数组、类数组

数组

• 改变原数组
  push pop shift unshift sort reverse splice

arr.splice() - 从第几位开始，截取多少的长度，在切口处添加新的数据

var arr = [1,1,2,3,4,5];
arr.splice(1,2);//[1, 2]
var arr1 = [1,2,3,5];
arr1.splice(3,0,4);//[1,2,3,4,5]
arr1.splice(-1,1);//[4] //负数指倒数 原理↓
splice = function(pos){
    pos += pos > 0 ? 0 : this.length;
}

arr.sort() - 按字符串排序，e.g. [1,10,3,4,5]

var arr = [1,3,5,10,4]
arr.sort(function(a,b){//某种排序方式
    //1.必须写两个形参
    //2.看返回值 1)当返回值为负数时，前面的数字放在前面
    //          2)        为正数时，后面的数字在前
    //          3)        为0不动

    /*if(a > b){
        return 1;//此时a-b>0,也可以return a-b
    }else{
        return -1;//此时a-b<0,也可以return a-b
    }*/
    //相当于 
    return a - b;//升序
    return b - a;//降序
})

//将有序数组随机打乱(每次打乱的结果顺序都不同)
var arr2 = [1,2,3,4,5,6,7];
arr2.sort(function(){
    return Math.random() - 0.5;//Math.random()为0~1开区间的随机数
})

var a = {
    name : 1,
    age  : 10
}
var b = {
    name : 0,
    age  : 8
}
var c = {
    name : 90,
    age  : 9
}
var arr3 = [a, b, c];
arr3.sort(function(a,b){
    return a.age - b.age;
    return a.name - b.name;
})

• 不改变原数组
  concat join --> split toString slice

var arr = [1,2,3,4,5,6];
var arr1 = [1,2];
console.log(arr.concat(arr1))//[1,2,3,4,5,6,1,2]

arr.slice(1,3);//从第一位截取到第三位 //[2,3]
arr.slice(0);//从第一位开始截取到最后

arr.join("!");//'1~2~3~4~5~6'

var str = arr.join('-');//'1-2-3-4-5'
var str = arr.join();//'1,2,3,4,5,6'
var str = arr.join('');//'123456' //相较于字符串入栈出栈，此法效率更高
str.split('-');//['1', '2', '3', '4', '5', '6'] //字符串方法

类数组

function test(){
    console.log(arguments);//[1, 2, 3, 4, 5, callee: ƒ, Symbol(Symbol.iterator): ƒ]
}
test(1,2,3,4,5);

var obj = {
    "0" : 'a',
    "1" : 'b',
    "length" : 2,
    "push" : Array.prototype.push，
    "splice" :Array.prototype.splice//加了该属性，类数组就和数组长得一模一样了，可以当类数组用 //ouput : ['a', 'b']
    //input  : obj.push('c')
    //output : obj --> 0: 'a', 1: 'b', 2: 'c', length: 3
}

Array.prototype.push = function(target){
    obj[obj.length] = target;
    obj.length ++;
}

//阿里巴巴试题
var obj = {
    "2" : "a",
    "3" : "b",
    "length" : 2,
    "push" : Array.prototype.push
}
obj.push('c');
obj.push('d');
// output : {2: 'c', 3: 'd', length: 4, push: ƒ}

属性必须为索引(数字)属性，必须有length属性，最好加上push

• advantages :
  具备数组和对象的特性，存储数据更强大

1. 可以利用属性名模拟数组的特性
2. 可以动态的增长length属性
3. 如果强行让类数组调用push方法，则会根据length属性值的位置进行属性的扩充

//封装type
//typeof([]) -- array
//typeof({}) -- object
//typeof(function) -- object
//typeof(new Number()) -- number object
//typeof(123) -- number

function type(Target){
    var template = {
        "[object Array]"   : "array",
        "[object Object]"  : "object",
        "[object Number]"  : "number - object",
        "[object Boolean]" : "boolean - object",
        "[object String]"  : "string - object"
    }
    if(Target === null){
        return null;
    }else if(typeof(Target) == 'object'){
        //素组
        //对象
        //包装类 Object.proptotype.toString
        var str = Object.prototype.toString.call(Target);
        return template[str];
    }else {
        return typeof(Target);
    }

//数组去重
// 要求在原型链上编程
// Array.prototype.unique = function(){

// }
var arr = [1,1,1,1,2,2,2,2,4,4,3,3,3,3,3,1,1,10];//[1, 2, 4, 3, 10]

Array.prototype.unique = function(){
    var temp = {},
        arr  = [],
        len = this.length;
    for(var i = 0; i < len; i ++ ){
        if(!temp[this[i]]){
            temp[this[i]] = 'abc';
            arr.push(this[i]);
        }
    }
    return arr;
}