js中的数组的创建及一些方法怎样遍历数组

数组的创建及方法和怎样遍历数组
数组实际上就是来源对象，脱胎于对象，继承于对象
数组的创建：
var arr=[1,2,3,4,5,6];
var arr1=new Array(6);
//这个数字就是数组的长度,没有元素
var arr=new Array(“a”);
//这是数组只有一个元素a,
var arr=new Object([1,2,3,4,5]);
//一般不用这种创建数组

在数组中所有的下标都会转换为number，
如果不能转换为number的（也就是转换后是NaN的），就会默认添加对象的属性名
数组的长度，仅记录下标的个数，不包含属性数量
数组不可以使用点语法获取下标变量，但是可以使用点语法取属性
数组的最大下标是数组的长度-1;
var arr=[1,2,3,4,5,6,7];
console.log(arr.lenght);//arr.lenght就是数组的长度
数组的循环是根据下标的数字从0开始循环到最大下标，有序
对象是循环所有属性名，无序
对象的属性遍历是根据对象属性名添加的顺序
/* var obj={d:1};
obj.c=5;
obj.a=10;
obj.b=30;
for(var prop in obj){
console.log(prop);
} */
prop就是属性名,obj[prop]就是这个属性名对应的属性值
当使用for in遍历时，会将所有属性包括下标都会转为字符型
for (var num in arr) {
console.log(num);
// 数组的下标，如果给让的是字符。会转换成数值
console.log(arr[num]);
}
1、for in不会遍历空元素，for会遍历空元素
2、for in可以遍历到数组的属性，for只能遍历数组所有下标，不能遍历属性
属性包含字符和下标（数字）

// 0就是arr的下标，也是arr的属性
arr[0]=5;
//   aa就是arr的属性
 arr["aa"]=10;
 /* 
        var arr=[5,7,8,,2,4,6];
        arr["aa"]=10;
        for(var i=0;i<arr.length;i++){
            console.log(arr[i]);
        }
        for(var num in arr){
             console.log(arr[num]);
         }
     */
       //  这样可以完成不遍历空元素
    //  var arr=[2,4,6,,8,10];
        /* for(var i=0;i<arr.length;i++){
            if(!(i in arr))continue;
            console.log(arr[i]);
        } */

      /*   for(var i=0;i<arr.length;i++){
            if(i in arr)console.log(arr[i]);
        } */

数组的方法：
push 在数组尾部添加一个或者多个元素，并且返回数组的新长度

        arr.push("a","b");
    arr.push(6);//在数组的尾部插入一个新元素
    arr.push(6,7,8);//在数组的尾部插入多个新元素
    var a=arr.push(6,7,8);//通过添加到尾部元素后返回数组的新长度

unshift在数组头部添加一个或者多个元素，并且返回数组的新长度

    arr.unshift(0);//在数组的头部插入一个新元素
    arr.unshift(-3,-2,-1,0);//在数组的头部插入多个新元素
   var a=arr.unshift(-3,-2,-1,0);//返回数组的新长度

pop 删除数组尾部的最后一个元素，并且将这个被删除的元素返回

    arr.pop();//pop中没有参数,删除数组的最尾部一个元素
   var a=arr.pop();//pop删除数组的最尾部一个元素，并且将被删除的元素返回
   arr.length--; //等同 速度更快，但是不会返回被删除的元素
    arr.pop();//速度慢，但是会返回被删除的元素

shift() 删除数组的第一个元素，并且返回被删除的元素

    arr.shift();//将数组的第一个元素删除
    var a=arr.shift();//将数组的第一个元素删除，并且返回这个被删除的元素
    // 不管删除还是添加都会改变数组的长度
    // 这样写，i会不断增大，length会不断减小，他们会相遇，所以不会全部删除
   /*  for(var i=0;i<arr.length;i++){
        arr.pop();
    }
    console.log(arr); */

concat既可以合并元素，也可以合并数组

    // 数组的合并，合并后会返回一个新数组，原来的两个数组不会变化
     /*  var arr=[1,2,3,4];
    var arr1=[5,6,7,8];
    var arr2=arr.concat(arr1);
    // 数组除了可以合并数组，也可以合并元素，将多个元素与原数组合并，返回新数组
    var arr3=arr.concat(0,-1,-2);
    // concat既可以合并元素，也可以合并数组
    var arr4=arr.concat(0,arr1,["A","B"]);
    // 如果直接使用concat，就可以完成数组的复制功能
    var arr5=arr.concat();
    console.log(arr5); */   

join就是将数组的每个元素以指定的字符连接形成新字符串返回

    // var  arr=[1,2,3,4,5];
    // 将数组合并为字符串返回，默认使用,连接
    // var str=arr.join();

    // 在这里join的参数是字符串的连接符
    // var str=arr.join("|");

    // ""作为连接符，会将数组元素首尾相连成为字符串
    // var str=arr.join("");
     toString直接将数组转换为字符串
//   var arr=[1,2,3,4,5];
//   var str=arr.toString();
//   console.log(str);

