day 06 数组

1. 数组

（1）概念

一个变量只能存储一个数据，如果我们有一组数据，比如1到100一百个数字，定义100个变量来存储就太痛苦了，这时候我们就需要数组来存储这样的数据。数组类似于数学概念中的中的集合。

（2）定义

​ 1）构造方法：使用new 在内存中开辟空间, 返回的是new出来空间的地址

var arr = new Array();//无参构造函数，创建一空数组
var arr = new Array(5);//创建指定长度的数组(由于数组长度可以动态调整，作用并不大)
var arr = new Array(1,2,'hello');//创建数组并初始化参数数据

​ 2) 字面量：使用方括号，与上面的new 是一样的，也会在内存中开辟空间

var arr = [ ];//等同于调用无参构造函数
var arr = [10];//等同于调用带有初始化数据的构造函数

（3）数组元素的访问

• 语法： 数组名[下标];

  • 下标base on zero， 下标最大取值是“长度-1”，千万不要越界（越界后的结果不是你想要的结果）
  • 下标是连续的整数
  • 下标可以是变量或表达式
  • 数组的长度：数组名.length 返回当前数组的长度

• 数组的修改

  数组名[下标]= 赋值;

  var arr = [5,7,9];
  arr['haha'] = 99;//如果对没有的下标元素进行赋值，则等价于添加新元素
  console.log(arr);//5，7，9，99

（4）数组的遍历

通常操作数组时，每个元素都要操作一遍，这个时候我们会用循环来访问每一个元素，循环访问数组的每一个元素的过程就叫做数组的遍历。

//1. 常规的for循环
for(var i=0;i<arr.length; i++){
    console.log(arr[i]);
}

 //2. for...in...遍历数据的下标
     for(var index in arr){
        // console.log(arr[index]);
        console.log(index);
    }

// 3. for...of...遍历内容
for(var item of arr){
    console.log(item);
}

（5）数组的逆序

<script>
    var arr=[5,6,3,7,8,4];
    for(var i=0; i<parseInt(arr.length/2);i++){
        // 交换元素
        var temp;
        temp = arr[i];
        arr[i] = arr[arr.length-i-1];
        arr[arr.length-i-1] = temp;
    }
    for(var i=0; i<arr.length;i++){
        console.log(arr[i]);
    }
</script>

（6）数组的常见函数

如何学习函数：关注3点

1. 函数的功能
2. 函数的参数
3. 函数的返回值

push 尾插 返回数组的新长度

• 数组名.push (参数1,[参数2...参数N]):
• 向数组的末尾添加一个或多个元素

var arr = [1,2,3];
var len = arr.push(4,5);
console.log(len);//5
console.log(arr);//1,2,3,4,5

pop 尾删 无参 返回被删元素

• 删除并返回数组的最后一个元素

var arr=[8,5,9];
var x = arr.pop();
console.log(x);//9
console.log(arr);//8,5

unshift 头插 返回数组的新长度

• 数组名.unshift(参数1,[参数2...参数N])
• 向数组的开头添加一个或多个元素，并返回新的长度

var arr = [6,5,7];
var a = arr.unshift(10,90);
console.log(a);//5
console.log(arr);//10,90,6,5,7

shift 头删 无参 返回被删元素

• 把数组的第一个元素从其中删除，并返回第一个元素的值

var arr=[1,2,3];
var x = arr.shift();
console.log(x);//1
console.log(arr);//2,3

splice 删除若干个元素或添加若干个元素

• splice(参数1, 参数2, 参数3) 返回一个由删除元素组成的新数组

  • 参数1 开始索引
  • 参数2 删除元素的位数
  • 参数3 插入的新元素，当然也可以写多个

join 通过参数连接成字符串

• 数组名.join([分隔符号])

• 将数组转为字符串 :返回值为转换后的字符串

  var arr=[4,7,3];
  console.log(arr.join('~'));//4~7~3

slice 截取子数组

• slice (起始位置，结束位置):返回截取的子数组 左闭右开

var arr=[4,6,7,4,6,5];
var arr1 = arr.slice(3,5);
console.log(arr1);//4, 6

concat 拼接数组

• concat(增加的数组): 返回一个新数组

  var arr1 = [6,7,5,8];
  var arr2 = [0,3,7];
  console.log(arr1.concat(arr2));//6,7,5,8,0,3,7

reverse() 将数组逆序

• 无参 无返回 与之前不同的是它会直接修改原数组

var arr=[5,7,8,9,3];
arr.reverse();
console.log(arr);//3,9,8,7,5

sort() 数组排序

• 用于对数组进行排序 (只能由小到大)
• 字符串比较，所以和我们预想的结果不同
• 返回排序后的数组， 且原数组发生改变

var arr=[9,7,8,5];
arr.sort();
console.log(arr);//5,7,8,9

var arr=[19,7,8,5];
arr.sort();
console.log(arr);//19, 5,7,8

二维数组（了解）

var arr = [[],[],[],[]];

随机函数

• Math.random();
• 无参,返回值为0~1的小数

排序

冒泡排序

• 趟次(外层循环)： N-1；
• 次（内层循环）：N-1-i; 内层循环两两交换

//使用冒泡法由小到大排列
<script type="text/javascript">
    var arr= [5,7,8,4,6,5,2,7];
    var temp;
    // 外层循环n-1次
    for(var i=0; i<arr.length; i++){
        // 内层循环n-i-1
        for(var j=0; j<arr.length-i-1;j++){
            //由小到大排列
            if(arr[j]>arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
    console.log(arr);//[2, 4, 5, 5, 6, 7, 7, 8]
</script>

选择排序

• 外层循环： n-1 次， k=i; 每趟只会交换一次a[k] a[i]

• 内层循环： n-i-1，

  • 但是内层循环应该从i+1开始; 如果a[k]>a[j] 小到大排序， 则更新k的值

<script type="text/javascript">
    var arr=[5,8,6,4,5,3,7,8];
    var temp;
    var k;
    // 外层n-1
    for(var i=0; i<arr.length-1;i++){
        k = i;
        // 内层循环次数为n-i-1, 但是内层应从i+1开始
        for(var j=i+1; j<arr.length; j++){
            // a[k]与当前的arr[j]比较
            // 由大到小排列
            if(arr[k]>arr[j]){
                k = j;
            }
        }
        // temp, a[i], a[k];
        temp = arr[i];
        arr[i] = arr[k];
        arr[k] = temp;
    }
    console.log(arr);
</script>