数组的一些方法

var arr = []; //数组字面量
var arr1 = new Array();//通过系统内置的Array构造函数声明数组，不推荐使用
var arr2 = Array();//不使用
console.log(arr1.__proto__);
//原型都是Array.prototype,

所有数组都继承于Array.prototype
数组也是对象，所有可以用对象来模拟数组，可以发现数组的取值和对象是一样的

  var arr = [1, 2, 3, 4, 5];
        // 对象模拟数组
        var obj = {
            0: 1,
            1: 2,
            2: 3,
            3: 4,
            4: 5
        }
        console.log(arr[2],obj[2])//都打印3

像 var arr = [1,2,3,4]这样的数组叫稀松数组，数组最后打了逗号跟没打一样

构造函数 new Array()
var arr = new Array(1,2,3)这样子创建数组会报错，构造函数构造数组不能有空值
当new Array(5)只填一个数的时候是设置数组的长度，就相当于[,]

打印arr[4]出现undefined的原因，相当于在对象中访问一个不存在的属性，因为数组也是对象

var arr[1, 2, 3];
console.log(arr[4]);//undefined

push()/unshift() 继承于数组的原型，都可以添加多个值，返回值都是执行了方法以后数组的长度
push在数组的最后添加

  var arr = [2,3,4];
        // arr.push(5);
        // arr.push(5,6,7);
        arr.unshift(1);
        Array.prototype.myPush = function(){
            for(var i = 0; i< arguments.length;i++){
                // console.log(arguments[i])
                this[this.length] = arguments[i]
            }
            return this.length
        }
        arr.myPush(1,2,3)
        console.log(arr)

pop()剪切数组最后一位，shift()剪切数组第一位， 都返回被剪切的值

reverse 数组倒序

**splice()**方法
splice(开始项 的下标，剪切的长度，剪切以后最后一位开始添加数据)

var arr = [1, 2, 3];
arr.splice(1,2);//从下标为1的位置开始，剪切两个元素
console.log(arr);//1
var arr1 = ['a', 'b', 'c'];
arr1.splice(1,1,1,2,3);
console.log(arr1);//['a', 1, 2, 3 'c']
//在c e中间添加d
var arr2 = ['a', 'b', 'c', 'e'];
//方法一
arr2.splice(3,0,'d');
console.log(arr1);//['a', 'b', 'c', 'd', 'e']
//方法二 负值，从后往前从-1开始
arr2.splice(-1, 0, 'd');

splice底层是如何判断index的正负的

function splice(arr, index){
  return index += index >= 0 ? 0 : arr.length;
}

sort()数组排序 返回排序后的数组，如果没有传参数默认是按照ASCII码来排列的
如果自定义一个函数来排序的话1、要有两个参数a,b
2、返回值： 如果是负值， a就排在前
如果是正值，b就排在前
使用Math.random()实现数组的随机排序

  var arr = [1, 2, 3];
        // Math.random()  //0 - 1开区间
  arr.sort(function(a, b){
       return Math.random() - 0.5
  })
  console.log(arr)

重写unshift()方法

 var arr=[1, 2, 4];
      Array.prototype.myUnshift = function(){
            var ind = 0;
            for(var i = 0; i < arguments.length; i++){
                this.splice(ind, 0, arguments[i]);
                ind++;
            }
        }
      //使用concat()方法
        Array.prototype.myUnshift = function(){
            // 把类数组转换为数组
            var argArr = Array.prototype.slice.call(arguments);
            var newArray = argArr.concat(this);
            return newArray;
        }
        arr.myUnshift('a',5,'k')
        console.log(arr);

数组元素按照字节数排序

var arr =  ['很好的胡','aa了了咳咳咳及','ccccc']
    function getBytes(str){
            var len  = str.length;
            for(var i = 0; i < str.length; i++){
                if(str.charCodeAt(i) > 255){
                    len++;
                }
            }
            return len;
     }
     arr.sort(function(a, b){
            return getBytes(a) - getBytes(b);
     })
    console.log(arr);

以上数组方法都会修改原数组
concat()合并两个数组返回合并后的数组
toString() 数组转成逗号隔开的字符串

  var arr = [1,2,3,4];
  arr.toString()

slice()，从开始位置截取数组，截取到结束位置为止，不包含结束为止，返回截取到的数组

     slice() [start, end)
      var arr = ['a', 'b', 'c', 'd', 'e', 'f'];
      var arr1 = arr.slice(1);//如果没写结束的下标，就是从当前位置截取到最后
      var arr1 = arr.slice(1,4)//从下标为1开始截取，到下标为4之前，不包含下标是4的元素
       var arr1 = slice(-3,5)//和splice是一样的取法，从后往前，从-1开始
       var arr1 = slice(-3,-1)
      console.log(arr1);

jion()/split() split(‘分隔符’，截取的数组的长度)

类数组 arguments就是类数组， 类数组一定要有数组形式对应的下标的值

 var obj = {
    '2': 3,
    '3': 4,
    'length': 2,
    'splice': Array.prototype.splice,
    'push': Array.prototype.push
   }
   obj.push(1);// 2: 3 length 3
   obj.push(2,3);// 3: 2 length 4
   console.log(obj)
//    Array.prototype.push = function(el){
//     this[this.length] = el;
//     this.length++
//    }

var pesrson = {
    '0':'一',
    '1':'一',
    '2':'一',
    '3':'一',
    'name': '',
    'age': 90,
    'length': 4,
    'splice': Array.prototype.splice,
    'push': Array.prototype.push

}

  // 数组去重
        var arr = ['b', 'z', 'b', 'i', 'b',1,2,1]
        Array.prototype.unique = function(){
            var obj = {};
            var arr = [];
            for(var i = 0; i < this.length; i++){
                if(!obj.hasOwnProperty(this[i])){
                    obj[this[i]] = this[i];
                    arr.push(this[i])
                }
            }
            return arr;
        }
        console.log(arr.unique())

   // 判断数据类型
        function myTypeof(val){
            var type = typeof(val);
            var toStr = Object.prototype.toString;
            var res = {
                '[object Array]': 'array',
                '[object Number]':'object number',
                '[object Object]':'object',
                '[object String]':'string',
                '[object Boolean]':'boolean',
            }
            if(val == null) return String(null);
            if(type === 'object'){
                var r = toStr.call(val)
                return res[r]
            } else {
                return type;
            }
        }
       console.log(myTypeof('er')) ;