JavaScript之数组

1.数组的概念（引用类型）

除了 Object 类型之外，Array 类型是ECMAScript 最常用的类型。而且 ECMAScript 中的Array 类型和其他语言中的数组有着很大的区别。 虽然数组都是有序排列，但ECMAScript中的数组可以保存任何类型的数据，ECMAScript 中数组的大小也是可以调整的。
数组：一组任意类型或者相同类型的数据。
123,true,‘hello’,function(){alert(2)},null,undefined

2.数组的创建(两种方式) ‘’

（1）构造函数创建数组：new 运算符
构造函数构建对象：必须通过new调用，首字母大写
构造函数的特点：
a:构造函数的首字母必须大写，用来区分于普通函数
b:内部使用的this对象，来指向即将要生成的实例对象
c:使用New来生成实例对象
注意：给构造函数传递一个值也可以创建数组。如果传递的是数字，则会按照该数自创建包含给定项数的数组（该数组的项数等于该数字）；而如果传递的是其他类型的参数，则会创建包含那个值的只有一项的数组（该数组只有这一项）。

var shuzu=new Array(123,true,'hello',function(){alert(2)},null,undefined);

（2）字面量创建数组

在计算机科学中，字面量是用于表达源代码中一个固定值的表示法。

var shuzu1=[123,true,'hello',function(){alert(2)},null,undefined];

构造的数组写入的数据，虽然没有类型要求，什么类型的数据都可以写入，但是各个数据必须符合数据类型要求否则会报错，比如字符串要加‘’。

  var shuzu = [nihao, 12, null, undefined, Function, Object, 12]
        console.log(shuzu)//报错，Uncaught ReferenceError: nihao is not defined

比较构造函数创建和字面量创建数组的区别：
构造函数创建数组，如果里面的值只有一项，而且是数字，这个数字代表数组的长度。
字面量创建的数组，如果里面的值只有一项，数组的长度和数组里的存入数据的个数相同

var arr=[123];
var arr1=new Array(123);
alert(arr.length);//输出数组的长度  1
alert(arr1.length);//输出数组的长度 123
    

要是两者创建的数组都不止一项且不是数字
，那么数组的长度就等于数组的个数

var a1=new Array('hello');//1
var a2=['hello'];//1

3数组的操作（length和下标操作）

（1）arguments对象是类数组(具有：length和下标编号)；
arguments对象不是一个 Array 。它类似于Array，但除了length属性和索引元素之外没有任何Array属性。只能在函数内部使用
（2）数组的length属性：数组的长度，可读写的。通过设置这个属性，可以从数组的末尾移除项或向数组中添加新项。
读：读取数组的长度
数组名等于数组的所有值，读取数组的所有内容：console.log(arr)，
读取数组长度： console.log(arr.length)

var arr=['apple','banana','orange','pear'];
alert(arr);//数组名等于数组的所有的值。
console.log(arr);//数组名等于数组的所有的值。["apple", "banana", "orange", "pear"]

写：更改数组的长度
增加数组的长度：arr.length=100;
减小数组的长度：arr.length=2;

 var arr=['apple','banana','orange','pear'];
alert(arr);//数组名等于数组的所有的值。
console.log(arr);//数组名等于数组的所有的值。["apple", "banana", "orange", "pear"]
 console.log(arr.length);//4
arr.length=100;//增加数组的长度，在原有数组内数值的基础上，添加96个空位置
console.log(arr);
arr.length=2;//减小数组的长度，在原有数组内数值的基础上，截取前两个数据
 console.log(arr);//["apple", "banana"]

（3）使用索引下标来读取数组的值–下标是固定的，从0开始,可读写的.
读：通过下标访问数组里的任何一个数据，如果访问的下标超出了数组的本身长度，那么会出现undefined

 var arr=['apple','banana','orange','pear'];
console.log(arr[1]);//banana
console.log(arr[2]);//orange
 console.log(arr[10]);//undefined

写：通过下标，更改或者添加数组里的任何一个数据

 var arr=['apple','banana','orange','pear'];
console.log(arr);//["apple", "banana", "orange", "pear"]
 arr[10]='hehe';
console.log(arr);//["apple", "banana", "orange", "pear", empty × 6, "hehe"]
arr[0]='javascript';
console.log(arr);//['javascript','banana','orange','pear']

