JavaScript内置对象--Array

JavaScript提供了内部（或”内置”）对象。它们是Array、Boolean、 Date、 Error、 Function、 Global、 JSON、 Math、 Number、 Object、 RegExp 和String 共12个常用对象。
JavaScript内置的String对象就是字符串对象。

一、数组的创建

字面量方式（json方式）

var arr1 = [];                    //创建一个空数组
var arr2 = [5];                   //创建一个具有单个元素的数组
var arr3 = [5,6,7];               //创建一个具有多个元素的数组`

构造函数方式

var arr1 = new Array();          //创建一个空数组
var arr2 = new Array(5);         //创建一个长度为5，值为空的数组
var arr3 = new Array(5,6,7);     //创建一个具有多个元素的数组

数组的遍历

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

for…in循环

 var arr =[1,2,3,4,5];
 for(let key in arr){
 console.log(key);
 console.log(typeof key);
 }

二、数组的方法

1.push()：
功能：在数组的尾部增加数据，增加的数据是push的参数
参数：任意个，任意值
返回值：数组被增加之后的长度
有没有修改原数组：会修改原数组

var arr =["hello",3,4,5,"world"]  
var res = arr.push("a",3,4,5,"hahah");
console.log(res); //10

2.unshift()：
功能：在数组的头部增加数据，增加的数据是unshift的参数
参数：任意个，任意值
返回值：数组被增加之后的长度
有没有修改原数组：会修改原数组

var arr =["hello",3,4,5,"world"]  
var res = arr.unshift("a",3,4,5,"hahah");
console.log(res); //10

3.pop()：
功能：从数组尾部删除一个元素
参数：没有
返回值：被删除的数据
有没有修改原数组：会修改原数组

var arr =["hello",3,4,5,"world"]  
var res = arr.pop("a",3,4,5,"hahah");
console.log(res); //word

4.shift()：
功能：从数组头部删除一个元素
参数：没有
返回值：被删除的数据
有没有修改原数组：会修改原数组

var arr =["hello",3,4,5,"world"]  
var res = arr.shift("a",3,4,5,"hahah");
console.log(res); //hello

5.splice()：
功能：从数组中替换、删除或插入元素并返回新数组
参数：一个，表示索引，两个，第一个表示索引，第二个表示个数，从第三个开始向后，都是数据
返回值：被删除的数据
有没有修改原数组：会修改原数组

var arr2 = ["huahua",14,5,6]
document.write(arr2.splice(2,2))
//括号第一位表示从哪里删，第二位表示删除几位
document.write(arr2.splice(2,2,"hello"))
//第三位表示要增加的新元素
//结果：5,6
//结果：huahua，14，hello

6.reverse()：
功能：将数组的元素顺序变成倒序返回
参数：无
返回值：数组
有没有修改原数组：原数组被修改为倒序排列之后的数组

var arr =["hello",3,4,5,"world"]  
var res = arr.reverse("a",3,4,5,"hahah");//翻转数组
console.log(res); //[hahah，5,4，3，a]

7.join()：
功能：将数组元素连接在一起，并以字符串形式返回
参数：可选，指定元素之间的分隔符，没有参数则默认为逗号
返回值：字符串
有没有修改原数组：无

var arr =["hello",3,4,5,"world"]  
var res = arr.join("a",3,4,5,"hahah");//转成字符
console.log(res); 

8.slice()：
功能：从数组中截下若干个元素，组成新的数组并返回
参数：
返回值：数组
有没有修改原数组：无

var arr =["hello",3,4,5,"world"]
var res=arr.slice(3);
console.log(res);// [5, "world"]
//从指定索引开始截取，返回成一个新数组
var res = arr.slice(2,4); 
console.log(res);//[4, 5]
//从指定索引开始截取，截取到指定位置的前一个，返回成一个新数组
    

9.sort()：
功能：对数组元素进行排序并返回
参数：可选，排序的方法函数，没有参数则默认按照字典顺序排序
返回值：排序后的数组
有没有修改原数组：原数组被修改为排序之后的数组

 var numArr=[45,63,2456,163,79];//比大小
console.log(numArr);
//sort默认是字符的排序规则：诸位比较，得到结果就停止
//numArr.sort();
//修改：固定格式，传一个回调函数，被系统执行，不用管传哪
numArr.sort (function(a,b){
return a-b;
})
console.log(numArr);   

10.concat()：
功能：连接若干个数组
参数：若干个，可以是数组或者是元素
返回值：连接后的新数组
有没有修改原数组：无

var arr =["hello",3,4,5,"world"]
var arr1 =["a","b"];
var arr2 =[4,5];
//合并数组
var res = arr1.concat(arr2);
console.log(res);// ["a", "b", 4, 5]
// console.log(arr1);
// console.log(arr2);  

