js数组

1.特点

	数组的长度可以动态修改（length ）
	数组中的元素可以使用任意数据类型
	length可以返回当前数组长度，也可以设置数组长度

2.创建数组

1.数组字面量

var arr=[null,undefined,true,0,function(){},{}];
var arr=[]//创建空数组

2.构造函数

  1.var arr=new Array();//调用array构造函数  空数组
  2.var arr=new Array(10);//数组长度为10
       创建一个数组，并且数组长度为10
  3.var arr=new Array("hello",20,true);//数组元素为hello 20 ture
       创建一个以参数为数组项的数组

3.访问数组元素

	数组下标：从0开始
	[1,2,3,4]{0:1,1:2,2:3}

	arr[3]://访问arr数组中的第4个数据
	arr.length=10;
		将数组长度设置为10，如果原数组长度小于10，相当于将原数组的长度扩展到10的长度；
		如果原数组的数组长度大于10，相当于删除数组元素，直到数组长度为10
	arr[10]='hello';
		将原数组的长度扩展到11 然后将第十一个赋值hello

  例子
        var arr=new Array();
        arr[10]="hello";  //把第十一个数设置为hello
        console.log(arr);//(11) [empty × 10, "hello"]
        var arr1=new Array(10);
        var arr2=new Array("hello");
        var arr3=new Array(null,10,true);
        console.log(arr3.length);//3
        console.log(arr.length=5);5
        arr3.length=2;//把arr3长度设置为2
        console.log("arr3:",arr3);//2

        console.log(arr);//(5) [empty × 5]
        console.log(typeof arr);//object
        console.log(arr1);//(10) [empty × 10]
        console.log(arr2);//hello
        console.log(arr3);   //(2) [null, 10]

4.检测数组

	Array.isArray():返回当前参数是否为array类型
	es6:
		Array.from():将类数组转换为数组				

创建类数组对象：

1.包含length属性
2.属性名必须为number类型或者字符串number
0:
"0"

Array.of(10,"hello") 创建数组 [10, "hello"]

	  例子                   
             var arr=[];
             var o={}
             var a="hello";

             console.log(typeof arr);//object
             console.log(typeof o);//object
             console.log(typeof a);//string

             console.log(Array.isArray(arr));//ture    arr是不是数组类型
             console.log(Array.isArray(o));//false
             console.log(Array.isArray(a));//false

             console.log(Array.of(10));//[10]  设置长度为一 第一个数为十的数组
             console.log(Array.of(10,null,false));//(3) [10, null, false]

             function say(){
             console.log(arguments);//Arguments(2) [false, 20, callee: ƒ, Symbol(Symbol.iterator): ƒ]
             var result=Array.from(arguments);//将类数组对象转化为数组
             console.log(result);//(2) [false, 20]
             console.log(Array.isArray(result));//true
             }  
             say(false,20);

             var obj={
             "0":10,
             "1":null,
             "2":false,
             "length":3
             }
             var result=Array.from(obj);//将类数组对象转化为数组
             console.log(result); //(3) [10, null, false]
             console.log(Array.isArray(result));//ture

             function say(){
             console.log(arguments);//Arguments [callee: ƒ, Symbol(Symbol.iterator): ƒ]
             var result=Array.from(arguments);
             console.log(result);//[]
             console.log(Array.isArray(result));//ture
             }
             say()
			 instanceof
    		 console.log(arr instanceof Object)//ture  

5.将数组转换为字符串

toString():

		arr->Array.prototype:
			toString(){}
		var arr=[];
		arr.toString();

join("-"):

		将数组元素使用分隔符进行连接之后转换为字符串

例子
         var arr=[4,5,6,7];
         console.log(arr.join("-"));//4-5-6-7   转换为字符串类型
         console.log(typeof(arr.join("-")));//string
         var result=arr.toString();//转换为字符串
         console.log(result);//4,5,6,7
         console.log(typeof result);//string

6.队栈方法

	删除或者添加数组元素

栈方法：

pop():只可以删最后一个

			 参数：无
			 返回值：删除的元素 

push()：在最后添加一个元素

			参数：想要添加的元素
			返回值：新数组的长度

  例子
      var arr=[1,2,3,"hello",null];
      console.log(arr);//(5) [1, 2, 3, "hello", null]
      var result=arr.pop();//删除最后一个数组
      // var result=arr.push({},false);
      console.log(result);//返回值为删除的元素
      console.log(arr);//(4) [1, 2, 3, "hello"]  现在已经删除最后一个数了

队列方法：

shift():

			参数：无
			返回值:删除的元素  删除第一个元素

unshift()：

			参数：添加的数组元素
			返回值：新数组长度

         例子
             var arr=[null,false,10];
             console.log(arr);//(3) [null, false, 10]
             // var result=arr.unshift("hello",true);//在前面添加'hello,ture'
             var result=arr.shift();
             console.log(result);    //null
             console.log(arr);//(2) [false, 10]

7.排序方法

reverse():

		 反转
		  参数：无
		  返回值：反转之后的数组
		  在原数组的基础上进行反转

    例子
           var arr=[1,2,3,4];
           console.log(arr);//(4) [1, 2, 3, 4]
           var result=arr.reverse();//将arr 反转
           console.log(result);//(4) [4, 3, 2, 1]
           console.log(arr==result);//ture

sort():

1. 排序

		参数：(修改原数组)
			1.无
			默认调用每一个数组元素的tostring()进行比较