（4）核心的应用：通过length和索引随机产生数组项的值
数组的随机索引：parseInt(Math.random()*arr.length);

var arr=['apple','banana','orange','pear','grape'];
console.log(arr[parseInt(Math.random()*arr.length)]);//随机获取数组的下标，然后获得数据输出

（5）如何检测数组
用typeof无法确定数组类型，typeof array==object，很多都是object类型，所以无法作为判断的标准

 array = [];
        alert(typeof array)//object

        var a=null;
        var b=[1,2,3];
        console.log(typeof a);//object
        console.log(typeof b);//object

静态方法：（构造函数名开始的。）
Array.isArray()：确定括号中的某个值到底是不是数组（返回值为布尔值）

var a=null;
var b=[1,2,3];
console.log(Array.isArray(a));//false
console.log(Array.isArray(b));//true

（6）数组的遍历-for循环-数组下标是有序的，用for循环进行遍历
数组的下标是-固有的，都是数字，从0开始

var arr=['apple','banana','orange','pear','grape'];
for(var i=0;i<arr.length;i++){//i:数组的每一项的索引下标 
console.log(arr[i]);
        }

3.数组的方法

push()

可以接收任意数量的参数，把它们逐个添加到数组末尾，并返回修改后数组的长度。（更改原数组）(重点)

var arr = [1, 2, 3]；
console.log(arr.push('a', 'b', 'c'))//返回修改后的数组长度6，不写输出不会显示6，不显示修改后的数组所有项
console.log(arr)//输出显示修改后的数组所有项[1, 2, 3，'a', 'b', 'c']

pop()

从数组末尾移除最后一项，减少数组的length值，然后返回移除的项。（更改原数组）（重点）
利用此方法可以清空数组

 var arr = [1, 2, 3]；
console.log(arr.pop()))//返回删除的那一项3，必须写输出，否则无法看到删除的那一项
   console.log(arr)//[1,2]

unshift()

方法能够在数组前面添加任意个项并返回新数组的长度。

 var arr = [1, 2, 3]
 console.log(arr.unshift('a'))//返回修改后的数组长度4，不写输出无法显示4，不显示更改后的数组所有项
 console.log(arr)//["a", 1, 2, 3]

shift()

方法能够移除数组中的第一个项并返回该项，同时将数组长度减 1。
利用此方法可以清空数组

 var arr = [1, 2, 3]
 console.log(arr.shift())//返回移出的数组第一项1，不写输出，无法看到移出的1
 console.log(arr)//[2,3]

reverse()

方法会反转数组项的顺序。

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

sort()

方法按字母表升序排列数组项（重点）
.sort():按字母表升序排列数组项-unicode编码

0-9  48-57
a-z  97-122
 A-Z  65-90
 var arr = ['banana', 'apple', 'pear', 'orange', 'grape'];
console.log(arr.sort());//输出['apple','banana','orange','pear','grape']

注意：如果按照其他方式而非字母表顺序进行数组排列，必须给sort方法传递一个比较函数做参数。
例

var arrnum = [9, 5, 63, 6, 12, 7, 4, 100, 8, 0];
console.log(arrnum.sort())//输出为[0,100,12,4,5,6,63,7,8,9]

此数组用sort（）方法按照字母表排序的结果如上，但要是按照从小到大的顺序排序，必须给sort方法传递一个比较做函数参数
比较函数有两种：

//第一种
function compare1(a,b){
        if(a>b){
            return 1;
        }else if(a<b){
            return -1
        }else{
            return 0;
        }
    }
//第二种
 function compare2(a,b){
 return b-a;
}

  var arrnum = [9, 5, 63, 6, 12, 7, 4, 100, 8, 0];
        console.log(arrnum.sort()) //输出为[0,100,12,4,5,6,63,7,8,9]
        function compare(a, b) {
            return b - a;//(b-a为降序，a-b为升序)
        }
        console.log(arrnum.sort(compare2))//降序[100.63,12,9,8,7,6,5,4,0]

例：有一个从小到大排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。

function compare(a, b) {
            return a - b;
        }
        var arr = [1, 3, 5, 7, 9];
        arr.push(6);
        console.log(arr.sort(compare))
//可以改为
   var arr = [1, 3, 5, 7, 9];
        arr.push(6);
        console.log(arr.sort( function(a, b) {
            return a - b;
        }))