11.toString()：
功能：转换成字符串，类似于没有参数的join()。该方法会在数据发生隐式类型转换时被自动调用，如果手动调用，就是直接转为字符串。
参数：无
返回值：形成的字符串（二维数组中也只是连接二维数组的元素）
有没有修改原数组：无

    var arr = [1,2,3];
    console.log(arr.toString());     //1,2,3
    console.log(arr);                //[1,2,3]---原数组未改变

12.indexOf()：
功能：根据指定的数据，从左向右，查询在数组中出现的位置，如果不存在指定的数据，返回-1。该方法是查询方法，不会对数组产生改变。
参数：indexOf(value, start);value为要查询的数据；start为可选，表示开始查询的位置，当start为负数时，从数组的尾部向前数；如果查询不到value的存在，则方法返回-1
返回值：number，查找的项在数组中的位置，没有找到的情况下返回-1。
有没有修改原数组：无

var nums=[1,7,5,7,8,1,6,9];
var pos=nums.indexOf(7);
console.log(pos);//1
var pos=nums.indexOf(99);
console.log(pos);//-1

var pos=nums.indexOf(7,3);//从索引为3开始检测7的位置
console.log(pos);//3
		
var pos=nums.indexOf("7");
console.log(pos);//-1

13.lastIndexOf()：
功能：从数组的末尾开始向前查找
参数：lastIndexOf(value, start);value为要查询的数据；start为可选，表示开始查询的位置，当start为负数时，从数组的尾部向前数；如果查询不到value的存在，则方法返回-1
返回值：number，查找的项在数组中的位置，没有找到的情况下返回-1。
有没有修改原数组：无

 var arr = ["h","e","l","l","o"];
 console.log(arr.lastIndexOf("l"));        //3
 console.log(arr.lastIndexOf("l",3));      //3
 console.log(arr.lastIndexOf("l",1));      //-1
 console.log(arr.lastIndexOf("l",-3));     //2
 console.log(arr.lastIndexOf("l",-4));     //-1

14.valueOf()：
功能：返回数组的原始值（一般情况下其实就是数组自身），一般由js在后台调用，并不显式的出现在代码中
返回值：数组
有没有修改原数组：无

var arr = [1,2,3];
console.log(arr.valueOf());         //[1,2,3]
console.log(arr);                   //[1,2,3]
//为了证明返回的是数组自身
console.log(arr.valueOf() == arr);  //true

15.forEach()：
功能：ES5新增方法，用来遍历数组，该方法没有返回值。forEach接收的回调函数会根据数组的每一项执行，该回调函数默认有三个参数，分别为：遍历到的数组的数据，对应的索引，数组自身
参数：forEach(callback);callback默认有三个参数，分别为value，index，self
返回值：无
有没有修改原数组：无

  var arr = ["Tom","Jack","Lucy","Lily","May"];
    var a = arr.forEach(function(value,index,self){
        console.log(value + "--" + index + "--" + (arr === self));
    })
    // 打印结果为：
    // Tom--0--true
    // Jack--1--true
    // Lucy--2--true
    // Lily--3--true
    // May--4--true
    console.log(a);     //undefined---forEach没有返回值
    //该方法为遍历方法，不会修改原数组

16.map()：
功能：同forEach功能；2.map的回调函数会将执行结果返回，最后map将所有回调函数的返回值组成新数组返回。
参数：map(callback);callback默认有三个参数，分别为value，index，self
返回值：新数组
有没有修改原数组：无

 //功能1：同forEach
    var arr = ["Tom","Jack","Lucy","Lily","May"];
    var a = arr.map(function(value,index,self){
        console.log(value + "--" + index + "--" + (arr === self))
    })
    // 打印结果为：
    // Tom--0--true
    // Jack--1--true
    // Lucy--2--true
    // Lily--3--true
    // May--4--true

    //功能2：每次回调函数的返回值被map组成新数组返回
    var arr = ["Tom","Jack","Lucy","Lily","May"];
    var a = arr.map(function(value,index,self){
        return "hi:"+value;
    })
    console.log(a);     //["hi:Tom", "hi:Jack", "hi:Lucy", "hi:Lily", "hi:May"]
    console.log(arr);   //["Tom", "Jack", "Lucy", "Lily", "May"]---原数组未改变

17.filter()：
功能：同forEach功能；2.map的回调函数会将执行结果返回，最后map将所有回调函数的返回值组成新数组返回。同forEach功能；2.filter的回调函数需要返回布尔值，当为true时，将本次数组的数据返回给filter，最后filter将所有回调函数的返回值组成新数组返回（此功能可理解为“过滤”）
参数：filter(callback);callback默认有三个参数，分别为value，index，self
返回值新数组
有没有修改原数组：无

 //功能1：同forEach
    var arr = ["Tom","Jack","Lucy","Lily","May"];
    var a = arr.filter(function(value,index,self){
        console.log(value + "--" + index + "--" + (arr === self))
    })
    // 打印结果为：
    // Tom--0--true
    // Jack--1--true
    // Lucy--2--true
    // Lily--3--true
    // May--4--true

    //功能2：当回调函数的返回值为true时，本次的数组值返回给filter，被filter组成新数组返回
    var arr = ["Tom","Jack","Lucy","Lily","May"];
    var a = arr.filter(function(value,index,self){
        return value.length > 3;
    })
    console.log(a);         //["Jack", "Lucy", "Lily"]
    console.log(arr);       //["Tom", "Jack", "Lucy", "Lily", "May"]---原数组未改变

