javascript---数组----

数组概述

什么是数组

存储一组或一系列相关数据的容器

//数组开辟空间是连续的；
//声明数组的关键字也是var；
//对存储的类型没有要求，对存储的数据多的时候才采用数组。 //数组为对象类型，用console.log会输出数组的详细信息。 //prototype：原型，是个属性。
//获取数组的长度：数组.length;

　　

  数组的好处

集中管理、访问速度和效率高



什么是下标

标识每一个空间唯一的索引号。
最小下标为0，最大为长度-1；

　　

如何定义数组？

json的方式（字面量的方式）；
```
var 数组名 = [1,2,3];
var arr = [];
arr[0] = 1;//[下标]
arr[1] = 2;
arr[2] = 3;
arr[3] = 4;
console.log(arr[0],arr[1],arr[3],arr[5]);//1,2,4,undefined;
```
构造函数的方式（Array是内置的构造函数）
```
var arr = [5];//数组元素为5
var list = new Array(5);//数组长度为5，且数值不能为负值
var list = new Array(3,4)//数组长度为2，且内部的元素为3.4
两者的区别 [1] 构造函数：如果只有一个参数是正整数时，表示数组长度。如果是负数或小数，报错。其他情况表示数组的元素。 json：里面是啥都行。
```
如何遍历数组？
```
//遍历数组进行赋值（使用循环语句进行赋值）
var arr = new Array(5);
for(var i = 0;i < 5;i++){
    arr[i] = prompt("请输入数据：");
}
console.log(arr);




//遍历数组单独输出元素
var arr = new Array(5);
for(var i = 0;i < 5;i++){
    arr[i] = prompt("请输入数据：");
}
for(var i = 0;i < arr.length; i ++){
    console.log(arr[i]);
}
```

　　

数组的属性

口诀：增删改截拼复排转

1.增 （1）前增：unshift(增加的元素); 作用：在数组的首部增加元素，返回新增后数组的长度，会影响原数组。

```
    var arr=["a","b","c","d","e"];
    console.log(arr.unshift(1,2,3,4));//前面增加的内容
    console.log(arr);//长度为9
    var arr=["a","b","c","d","e"];
    console.log(arr.unshift([1,2,3,4]));//前增一个数组。
    console.log(arr);//长度为6，返回值为[1,2,3,4],a,b,c,d]
    ```
（2）后增：push(增加的元素);
作用：在数组的尾部增加元素，返回新增后数组的长度，会影响原数组。

    ```
  var arr=["a","b","c","d","e"];
  console.log(arr.push(1,2,3,4));//尾部增加的内容
  console.log(arr);
  ```

　　

2、 删

（1）前删：shift();
作用：删除数组首部的元素，一次只能删除一个元素。返回值为被删除的元素，会影响源 数组
        var arr=["a","b","c","d","e"];
        console.log(arr.shift());
        console.log(arr);//b,c,d,f
        
        ```
（2）后删：pop()； 作用：删除数组尾部的元素，一次只能删除一个元素。返回值为被删除的元素，会影响源 数组

　　var arr=["a","b","c","d","e"]; console.log(arr.pop()); console.log(arr);//a,b,c,d

3、改

splice（start,length,新增元素，...）//start:从哪个下标开始；length：删除几个元素 作用：可以再数组任意位置删除、修改、增加、任意数量的元素。返回值返回被删除的元素数组，会影响原数组。

 　　var arr=["a","b","c","d","e"];
    console.log(arr.splice(1,2));
    console.log(arr);//a,d,e
    ```
    
    ```
    var arr=["a","b","c","d","e"];
    console.log(arr.splice(1,0,1,2));
    console.log(arr);//a,1,2,b,c,d,e

4、截

slice(开始下标，结束下标)；
作用：截取数组中指定位置的元素，返回被截取的新数组，不影响源数组

 　　var arr=["a","b","c","d","e"];
    console.log(arr.slice(2，4));
    console.log(arr);//截取c，d.包含开始不包含结束，左闭右开。
    
    var arr=["a","b","c","d","e"];
    console.log(arr.slice(4，2));
    console.log(arr);//截取到的是一个空数组。
    
    var arr=["a","b","c","d","e"];
    console.log(arr.slice(-4，-2));
    console.log(arr);//b,c.反过来走，e为-1，以此类推。
    ```

5、拼

    concat(新元素)
    作用：在指定数组后面拼接新的元素，返回拼接后的新数组，不影响原数组。

