JavaScript笔记（第五部分）

数组 ---- 特殊的对象
定义方法：
1. var a = [ 里面可放值 ]; 自变量形式
2. var arr = new Array( 里面可传参数 );
当 new Array()的参数只有一个时，此时不能传小数，此参数就变成数组的长度
数组能用的一切方法都来源于 Array.prototype 提供

数组的读和写:

arr[num] ----- 不可溢出读，结果为 undefined
arr[num] = xxx ——————> 可以溢写，是那么都可以溢出

数组的方法：
改变原数组:

push（一或多参数）— 在数组的最后一位添加值
```
//      自己编写的 push 方法             
  var arr = [1,2,3];            
  Array.prototype.push = function (){             
    for (var i = 0; i < arguments.length; i++) {             
   this[this.length] = arguments[i]; 
    }             
     return this.length;             
     }
```
1. pop（无参）---- 将数组最后一位剪切出来
2. shift (无参) ------ 在数组的最前位剪切值
3. unshift (无参) ---- 在数组的最前位添加值
4. sort (无参) ---- 将数组内的值按字符ASCII值升序排列
  sort (无参).reverve (无参) ---- 按字符ASCII值降序排列

sort( ) 方法的改写

 var arr = [1,3,5,4,10];  
   // 由于原来的方法不满足我们的正常需求，因此可以改写 sort() 方法 
   // sort( 为用户保留了一个接口 ，改写后系统会在适合的时机调用)      
   // 改写 要求 规则 :         
    // 1.必须写两个形参          
    // 2.看返回值  
    1）当返回值为 负数 时，前面 的数放在 前面          
                2）当返回值为 正数 时，后面 的数在 前面          
                3）当返回值为 0 时，不动           
    arr.sort(function (a , b){            
    // 实际符合 冒泡排序，每轮都把最小的数放在前面               
    if(a > b){                
    return 1;               
    }else{                
    return -1;              
     }
              // 上述方法简化为 三木运算              
              //return (a > b ? 1 : -1) ;
              // 或者直接返回,更简洁             
               //return a-b;            });

  //   给一个有序的数组 乱序,即每次执行后的值顺序都不一致          
   var arr = [1,2,3,4,5,6,7];         
   arr.sort(function (){          
     return Math.random() - 0.5;        
   });

reverve (无参) — 改变数组内值的顺序，逆转
splice (从第几位开始，截取多少长度 ,在切口处添加新的数据) — 剪切

不改变原数组：

concat（有参） — arr.concat(arr1) —> 把两个数组内的值链接，形成一个新数组
join(" 参数必须是字符串原始值，返回的结果为字符串类型 ") -----> 将数组里的每个数，用参数链接起来, 不传参数时，按逗号链接
split(‘参数必须是字符串原始值，返回的结果为数组’) ----> 与 join() 作用互逆，按参数形式进行拆分
toString（无参） ——> arr.toString() 将 arr 里的值转化为字符串类型也证明了 Array 数组已经重写了 toString() 方法
slice （有参也可无参）：
1)两位参数 arr.slice(从该位开始截取，截取到此位) 必须要有变量接收其值
var newArr = arr.slice(1,3);
2)一位参数 arr.slice(从该位开始，一直截取到最后一位)
3）参数为负数时，具体位数的结果 = 负数值 + 数组的长度
4）无参数时，截取整个数组

类数组 ———— 像数组，但就不是数组，没有数组拥有的方法

构建类数组
好处：把对象和数组的方法链接到一起

属性要为索引（数字）属性，必须有 length 属性，最好加上 push    
 var obj = {     
  '2' : 'c',     
  '3' : 'd',     
   'length' : 2,      
   'push' : Array.prototype.push,  
   // 加了此方法后，类数组 就可以当作数组一样用了     
    'splice' : Array.prototype.splice    
    }
   // 类数组 push() 方法内部原理   
    Array.prototype.push = function (target){   
       obj.[obj.length] = target;   
      obj.length ++;   
      }

作 — ---------------------- — 业

封装 type() 方法
由于 typeof() 方法返回的类型并不准确，因此要封装
typeof( [ ] ) ----> array
typeof( { } ) ----> object
typeof( function ) ----> object
typeof( new Number() ) ----> number Object
typeof( 123 ) ----> number

1.分两类 : 原始值和引用值
2. 区分引用值

      var type = function (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' ){   
           // 数组 对象 包装类   
         var str = Object.prototype.toString.call(target);   
         return template[str];    
          }else {    
         return typeof(target);   
       }
}

数组去重
要求在原型链上编程利，用对象统一属性名不能有多个属性值的特点，
把数组里的每一位值，当作同一个对象的属性名

  var arr = [1,1,1,2,2,2,3,3,3,4,4];    
  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;   
     }

字符串去重

var str = '111222333';
  String.prototype.alone = function (){
      var a = this.split(" ");
      var temp = {},
      arr = [];
     for (var i = 0; i < this.length; i++) {
         if(temp[a[i]] == null){
             temp[a[i]] = 'a';
             arr.push([a[i]]);
    }     
    }
      return arr+" ";
 }

try {
} catch(e) {
// 捕捉异常
}

// 在 try 里面的代码 ，若发生错误    
// 不会执行错误后的在 try 中的代码     
 try{        
 console.log('a');       
  // 此处出错        
  console.log(b);      
    console.log('c');     
     } catch(e){ 
     // error    error.message         error.name   -->  error        
     console.log(e.namee + ":" + e.message  );     
      }
   console.log('d');

Error.name 的六种值对应的信息：

EvalError : eaval() 的使用与定义不一致（基本不常见）
RangeError : 数值越界
ReferenceError : 非法或不能识别的引用数值 // 最常见（未定义就使用）
SyntaxError : 发生语法解析错误（最常见）
TypeError : 操作数类型错误
URIError : URI（引用地址）处理不当

JavaScript笔记（第五部分）

猜你喜欢