2.回调函数

   function(a,b){
          if(a>b){
              return 1;//a排在b之后
          }else if(a<b){
              return -1;//a排在b前面
          }else{
              return 0;//不排序
          }
      }

  例子
      var arr=[1,3,2,11,23,32];
      console.log(arr);//(6) [1, 3, 2, 11, 23, 32]
      var result=arr.sort(function(a,b){
      //	console.log(a);
      //	console.log(b);
          if(a>b){
              return -1
          }else if(a<b){      
              return 1
          }else{
              return 0
          }

      });
      console.log(result);//(6) [32, 23, 11, 3, 2, 1]


 例子：
                  var arr=[{
                  name:'b',
                  age:20,
                  sarlary:1000
              },{
                  name:'a',
                  age:26,
                  sarlary:1500
              },{
                  name:'f',
                  age:12,
                  sarlary:800
              },{
                  name:'c',
                  age:30,
                  sarlary:5000
              }];

              var result=arr.sort(handler("sarlary"));

              function handler(key){
                  //key=age
                  return function(a,b){
                      var c=a[key];
                      var d=b[key];
                      if(c>d){
                          return 1 
                      }else{
                          return -1
                      }
                  }
              }

              //console.log(arr); 
              console.log(result);
  灵活排序：
      function sum(key){}

8 操作方法（非静态方法）

concat():

	数组拼接
	任意想要拼接的内容当作参数给concat
	拼接结果为新数组`

  例子
      var arr=[1,2,3];
      var arr1=[4,5,6];
      var arr2=["hello",null,true];
      var result=arr.concat([arr1]);//在arr后面加//[arr1](4) [1, 2, 3, Array(3)]
      console.log(result);
      console.log(arr1==result);
      console.log(arr==result);
      var result=arr.concat("hello",false);//在arr 后面加 “hello”，false

slice():

	数组切割
	不改变原数组
	参数：
		0: 返回值为一个没有切割的新数组
		1: index
			从当前位置开始切割，到数组末尾结束
		2:begin end
			从begin开始切割，到end结束，不包含结束位置

		-1代表数组中的最后一个元素

 例子
         var arr=[1,2,3,4,5,6,7,8,9];
         var result=arr.slice(2,-1);//从第二个数后 到最后一个数
         console.log(result);//[3 4 5 6 7 8 9]
         console.log(arr==result);//false

splice：

	返回值
	原数组
	数组切割
	                     修改原数组
	参数：
		0：返回一个空数组
		1:index	
			从当前位置切割到数组末尾
		2:begin num
			从begin开始切割，切割num个
		3:begin num 插入的元素
			num=0: 插入
			num不等于0: 替换

       例子
            var arr=[1,2,3,4,5,6,7,8,9];
            var result=arr.splice(2,3,"hello",false,10);//在2到3间加hello false 10
            // var result=arr.splice(1,3);//从标号为1的开始切3个
            console.log(arr);//[1, 5, 6, 7, 8, 9]
            console.log(result);// [2, 3, 4]
            console.log(arr==result);//false

indexOf(key,index):

	查找数组元素
	使用全等操作符进行比较
	返回值：
		找到了返回下标(从前向后查找一个)
		找不到返回-1

lastIndexOf():

	查找数组元素
	从后向前查找`

   例子
       var arr=[1,2,true,"hello",21,2,1,2];
         //var result=arr.indexOf(2,2);
         var result=arr.lastIndexOf(2);

         console.log(result);//7

9迭代方法(非静态方法)

every():

	当数组中的每一个数组项满足条件时，返回true

    例子//这个例子检查所有数组值是否大于 18：
         var numbers = [45, 4, 9, 16, 25];
         var allOver18 = numbers.every(myFunction);

         function myFunction(value, index, array) {
         return value > 18;
}

some():

	只要有一个数组项满足条件，返回true

        例子  //这个例子检查某些数组值是否大于 18：
                var numbers = [45, 4, 9, 16, 25];
                var someOver18 = numbers.some(myFunction);

                function myFunction(value, index, array) {
                return value > 18;

}

map():通过对每个数组元素执行函数来创建新数组。

	对每一个数组元素进行操作

        map() 方法通过对每个数组元素执行函数来创建新数组。
        map() 方法不会对没有值的数组元素执行函数。
        map() 方法不会更改原始数组
            例子将每个数*2
                var numbers1 = [45, 4, 9, 16, 25];
                var numbers2 = numbers1.map(myFunction);

                function myFunction(value, index, array) {
                return value * 2;   //90,8,18,32,50
                }

filter()：

	过滤
	将满足条件的数组元素组成了一个新数组返回，原数组不变

       例子 //这个例子用值大于 18 的元素创建一个新数组：

               var numbers = [45, 4, 9, 16, 25];
               var over18 = numbers.filter(myFunction);

               function myFunction(value, index, array) {
               return value > 18;        //45  25
               }

forEach()：

    方法为每个数组元素调用一次函数（回调函数）。
	for(){}升级版
	没有返回值

     例子  //每个数都使用回调函数
          var txt = "";
          var numbers = [45, 4, 9, 16, 25];
          numbers.forEach(myFunction);

          function myFunction(value, index, array) {
          txt = txt + value + "<br>"; //45br4br9br16br25br
          }

	参数：
		回调函数 this
			回调函数参数：
				item index arr
				数组项 当前数组项下标 当前数组

reduce():

	回调函数 this

回调函数参数：

			pre   item index arr
            上一次
	当this不存在时，pre第一次为第一个item，从第二次开始为undefined
	当this值存在时，第一次pre为this，从第二次开始，为上一次回调函数的返回值

        reduce() 方法在每个数组元素上运行函数，以生成（减少它）单个值。
        reduce() 方法在数组中从左到右工作。另请参见 reduceRight（）。
        reduce() 方法不会减少原始数组。

例子// 这个例子确定数组中所有数字的总和：
         var numbers1 = [45, 4, 9, 16, 25];
         var sum = numbers1.reduce(myFunction);

         function myFunction(total, value, index, array) {
         return total + value;
         }//总和是：99