　　　var arr=["a","b","c","d","e"];
        console.log(arr.concart(-4，-2));
        console.log(arr);
        
     var arr=["a","b","c","d","e"];
            console.log(arr.concat([1,2,3,4]);
            console.log(arr) //拼接一个数组，会把数组中的每个数拿出来重新拼接，形成新的数组。

6、复（复制）

var arr=["a","b","c","d","e"];
var list = arr;
list[0] = 2;//会将原数组的相应值也进行修改，所以不能这么写。

var arr=["a","b","c","d","e"];
var list = [];
for(var i = 0,len = arr.length;i < len;i++){
    list[i] = arr[i];
}
list[0] = 1;
console.log(arr,list);

var arr=["a","b","c","d","e"];
var list = arr.slice(0);
list[0] = 1;
console.log(arr,list);

var arr=["a","b","c","d","e"];
var list = arr.concat();
list[0] = 1;
console.log(arr,list);

var arr=["a","b","c","d","e"];
var list = [];
for(var i = 0,len = arr.length;i < len;i++){
    list.push(arr[i]);
}
list[0] = 1;
console.log(arr,list);

7、排

（1）reverse();
    作用：逆序排列，将数组中的元素逆序存放，返回逆序后的数组，影响原数组。
    
    var arr = [100,20,30,3,34,14];
    console.log(arr.sort());//14,34,3,30,20,100
    console.log(arr);//14,34,3,30,20,100

（2）sort();
    作用：数组中的元素按字符串比较，从小到大排列，返回排序都得数组，影响原数组。
    
    var arr = [100,20,30,3,34,14];
    console.log(arr.sort());//100,14,20,3,30,34
    console.log(arr);//100,14,20,3,30,34

sort(function(a,b){return a - b;})
　　数组中的元素按数字比较从小到大排，返回排序后的数组，影响源数组.
　　var arr = [100,20,30,3,34,14];
　　console.log(arr.sort(function(a,b){return(a - b);}));//3,14,20,30,34,100
　　console.log(arr);//3,14,20,30,34,100

sort(function(a,b){return b - a;})
　　数组中的元素按数字比较从大到小排，返回排序后的数组，影响源数组。 姓名排序可以用到。
　　//从大到小
　　var arr = [100,20,30,3,34,14];
　　console.log(arr.sort(function(a,b){return(b - a);}));//100,34,30,20,14,3
　　console.log(arr);//100,34,30,20,14,3

　　

8、转

(1)toString():

　　用于数组，将数组转为字符串，字符串以逗号分隔，返回字符串，不会影响源数组。 用于变量，将变量中的数字转为指定的进制。

 //用于数组
    var arr = [100,20,30,3,34,14];
    console.log(arr.toString());
    console.log(arr);
    
    //用于变量
    var num = 300;
    alert(num.toString(2));//将300转为2进制的字符串。

(2)join(); 

　　作用：将数组转为指定分隔符的字符串，返回转换后的字符串，不影响源数组

    var arr = [100,20,30,3,34,14];
    console.log(arr.join());
    console.log(arr);

    //join可以加参数，加什么参数就以什么分隔。
    var arr = [100,20,30,3,34,14];
    console.log(arr.join(""));//每个字符中间以空串分隔。
    console.log(arr);
    //字符串比较规则：从左到右依次比较。

　　

排序算法（冒泡、选择）

冒泡排序：

冒泡排序的思想：相邻的两个数比较，如果满足条件，交换两个数的位置。

9 6 15 4 2
第一种：
从小到大第一轮比较：6 9 4 2 15//确认了最大值。
第二轮比较：6 4 2 9 //又找到第二大的值
第三轮比较：4 2 6
第四轮比较：2 4
即遍历出来的最大值不再参与下次遍历

//第一种写法
var arr = [9,6,15,4,2];
for(var i = 1 ;i < arr.length;i++){//控制比较的轮数
    for(var j = 0;j < arr.length - i;j ++){//遍历数组，取出元素与后面的相比较
        if(arr[j] > arr[j + 1]){//改成小于则为从大到小
            var t = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = t;
        }
    }
}
console.log(arr);

第二种思想：
9 6 15 4 2
第一轮比较：2 9 6 15 4//求出最小值
第二轮比较： 4 9 6 15
第三轮比较： 6 9 15
第四轮比较： 9 15

var arr = [9,6,15,4,2];
for(var i = 1;i < arr.length;i++){
    for(var j = arr.length;j >= i;j --){
        if(arr[j] < arr[j - 1]){
            var t = arr[j];
            arr[j] = arr[j - 1];
            arr[j - 1] = t;
        }
    }
 }

选择排序

选择思想：拿出一个数来，与其后面所有的数相比较。

9 6 15 4 2 第一轮比较：6 9 15 4 2
4 9 15 6 2
2 9 15 6 4 //求出最小值
第二轮比较：6 15 9 4
4 15 9 6
9 15 6 6 15 9
9 15 则为2 4 6 9 15

var arr = [9,6,15,4,2];
//从第一个开始遍历，到length - 2
for(var i = 0;i < length - 1;i++){
    //从i+ 1开始遍历，到length - 1
    for(var j = i + 1;j < arr.length; j++){
        if(arr[i]>arr[j]){
            var t = arr[i];
            arr[i] = arr[j];
            arr[j] = t;
            
        }
    }
}