concat()

方法可以基于当前数组中的所有项创建一个新数组，参数可以是数组项或者数组

var arr = [‘begin’];
var arr1 = [‘hello’, ‘hi’];
var newarr = arr.concat(123, true, arr, arr1);
console.log(arr);//
console.log(newarr)// [“begin”, 123, true, “begin”, “hello”, “hi”]

slice()

方法它能够基于当前数组中的一或多个项创建一个新数组。可以接受一或两个参数，即要返回项的起始和结束位置，不包括结束位置,不改变原数组，输出的是创建的新数组。

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
console.log(arr.slice(1, 4)); //[2,3,4]两个参数第一个是起始位置（下标），第二个是结束位置（下标）
console.log(arr.slice(1)); //[ 2, 3, 4, 5, 6, 7, 8, 9, 10]一个参数是起始位置，结束位置是数组的最后一个
console.log(arr.slice(2, -5)) //[3,4,5]，负数从后往前数
console.log(arr.slice(2, -50))//[]，超出范围，为空

`

splice()

` 方法，对数组进行删除、插入、替换，是最强大的数组方法，返回值是数组，改变原数组。（重点）
参1：起始的索引位置 参2：截取的长度 参3开始代码要插入的数组项。
返回值就是截取的组数项,返回值也是数组
（1）删除

  var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
        console.log(arr.splice(2, 5)) // [3, 4, 5, 6, 7]这是删除的数组
        console.log(arr)//[1, 2, 8, 9]这是删除后的原数组，被改变了

（2）替换

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]  
console.log(arr.splice(2, 5, 'hihi', 'haha', 'hehe')); //输出截取的内容[3, 4, 5, 6, 7]
console.log(arr) //[1, 2, "hihi", "haha", "hehe", 8, 9]

（3）插入

  var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
console.log(arr.splice(2, 0, 'hihi', 'haha', 'hehe')); //[]没有截取，所以为空数组
console.log(arr) // [1, 2, "hihi", "haha", "hehe", 3, 4, 5, 6, 7, 8, 9]

join()

将数组转换成对应的字符串。参数就是连接符。（重点）
核心应用：将数组和字符串进行相互转换，意味数组能够使用字符串的方法，字符串也能够使用数组的方法。

 var arr = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
 console.log(arr.join('#'))//a#b#c#d#e#f#g

indexOf()

返回要查找的项在数组中的索引位置，没找到的情况下返回-1。（两个参数：要查找的项和（可选的）表示查找起点位置的索引）
indexOf() 方法从数组的开头开始向后查找。有两个参数，indexOf(参数1，参数2)
参数1：要查找的项；参数2：查找起点位置的索引

var arr = ['a', 'b', 'c', 'd', 'e', 'a', 'b', 'c'];
        console.log(arr.indexOf('c')) //2
        console.log(arr.indexOf('e', 2)) //4
        console.log(arr.lastIndexOf('c')) //7
        console.log(arr.indexOf('p')) //-1
        console.log(arr.indexOf('b', 20)) //-1
        console.log(arr.indexOf('d', -6)) //3，查找位置索引是-6，从后往前数，，也就是从正数第三个数开始找'd',找到返回所在索引
        console.log(arr.indexOf('d', -4)) //-1,查找位置索引是-4，从后往前数，，也就是从正数第四个数开始找'd',找不到返回-1

应用：数组去重
数组去重。返回要查找的项在数组中的索引位置，没找到的情况下返回-1。

var arr = [12, 35, 68, -2, 0, 123, -23, 250, 56, 68, 45, 100, 68, -2, 0, 123];
var newarr=[];
for(var i=0;i<arr.length;i++){
if(newarr.indexOf(arr[i])==-1){//arr[i]不存在新数组里面。
newarr.push(arr[i]);
}
}
console.log(arr);
console.log(newarr);

lastIndexOf()

方法则从数组的末尾开始向前查找。

every()

对数组中的每一项运行给定函数，如果该函数对每一项都返回 true（每一项都得满足） ，则返回 true 。

  var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
        var result = arr.every(function(value, index, arr) {
            return value > 0;
        })
        console.log(result) //true

some()