这个方法可以从指定的位置删除给定数量的元素，并且在这个位置插入需要的元素
并且返回被删除的元素组成的新数组
arr.splice(从什么位置开始,删除多少个元素,要插入的元素);
// 没有任何参数时,返回一个空数组
// var arr1=arr.splice();
// 第一个参数是0，表示从第0位开始，第二个参数删除多少个没有填，意味着删除到尾部
// var arr1=arr.splice(0);//将所有数据转移到新数组

    // 从第0位开始删除3个元素，返回到新数组arr1
    // var arr1=arr.splice(0,3);

    // 从第几位开始可以是负数，从后向前数（倒数）,因为没有给要删除的数量，因此删除到尾部
    // var arr1=arr.splice(-2);

    // 从数组的第0位开始，删除1个元素，并且在这个位置插入一个元素 -1,替换
    // var arr1=arr.splice(0,1,-1);
    // 数组的最后一位替换位0
    // var arr1=arr.splice(-1,1,0);
    // 将数组中第二位开始两位元素替换为10，11
    // var arr1=arr.splice(2,2,10,11);

    // 在数组的第二位插入一个元素 -1
    // arr.splice(2,0,-1);
    // arr.splice(2,0,-1,-2,-3,-4);
    // console.log(arr);

按指定位置截取复制数组的内容
arr.slice(从什么位置开始，到什么位置之前结束)
第二个参数不写，默认截取到尾部

    // var arr1=arr.slice();//复制数组arr
    
    // var arr1=arr.slice(0); //复制数组

    // var arr1=arr.slice(3);//从第三位截取到尾部复制

    // var arr1=arr.slice(-2);//从倒数第二位开始截取到尾部

    // var arr1=arr.slice(-3,-1);//从倒数第三位到倒数第一位
    // console.log(arr1);

数组.indexOf(要查询得元素,从什么位置开始查询) 位置就是下标
lastIndexOf(查找得元素，从什么位置开始查找)

 // 在数组中查找元素4，如果查找到，返回该元素所在的下标，如果没有查找到，则返回-1
    // var  index=arr.indexOf(4);
    // console.log(index);
    /*  var arr=[
        {a:1},
        {a:2},
        {a:3},
        {a:4}
    ];
    // 这是错误得，查找不到，因为查找得是新对象
    var index=arr.indexOf({a:1});
    console.log(index); */

    // lastIndexOf  从后向前查找
    // var arr=[1,3,1,2,3,5,2,3,4,6];
    // var index=arr.lastIndexOf(3);
    // console.log(index);

遍历数组

  // var arr=[1,2,3,5,6,7,8,9];
    // arr.forEach(function(数组中的元素，每个元素对应的下标，数组自身){

    // })
    /* arr.forEach(function(a,b,c){
        console.log(a,b,c);
    }) */
    /* var arr=[1,2,3,5,,6,7,8,9];
    // 使用forEach可以跳过空元素
    arr.forEach(function(item,index){
        console.log(item,index);
    }) */
     // forEach没有返回值
   /* var arr1=arr.forEach(function(item,index,arr){
            // 使用return无效
    });
    console.log(arr1); */
  // map会返回一个与原数组长度相等的新数组
    /* var arr=[3,5,7,9,1,2,4];
    var arr2=arr.map(function(item,index,arr){
        // console.log(item,index,arr);
        // 在map中使用return 就是在对应的下标中添加对应的数据
        // return "a";
        return item+10;
    });
    console.log(arr2); */
  var arr=[1,4,6,2,7,9,0];
    // 查找数组中是否有满足条件的元素，如果有就返回true，如果没有就返回false
    // 遍历数组，如果有一个满足条件的元素，都会直接返回true，不继续向后遍历
   /* var bool=arr.some(function(item,index,arr){
        return item>5;
    });
    console.log(bool); */
    // 判断数组中是否每一个都满足条件，如果有一个不满足条件，直接跳出
    // 否则的话所有都满足时返回为ture
   /* var bool=arr.every(function(item,index,arr){
        return item>2;
    });
    console.log(bool); */
    // 要求是将数组中大于5的返回到一个新数组
    // 首先想到map，map只能实现原数组和新数组长度相同
    /* 
        var arr1=arr.filter(function(item,index,arr){
                返回 条件
        });
        筛选数组中满足条件的结果
     */
    /* var arr1=arr.filter(function(item,index,arr){
        return item>5;
    });

    console.log(arr1); */

    // 希望求累积相加数组元素求和，在基数100的前提下，100就是初始值

  /*   var sum=arr.reduce(function(value,item){
        // 函数后面的参数就是累加的初始值
        console.log(value);
        return value+item;
    },100); */
    
/*
    数组.reduce(回调函数(累积值,元素,下标,数组){},初始值)
    如果reduce没有设置初始值，累计值是数组的第0位元素，遍历从下标1开始
    如果reduce设置了初始值，累积值就是从这个初始值开始，遍历从下标0开始
 */