类数组和去重

类数组

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

function test  ()  {
   console.log(arguments);
   arguments.push(7);
}
test(1,2,3,4,5,6);
return  [1,2,3,4,5,6]
但是push（7）就会报错 像这种类似数组，但还不
完全具备数组的属性  就是类数组

var obj = {
   '0'  :  'a',
   '1'  :  'b',
   '2'  :  'c',
   'length' :  3,
   'push'  :  Array.prototype.push,
   'splice'  :   Array.prototype.splice,保证了和数组
一样的形式，但obj还是对象
}
/属性要为索引（数字）属性，必须有length属性，
最好加上push
/     Array.prototype.push  =  function(target)  {
          this.[this.length]  =  target;
          this.length  ++;
}

var  obj  =  {
    '2'  :  'a',
    '3'  :  'b',
    'length'  :  2,
    'push'  :  Array.prototype.push
}
obj.push('c');套用上面的公式
obj.push('d');关键的点在于length  前面的就会被覆盖
  
obj  return  {2：‘c’,  3 :  'd',  length:  4}

function  type(target)  {
    var ret  =  typeof(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(ret  ==  'object'){
  var  str  =  Object.prototype.toString.call(target);
  return  template[str];
}else {
      return  ret;
}
}

数组去重代码

var arr  =  {1,1,1,1,1,1,2,2,2,2,2,2,2,1,1,1,1};
/var obj  =  {
/    1: "abc",
 /   2:"abc",
/}
/obj[1]  ->  undefined;
/obj[1]  ->"abc"
/obj[2]  ->  undefined;
/obj[2]  ->"abc"
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;
}
arr.unique()   

如果原数组里面有零， temp[this[ i ] ] = this[i];是不行的 不会去重， temp[this[ i ] ] = "abc";就可以了 。

function  test ()  {
    console.log(this);
}
// test();    ==  test.call();
 test.call({name  :  'deng'});
//test ()
/test()  -> AO{
/argumens  :  {},类数组
/this：{window}，
这里call把this改了