对数组中的每一项运行给定函数，如果该函数对任意一项返回 true（任意一项满足即可） ，则返回 true 。
可以应用找一个数组里有没有某个数

  var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
        var result = arr.some(function(value, index, arr) {
            return value > 9;
        })
        console.log(result) //true

应用：检测数组内某个数字重复了几次

 console.log(arr.some(function(v, i, a) {
            if (v == 12) {
                time++
            }

        }))
        console.log('12' + '重复了' + time + '次')
        //for循环
        var time = 0;
        for (var i = 0; i < arr.length; i++) {

            if (arr[i] == 12) {
                time++
            }
        }
        console.log('12' + '重复了' + time + '次')

filter()

对数组中的每一项运行给定函数，返回该函数结果为 true 的项组成的数组。（组成新数组）

 var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
        var result = arr.filter(function(value, index, arr) {
            return value > 9;
        })
        console.log(result) //[10]

应用：数组去重

 var arr = [12, 35, 35, -2, 0, 123, -23, 250, 56, 68, 45, 100, 68, -2, 0, 123];
        console.log(arr.filter(function(value, index, array) {
            return array.indexOf(value) == index;
        }));

map()

对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。
返回就是数组，不考虑true或者false；

var arr = [1, 3, 2, 5, 4, 3, 6, 7, 12, 6, 9, 10]
        var result1 = arr.map(function(value, index, array) {
            return value//遍历了数组的所有数值，组成数组返回
        })
         var result2 = arr.map(function(value, index, array) {
            return value*3//遍历了数组的所有数值并改变了原数组的值，组成数组返回
        })
        var result2 = arr.map(function(value, index, array) {
            return value > 3//此处进行了判断，返回判断的结果组成数组返回
        })
        console.log(result1)//直接返回遍历后的数值， [1, 3, 2, 5, 4, 3, 6, 7, 12, 6, 9, 10]
        console.log(result2)//将遍历的数值改变后返回[3, 9, 6, 15, 12, 9, 18, 21, 36, 18, 27, 30]
        console.log(result3)//返回判断后的结果，组成数组[false, false, false, true, true, false, true,所有结果 true, true, true, true, true]

forEach()

对数组中的每一项运行给定函数。这个方法没有返回值。
取代for循环，没有返回值。

var arr = [1, 3, 2, 5, 4, 3, 6, 7, 12, 6, 9, 10]
 var result = arr.forEach(function(value, index, array) {

            console.log(value)//此处会输出arr里的所有值，因为遍历了，但是不会返回给result，没有返回值
        })
        console.log(result)//undefined,没有返回值，输出不了值

reduce()

从数组的第一项开始，逐个遍历到最后。
两个参数：每一项上调用的函数和（可选的）作为归并的初始值。
调用的函数接收 4 个参数：前一个值、当前值、项的索引和数组对象。
只有一个参数：调用的函数

 var arr = [1, 3, 2, 5, 4, 3, 6, 7, 12, 6, 9, 10]
        var result = arr.reduce(function(prevalue, nextvalue, index, array) {
           // return prevalue * 10 + nextvalue//可以对该数组进行任何操作，该方法的核心是迭代和返回最终值
             console.log(prev + '|' + next);
              return prevalue + nextvalue
        })
        console.log(result)//55
//1|2 初始值默认为1=prevalue(因为没设置迭代的初始值))；nextvalue：2
//3|3
//6|4
//10|5
//15|6
//21|7
//28|8
//36|9
//45|10
//55

有两个参数：参数1：函数；参数2：迭代的初始值

 var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
        var result = arr.reduce(function(prev, next, index, array) {
            console.log(prev + '|' + next);
             return prev + next
        }, 100)
        console.log(result)//155,将100作为迭代的初始值，此时
//100|1//100为初始值=prev；next=1
//101|2
//103|3
//106|4
//110|5
//115|6
//121|7
//128|8
//136|9
//145|10
//155

reduceRight()

方法从数组的最后一项开始，向前遍历到第一项。除了迭代顺序，其他和reduce相同

  var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
        var result = arr.reduceRight(function(prevalue, nextvalue, index, array) {
            console.log(prevalue + '|' + nextvalue)
            return prevalue + nextvalue
        })
        console.log(result)
//10|9，从后开始迭代，初始默认为（因为没设置）prevalue=10；nextvalue：9
//19|8
//27|7
//34|6
//40|5
//45|4
//49|3
//52|2
//54|1
//55