18.every()：
功能：判断数组中每一项是否都满足条件，只有所有项都满足条件，才会返回true
参数：every()接收一个回调函数作为参数，这个回调函数需要有返回值，every(callback);callback默认有三个参数，分别为value，index，self
返回值：
有没有修改原数组：无
功能1：当回调函数的返回值为true时，类似于forEach的功能，遍历所有；如果为false，那么停止执行，后面的数据不再遍历，停在第一个返回false的位置

 //demo1:
    var arr = ["Tom","abc","Jack","Lucy","Lily","May"];
    var a = arr.every(function(value,index,self){
        console.log(value + "--" + index + "--" + (arr == self))
    })
    // 打印结果为：
    // Tom--0--true
    //因为回调函数中没有return true，默认返回undefined，等同于返回false

    //demo2:
    var arr = ["Tom","abc","Jack","Lucy","Lily","May"];
    var a = arr.every(function(value,index,self){
        console.log(value + "--" + index + "--" + (arr == self))
        return value.length < 4;
    })
  // 打印结果为：
    // Tom--0--true
    // abc--1--true
    // Jack--2--true
    //因为当遍历到Jack时，回调函数到return返回false，此时Jack已经遍历，但是后面数据就不再被遍历了

    //demo3:
    var arr = ["Tom","abc","Jack","Lucy","Lily","May"];
    var a = arr.every(function(value,index,self){
        console.log(value + "--" + index + "--" + (arr == self))
        return true;
    })
    // 打印结果为：
    // Tom--0--true
    // abc--1--true
    // Jack--2--true
    // Lucy--3--true
    // Lily--4--true
    // May--5--true
    //因为每个回调函数的返回值都是true，那么会遍历数组所有数据，等同于forEach功能

功能2：当每个回调函数的返回值都为true时，every的返回值为true，只要有一个回调函数的返回值为false，every的返回值都为false

    var arr = ["Tom","abc","Jack","Lucy","Lily","May"];
    var a = arr.every(function(value,index,self){
        return value.length > 3;
    })
    console.log(a);           //false

    //demo2:
    var arr = ["Tom","abc","Jack","Lucy","Lily","May"];
    var a = arr.every(function(value,index,self){
        return value.length > 2;
    })
    console.log(a);           //true

19.some()：
功能：判断数组中是否存在满足条件的项，只要有一项满足条件，就会返回true
参数：some()接收一个回调函数作为参数，这个回调函数需要有返回值，some(callback);callback默认有三个参数，分别为value，index，self。
功能1：因为要判断数组中的每一项，只要有一个回调函数返回true，some都会返回true，所以与every正好相反，当遇到一个回调函数的返回值为true时，可以确定结果，那么停止执行，后面都数据不再遍历，停在第一个返回true的位置；当回调函数的返回值为false时，需要继续向后执行，到最后才能确定结果，所以会遍历所有数据，实现类似于forEach的功能，遍历所有。

  //demo1:
    var arr = ["Tom","abc","Jack","Lucy","Lily","May"];
    var a = arr.some(function(value,index,self){
        console.log(value + "--" + index + "--" + (arr == self))
        return value.length > 3;
    })
    // 打印结果为：
    // Tom--0--true
    // abc--1--true
    // Jack--2--true

    //demo2:
    var arr = ["Tom","abc","Jack","Lucy","Lily","May"];
    var a = arr.some(function(value,index,self){
        console.log(value + "--" + index + "--" + (arr == self))
        return true;
    })
     // 打印结果为：
    // Tom--0--true

    //demo3:
    var arr = ["Tom","abc","Jack","Lucy","Lily","May"];
    var a = arr.some(function(value,index,self){
        console.log(value + "--" + index + "--" + (arr == self))
        return false;
    })
    // 打印结果为：
    // Tom--0--true
    // abc--1--true
    // Jack--2--true
    // Lucy--3--true
    // Lily--4--true
    // May--5--true

功能2：与every相反，只要有一个回调函数的返回值都为true，some的返回值为true，所有回调函数的返回值为false，some的返回值才为false

  var arr = ["Tom","abc","Jack","Lucy","Lily","May"];
    var a = arr.some(function(value,index,self){
        return value.length > 3;
    })
    console.log(a);             //true

    //demo2:
    var arr = ["Tom","abc","Jack","Lucy","Lily","May"];
    var a = arr.some(function(value,index,self){
        return value.length > 4;
    })
    console.log(a);             //false