数组与对象的遍历、浅复制以及数组的常用方法

1、数组与对象的遍历

（1）遍历数组

var arr=[3,5,,2,,7,3];
for(var i=0;i<arr.length;i++){
    console.log(arr[i]);
    //判断数组里面有没有undefined类型的元素或者值为undefined的元素。
    console.log(arr[i]===undefined);//true
}

（2）for……in遍历对象

var obj={
    a:1,
    b:2,
    c:3
};
//判断属性名为a的属性是否在该对象中
console.log("a" in obj);//true
//将对象中每个键名循环赋值给prop（名字自己取的）变量，把属性名一个一个取出来
for(var prop in obj){
    //prop就是对象中的所有属性名,obj[prop]就是对象中的属性名对应的属性值
    console.log(prop,obj[prop]);
}

2、对象属性的浅复制（只能复制解除最外层的引用关系）

var obj={
    a:1,
    b:2,
    c:3
};
var o={};
for(var prop in obj){
    //prop就是对象中的所有属性名,obj[prop]就是对象中的属性名对应的属性值
    console.log(prop,obj[prop]);
    //o[prop]=1;//把obj对象中的所有属性名都复制给o对象，属性值都为1
    //var a="c";o[a]=3;//prop相当于上面的a变量
    //把obj对象中的所有属性名，属性值都复制给o对象
    o[prop]=obj[prop]
}
 //此时obj对象的属性值变化，o对象不会发生变化
obj.a=100;
console.log(o);

【注】

• 数组的循环是根据下标的数字从0开始到最大下标结束，是有序的
• 对象是循环所有属性名，是无序的。对象的属性遍历是根据对象属性名添加的顺序

  var obj={d:1};
  obj.c=5;
  obj.a=10;
  obj.b=30;
  for(var prop in obj){
     console.log(prop);//d,c,b,a
  }
  

案例：

/*var arr=["d","e","f","a"];
1.通过这个数组的值创建一个对象，每个对象的属性名就是这个数组的每个元素
2.对象的属性名对应的值0-9随机数的值
3.复制出一个新对象*/
var arr = ["d", "e", "f", "a"];
var obj = {};
for(var i=0; i<arr.length; i++){
    var prop = arr[i];
    obj[prop] = parseInt(Math.random()*10);
    //obj[arr[i]] = parseInt(Math.random()*10);
}
var o={};
for(var prop1 in obj){
    o[prop1]=obj[prop1];
}
console.log(obj);
console.log(o);

3、for与for……in

（1）for in 不会遍历空元素，而for会遍历空元素，显示为undefined

（2）for in可以遍历到数组的属性，for只能遍历数组所有下标，不能遍历属性。属性包含字符和下标

（3）当使用for in遍历时，会将所有属性包括下标都会转为字符型

var arr[3,5,2,1,,6];
//aa是arr的属性，中括号内只有在是数值才是下标
arr["aa"]=10;
//数组的下标也是属性
//判断下标3的元素是否在数组中
console.log(3 in arr);
for(var i=0;i<arr.lenght;i++){
    console.log(arr[i]);
}
console.log("————————————--——");
//当使用for in遍历时，会将所有属性包括下标都会转为字符型
for(var num in arr){
    console.log(num);
    //数组的下标，如果给入的是字符，会转换成数值
    console.log(arr[num]);
}

实现用for时不遍历空元素的方法：

方法一：
var arr[3,5,2,1,,6];
for(var i=0;i<arr.lenght;i++){
    if(i in arr) console.log(arr[i]);
}
方法二：
var arr[3,5,2,1,,6];
for(var i=0;i<arr.lenght;i++){
    if(!(i in arr)) continue; 
    console.log(arr[i]);
}

4、数组的常用方法

（1）push

在数组的末尾追加一个或者多个新元素，并且返回数组的新长度

