for 和 for in 循环

因为数组的索引就可以获取数组中的内容
数组的索引有事按照 0 ~ n 顺序排序
我们就可以使用 for循环来循环数组，因为 for循环我们也可以设置值成 0 ~ n顺序增加
我们把这个行为叫做遍历

var arr = [1,2,3,4,5]

//使用 for 循环遍历数组
for (var i = 0; i < arr.length; i++){
    
    
    console.log(arr[i])
}

//会在控制台一次打印出 1,2,3,4,5

i < arr .length因为 length就是数组的长度，是一个数字，所以我们可以直接用它来决定循环次数
console.log(arr[i])因为随之循环，i的值会从 0 开始一次增加
所以我们实际上就相当于在打印arr[0] / arr[1] / …
因为对象是没有索引的，所以我们没有办法使用for in 循环来遍历对象
先来看一段代码

var obj = {
    
    
name:'jack';
age: 18
}

for (var key in obj){
    
    
   console.log(key)
}
//会在控制台打印两次内容，分别 name 和 age

for in循环的遍历是按照对象中有多少成员来决定了
有多少成员，就会执行多少次
key是我们自己定义的一个变量，就和 for循环的时候我们定义的 i 一个道理
在每次循环的过程中， key 就代表着对象中某一个成员的 属性名

数组的排序

排序，就是把一个乱序的数组，通过我们的处理，让他变成一个有序的数组
今天我们讲解两种方式来排序一个数组 冒泡排序 和 选择排序

冒泡排序

先遍历数组，让挨着的两个进行比较，如果前一个比后一个大，那么就把两个换个位置
数组遍历一遍以后，那么最后一个数字就是最大的那个了
然后进行第二遍的遍历，还是按照之前的规则，第二大的数字就会跑到倒数第二的位置
以此类推，最后就会按照顺序把数组排好了

1.我们先来准备一个乱序的数组

var arr = [3, 1, 5, 6, 4, 9, 7, 2, 8]

接下来我们就会用代码让数组排序

2.先不着急循环，先来看数组里面内容换个位置

//假设我们现在要让数组中的第 0 项 和 第 1 项换个位置
//需要借助第三个变量
var tmp = arr[0]
arr[0] = arr[1]
arr[1] = tmp

3.第一次遍历数组，把最大的放到最后面去

for (var i = 0; i < arr.length; i++){
    
    
//判断，如果数组中的当前一个比后一个大，那么两个交换一下位置
if (arr[i] > arr[i + 1]) {
    
    
   var tmp = arr[i]
   arr[i] = arr[i + 1]
   arr[i + 1] = tmp
  }
}

// 遍历完毕以后，数组就会变成 [3, 1, 5, 6, 4, 7, 2, 8, 9]

第一次结束以后，数组中的最后一个，就会是最大的那个数字
然后我们把上面的这段代码执行多次。数组有多少项就执行多少次

4.按照数组的长度来遍历多少次

for (var j = 0; j < arr.length; j++) {
    
    
  for (var i = 0; i < arr.length; i++) {
    
    
    // 判断，如果数组中的当前一个比后一个大，那么两个交换一下位置
    if (arr[i] > arr[i + 1]) {
    
    
      var tmp = arr[i]
      arr[i] = arr[i + 1]
      arr[i + 1] = tmp
    }
  }
}

//结束以后，数组就排序好了

5.给一些优化

想象一下问题，假设数组长度是 9，第八次排完以后
后面八个数字已经按照顺序排列好了，剩下的那个最小的一定是在最前面
那么第九次就已经没有意义了，因为最小的已经在最前面了，不会再有任何换位置出现了
那么我们第九次遍历就不需要了，所以我们可以减少一次

for (var j = 0; j < arr.length - 1; j++) {
    
    
  for (var i = 0; i < arr.length; i++) {
    
    
    // 判断，如果数组中的当前一个比后一个大，那么两个交换一下位置
    if (arr[i] > arr[i + 1]) {
    
    
      var tmp = arr[i]
      arr[i] = arr[i + 1]
      arr[i + 1] = tmp
     }
   }
}

第二个问题，第一次的时候，已经把最大的数字放在最后面了
那么第二次的时候，其实倒数第二个和最后一个就不用比了
因为我们就是要把倒数第二大的放在倒数第二的位置，即使比较了，也不会换位置
第三次就要倒数第三个数字就不用再和后两个比较了
以此类推，那么其实每次遍历的时候，就遍历 当前次数 - 1 次

for (var j = 0; j < arr.length - 1; j++) {
    
    
   for (var i = 0; i < arr.length - 1 - j; i++) {
    
    
     // 判断，如果数组中的当前一个比后一个大，那么两个交换一下位置
     if (arr[i] > arr[i + 1]) {
    
    
        var tmp = arr[i]
        arr[i] = arr[i + 1]
        arr[i + 1] = tmp
      }
   }
}

6.至此，一个冒泡排序就完成了

选择排序

先假定数组中的第 0 个就是最小的数字的索引
然后遍历数组，只要有一个数字比我小，那么就替换之前记录的索引
知道数组遍历结束后，就能找到最小的那个索引，然后让最小的索引换到第 0 个的位置
再来第二趟遍历，假定第 1 个是最小的数字的索引
在遍历一次数组，找到比我小的那个数字的索引
遍历结束后换个位置
依次类推，也可以把数组排序好
准备一个数组
```
var arr = [3, 1, 5, 6, 4, 9, 7, 2, 8]
```
假定数组中的第 0 个是最小数字的索引
```
var minIndex = 0
```

