js---数组，类数组

1. 数组 --- 一种特殊的对象

a 会改变原数组的API---push unshift pop shift splice sort reverse

var arr=[3,5,2,7,1,9,0,3]
//push(需要添加的参数值1,...,参数值n)---向数组末尾添加元素（可以是多个参数，就是向数组添加多个元素）
arr.push(56);console.log(arr)//[3,5,2,7,1,9,0,3,56]

//pop()---删除数组末尾的元素（传参数无效，就是剪切最后一个，因为返回值就是剪切出的结果）
arr.pop();console.log(arr);//[3,5,2,7,1,9,0,3]

//unshift(需要添加的参数值1,...,参数值n)---向数组首位添加元素（和push一样，可以传多个参数）
arr.unshift(4,3);console.log(arr);//[4,3,3,5,2,7,1,9,0,3]

//shift()---剪切掉数组首位的元素(和pop一样，传参数没用，调一次剪切一次)
arr.shift();console.log(arr)//[3,3,5,2,7,1,9,0,3]

//splice(数组的第几位开始截取，截取几位，在切口处添加新的数据)----剪切掉截取的一段字符串，并在截断的地方添加新的数据
arr.splice(1,3,22,44,55,66);console.log(arr);//[3,22,44,55,66,7,1,9,0,3]
//另外截取位数可以是0，就是不剪切，只插入，位置根据第n位开始截取，就在第n位前插入

//sort()---默认按acs码升序排序
arr.sort(); console.log(arr);//[0, 1, 22, 3, 3, 44, 55, 66, 7, 9]

//reverse()---翻转顺序
arr.reverse();console.log(arr);//[9, 7, 66, 55, 44, 3, 3, 22, 1, 0]

//例子---sort
//由于很多时候，我们并不需要根据acs码排序，所以sort提供参数便于操作
arr.sort(function(a,b){//sort里的函数必须是两个参数;返回负数，就认为a在前;正数就b在前;返回0，就不动
     //if(a<b){
     //   return -1;// a - b < 0
    //}else{
     //   return 1; // a - b > 0
    //}          
    return a-b;//升序
    return b-a;//降序
});

//sort从数组中取a和b是依照冒泡排序的方式---就是从arr中取第一位和第二位比，再和第三位比，比得过（返回正数）就交换，比不过就不动
//例子---冒泡排序
for(var i=0;i<arr.length;i++){
    for(var j=i+1;j<arr.length;j++){
        if(arr[i] > arr[j]){
            //如果当前拿来对比的值大于之后的值，就交换值，然后拿着交换后的i位置上的值继续和后面对比
            arr[j]=arr[i]+arr[j];
            arr[i]=arr[j]-arr[i];
            arr[j]=arr[j]-arr[i];
        }
    }
}
//冒泡排序原理
//当i=0的时候，是第一轮对比，将最小的数放在了第一位，每次其实就是在找当前位之后的最小的数放在当前位置
//就是拿着i位置的值去当前位置后面找比i位置的值小的数，找到就交换位置，然后拿着i位置上的新数字（比之前的数小，看看后面还有没有比它还小的，不断交换就是找最小的）。
//不交换就证明比当前数小，那就肯定比能交换的数大

例子---给你个有序数组，请你乱序排列：

var arr[1,2,3,4,5,6];
arr.sort(function(a,b){
    //随机数会产生开区间0到1
    //减0.5就是-0.5到0.5之间，就是返回可正可负的数，就随机交换或者不交换了呗
    return Math.random()-0.5;
})

b. 改变不了原数组的API---concat slice join

var arr=[1,2,3,7,5,4],arr1=[22];
//数组1.concat(数组2)---在数组1的末尾拼接上数组2
console.log(arr.concat(arr1),arr); //[1, 2, 3, 7, 5, 4, 22] [1, 2, 3, 7, 5, 4]
console.log(arr1.concat(arr),arr1);//[22, 1, 2, 3, 7, 5, 4] [22]

//slice(从第几位开始截取，截取到第几位之前的数结束)
console.log(arr.slice(1,2),arr);//[2] [1, 2, 3, 7, 5, 4]
console.log(arr.slice(3),arr); //[7,5,4] [1, 2, 3, 7, 5, 4]
//数组的这类API都是可以写负参数的，内部会转换为length+(负的参数) 然后计算出的位置
console.log(arr.slice(-2),arr);//[5,4] [1, 2, 3, 7, 5, 4]

//数组以某个东西链接
console.log(arr.join('-'),arr); //"1-2-3-7-5-4"
//字符串打断成数组
var arr3 = arr.join('-');
console.log(arr3.split('-'),arr3); //["1", "2", "3", "7", "5", "4"] "1-2-3-7-5-4"

2. 类数组：属性要为索引（数字）属性，必须有length属性。最好加上push方法。

另外：一个对象加上splice方法，就会变成数组的形式---就是从{}形式变成[]，但是它依然是对象，只能算是类数组。

function a(){
   console.log(arguments);//[2,3,1]  这里的arguments就是形式看上去是[] 但是依然是对象，依然只能算类数组。你不能给它push等调用数组的API
   arguments.push(2);//error: arguments.push is not a function
}
a(2,3,1);

例子：

var obj={
  "0":"haha",
  "1":"xixi",
  "2":"hehe",
  "name":"xiaoming",
  "length":3,
  "push":Array.prototype.push
}
obj.push("heihei");
console.log(obj); // {0: "haha", 1: "xixi", 2: "hehe", 3: "heihei", name: "xiaoming", length: 4, push: ƒ}

obj.length=1;
console.log(obj);//{0: "haha", 1: "xixi", 2: "hehe", 3: "heihei", name: "xiaoming", length: 1, push: ƒ}
obj.push('oh my god');
console.log(obj);//{0: "haha", 1: "oh my god", 2: "hehe", 3: "heihei", name: "xiaoming", length: 2, push: ƒ}

//上面的现象是由于push的内部处理造成的
//obj调用push,其实就是在以length的值为名称的属性上赋值，并且length+1，也说明了为什么类数组必须有length,且必须有索引才有意义
//所以当直接改变了length的值再push,当然就找错名字了，然后覆盖了已经有的值。
Array.prototype.push=function(){
    for(var i=0;i<arguments.length;i++){

    this[this.length] = arguments[i];
    this.length++;
   }
}