var arr = [1, 2, 3, 4, 5];
arr.push(6);// 使用 push 方法追加一个元素6在末尾
arr.push(7,8,9);// 使用 push 方法追加多个元素6,7,8在末尾
var a=arr.push(7,8,9);//通过添加到尾部元素后返回数组的新长度
console.log(arr); // [1, 2, 3, 4, 5, 6, 7, 8, 9]

（2）unshift

在数组的最前面添加一个或者多个新元素，并返回数组的新长度

var arr = [1, 2, 3];
// 使用 unshift 方法在数组的最前面添加一个元素
arr.unshift(4);
console.log(arr); // [4, 1, 2, 3]

(3)pop

删除数组末尾的一个元素，并且返回被删除的元素

var arr = [1, 2, 3]
// 使用 pop 方法删除末尾的一个元素，里面没有参数，只能删除最后一个元素
arr.pop();
console.log(arr); // [1, 2]

arr.length–;速度更快，但不会返回被删除的元素

arr.pop();速度慢，但是会返回被删除的元素

//从后往前删知道删除c后停止
var arr=["a","b","c","d","e","f","g"];
//先删除再判断
while((arr.pop())!="c"){}
console.log(arr);

（4）shift

删除数组最前面的一个元素，并且返回被删除的元素

var arr = [1, 2, 3];
// 使用 shift 方法删除数组最前面的一个元素
arr.shift();
var a=arr.shift();//删除数组最前面的一个元素，并且返回被删除的元素
console.log(arr); // [2, 3]

不管删除还是添加都会改变数组的长度
//
var arr = [1, 2, 3, 4, 5, 6];
for(var i=0;i<arr.length;i++){
    arr.pop();
}
console.log(arr);

var len=arr.length;
for(var i=0;i<len;i++){
    arr.pop();
}


console.log(arr);

（5）concat

把多个数组进行拼接

• 和之前的方法有一些不一样的地方，就是 concat 不会改变原始数组，而是返回一个新的数组
• 在前面的数组合并后还是在前面，在后面的数组合并后还在后面
• 既可以合并元素，也可以合并数组

var arr = [1, 2, 3];
var arr1=[4,5,6];
//数组的合并，合并后会返回一个新数组，原来的两个数组不会变化
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();

（6）join

把数组里面的每一项内容以指定的字符链接起来，变成一个字符串

• 可以自己定义每一项之间链接的内容 join(要以什么内容链接)
• 不会改变原始数组，而是把链接好的字符串返回

var arr = [1, 2, 3]
//将数组合并为字符串返回，默认是逗号连接
var str0=arr.join();
// 在这里join的参数是字符串的连接符，即字符串之间以“-”连接
var str = arr.join("-");
//将数组元素首尾相连成为字符串
var str1 = arr.join("");
console.log(str);// 1-2-3

（7）splice

从指定的位置删除给定数量的元素，并且在这个位置插入需要的元素，并且返回被删除的元素组成的新数组

语法： splice(从哪一个索引位置开始，截取多少个，替换的新元素) （第一个值可以是负数，从后往前数，第三个参数可以不写，也可以写多个）

var arr=[1,2,3,4,5];
// 没有任何参数时,返回一个空数组
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);

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

数组去重：

 // 去重
var arr=[1,2,3,4,1,2,3,2,1,1,3,7,7,2,1,6,1,2,4,5,1,2,3];
//创建一个新的空数组，用来存储去掉重复的元素之后剩余的元素
var arr1=[];
//for循环遍历原数组arr
for(var i=0;i<arr.length;i++){
    var item=arr[i];
    //此处bool是个状态，将其置为true，默认其值为真
    var bool=true;
    //for循环遍历新建的arr1数组
    for(var j=0;j<arr1.length;j++){
         //如果检测到arr中的元素值等于arr1中的某个元素值，就将bool置为false，表示该元素重复，跳出本for循环，并且不会将它置入arr1中
         if(arr1[j]===item){
            bool=false;
            break;
         }
    }
         //只有bool的值为真时（即某个arr中的元素不等于arr1中的任何一个元素）才会将该元素置入arr1
         if(bool){
            arr1.push(item);
         }
}
console.log(arr);
console.log(arr1);