遍历数组，判断，只要数字比我小，那么就替换掉原先记录的索引

var minIndex = 0
for (var i = 0; i < arr.length; i++) {
      
      
  if (arr[i] < arr[minIndex]) {
      
      
     minIndex = i
   }
 }
 // 遍历结束后找到最小的索引
 // 让第 minIndex 个和第 0 个交换
 var tmp = arr[minIndex]
 arr[minIndex] = arr[0]
 arr[0] = tmp

按照数组的长度重复执行上面的代码

for (var j = 0; j < arr.length; j++) {
      
      
  // 因为第一遍的时候假定第 0 个，第二遍的时候假定第 1 个
  // 所以我们要假定第 j 个就行
  var minIndex = j

  // 因为之前已经把最小的放在最前面了，后面的循环就不需要判断前面的了
  // 直接从 j + 1 开始
  for (var i = j + 1; i < arr.length; i++) {
      
      
     if (arr[i] < arr[minIndex]) {
      
      
        minIndex = i
      }
   }

    // 遍历结束后找到最小的索引
    // 第一堂的时候是和第 0 个交换，第二趟的时候是和第 1 个交换
    // 我们直接和第 j 个交换就行
    var tmp = arr[minIndex]
    arr[minIndex] = arr[j]
    arr[j] = tmp
 }

一些优化
和之前一样，倒数第二次排序完毕以后，就已经排好了，最后一次没有必要了

for (var j = 0; j < arr.length - 1; j++) {
    
    
  var minIndex = j

  for (var i = j + 1; i < arr.length; i++) {
    
    
     if (arr[i] < arr[minIndex]) {
    
    
        minIndex = i
      }
  }

  var tmp = arr[minIndex]
  arr[minIndex] = arr[j]
  arr[j] = tmp
}

在交换变量之前，可以判断一下，如果我们遍历后得到的索引和当前的索引一直
那么就证明当前这个就是目前最小的，那么就没有必要交换
做一我们要判断，最小作引和当前作引不一样的时候，才交换

for (var j = 0; j < arr.length - 1; j++) {
    
    
  var minIndex = j

  for (var i = j + 1; i < arr.length; i++) {
    
    
    if (arr[i] < arr[minIndex]) {
    
    
      minIndex = i
    }
 }

 if (minIndex !== j) {
    
    
   var tmp = arr[minIndex]
   arr[minIndex] = arr[j]
   arr[j] = tmp
  }
}

至此，选择排序完成

函数参数传递基本数据类型和复杂数据类型的区别

之前我们知道了，基本数据类型和复杂数据类型在存储上是有区别的
那么他们在赋值之间也是有区别的
基本数据类型之间的赋值

var num = 10
var num2 = num

num2 = 200

console.log(num) // 100
console.log(num2) // 200

相当于是把 num 的值复制了一份一摸一样的给了 num2 变量
赋值以后两个在没有关系
复杂数据类型之间的赋值

var obj = {
    
    
  name: 'Jack'
}
var obj2 = obj

obj2.name = 'Rose'

console.log(obj.name) // Rose
console.log(obj2.name) // Rose

因为复杂数据类型，变量存储的是地址，真实内容在堆空间内存储
所以赋值的时候相当于把 obj 存储的那个地址复制了一份给到了 obj2 变量
现在 obj 和 obj2 两个变量存储的地址一样，指向一个内存空间
所以使用 obj2 这个变量修改空间内的内容， obj 指向的空间也会跟着改变了

基本数据类型

1.基本数据类型变量存的是值
2.基本数据类的变量存储在栈内存
3.基本数据类型的变量和变量互不影响

 var a = 10;
    var b = a;
    b = 20;
    console.log(a); // 10
    console.log(b);// 20

function fn1(a) {
    
    
        a = 10;
    }
    var a = 20;
    fn1(a);
    console.log(a); // 20 //基本数据类型作为参数传递

引用数据类型

1.引用数据类型的变量存储的是地址值
2.基本数据类的变量存储在堆内存
3.引用数据类型的变量如果和另外一个引用数据类型的变量公用一个地址，
其中一个变化，另外一个也会受到影响

var arr = [12, 34, 21]
    var arr1 = arr; // 将arr的地址值赋值给arr1
    arr[0] = 10;
    console.log(arr1); // [10,34,21]
    console.log(arr);// [10,34,21]

function fn(arr) {
    
    
        arr[0] = 10;
    }
    var arr = [12, 43, 1]
    fn(arr);
    console.log(arr); //[10,43,1]  
    // 引用数据类型作为参数传递

函数的参数

函数的参数也是赋值的之中，在函数调用的时候，实参给行参赋值
和之前变量赋值的规则是一样的
函数传递基本数据类型

【JavaScript】学习第七天（冒泡排序、选择排序）（基本数据类型、引用数据类型）

for 和 for in 循环

数组的排序

冒泡排序

选择排序

函数参数传递基本数据类型和复杂数据类型的区别

基本数据类型

引用数据类型

函数的参数

Guess you like