我要返回数据

技巧

  1. 能使用===比较就不要使用==比较

    ==和!=操作符会在需要的情况下自动转换数据类型。但===和!==不会,它们会同时比较值和数据类型,这也使得它们要比==和!=快。

    	[10] === 10    // is false
    [10]  == 10    // is true
    '10' == 10     // is true
    '10' === 10    // is false
     []   == 0     // is true
     [] ===  0     // is false
     '' == false   // is true but true == "a" is false
     '' === false  // is false
  2. 小心使用typeof、instanceof和contructor

    typeof:JavaScript一元操作符,用于以字符串的形式返回变量的原始类型,注意,typeof null也会返回object,大多数的对象类型(数组Array、时间Date等)也会返回object
    contructor:内部原型属性,可以通过代码重写
    instanceof:JavaScript操作符,会在原型链中的构造器中搜索,找到则返回true,否则返回false

    	var arr = ["a", "b", "c"];
    typeof arr;   // 返回 "object"
    arr instanceof Array // true
    arr.constructor();  //[]
  3. 从数组中随机获取成员
    	var items = [12, 548 , 'a' , 2 , 5478 , 'foo' , 8852, , 'Doe' , 2145 , 119];
    var  randomItem = items[Math.floor(Math.random() * items.length)];
  4. 获取指定范围内的随机数

    从一个数到另一个之间进行随机,此方法一,公式:

    	var x = Math.floor(Math.random() * (max - min + 1)) + min;
    	// 比如随机10到20之间的数:
    	var x =  Math.floor(Math.random() * (20 - 10 + 1)) + 10;
    	console.log(x);
    	
  5. 生成从0到指定值的数字数组

    用for循环将1到100的数依次添加到空数组内

    	var numbersArray = [] , max = 100;
    for( var i=1; numbersArray.push(i++) < max;);  // numbers = [1,2,3 ... 100]
    
  6. 生成随机的字母数字字符串

    可以随机一些字母和数字,下面是函数

    	function generateRandomAlphaNum(len) {
        var rdmString = "";
        for( ; rdmString.length < len; rdmString  += Math.random().toString(36).substr(2));
        return  rdmString.substr(0, len);
    }
    // 使用方法:generateRandomAlphaNum(参数);“参数”为数字,位数多少,默认不填写为:""
    generateRandomAlphaNum(1);
    // 或者
    generateRandomAlphaNum(6);
    // 等等
    
  7. 打乱数字数组的顺序

    改变数组内的数字排列顺序

    	var numbers = [5, 458 , 120 , -215 , 228 , 400 , 122205, -85411];
    numbers = numbers.sort(function(){ return Math.random() - 0.5});
    /* numbers 数组将类似于 [120, 5, 228, -215, 400, 458, -85411, 122205]  */
    
  8. 打乱数字数组的顺序

    这里使用了JavaScript内置的数组排序函数,更好的办法是用专门的代码来实现(如Fisher-Yates算法),改变数组内的数字排列顺序

    	var numbers = [5, 458 , 120 , -215 , 228 , 400 , 122205, -85411];
    numbers = numbers.sort(function(){ return Math.random() - 0.5});
    /* numbers 数组将类似于 [120, 5, 228, -215, 400, 458, -85411, 122205]  */
    
  9. 字符串去空格

    对于兼容低版本浏览器的话,是不可能使用es6的语法,推荐使用下面的

    	
    tring.prototype.trim = function(){
    	return this.replace(/^\s+|\s+$/g, "");
    }
    
  10. 验证是否是数字

    	function isNumber(n){
        return !isNaN(parseFloat(n)) && isFinite(n);
    }
    // 比如:
    isNumber(12); // 真
    isNumber('222'); // 真
    isNumber('真'); // 假
    
  11. 验证是否是数组
    	function isArray(obj){
        return Object.prototype.toString.call(obj) === '[object Array]' ;
    }
    // 比如:
    isArray([]); // 真
    isArray(''); // 假
    isArray([1,1]); // 真
    isArray(111); // 假
    
    // 但如果toString()方法被重写过得话,就行不通了。也可以使用下面的方法:
    Array.isArray(obj); // its a new Array method
    
    // 如果在浏览器中没有使用frame,还可以用instanceof,但如果上下文太复杂,也有可能出错。
    var myFrame = document.createElement('iframe');
    document.body.appendChild(myFrame);
    var myArray = window.frames[window.frames.length-1].Array;
    var arr = new myArray(a,b,10); // [a,b,10]
    // myArray 的构造器已经丢失,instanceof 的结果将不正常
    // 构造器是不能跨 frame 共享的
    arr instanceof Array; // false
    
  12. 获取数组中的最大值和最小值
    	var  numbers = [5, 458 , 120 , -215 , 228 , 400 , 122205, -85411];
    var maxInNumbers = Math.max.apply(Math, numbers);
    var minInNumbers = Math.min.apply(Math, numbers);
    
  13. 清空数组
    	var myArray = [12 , 222 , 1000 ];
    // 方法一:
    myArray.length = 0; // myArray will be equal to [].
    // 方法二:
    myArray = [];
    
  14. 不要直接从数组中delete或remove元素

    如果对数组元素直接使用delete,其实并没有删除,只是将元素置为了undefined。数组元素删除应使用splice。

    	
    // 下面是禁止使用
    var items = [12, 548 ,'a' , 2 , 5478 , 'foo' , 8852, , 'Doe' ,2154 , 119 ];
    items.length; // return 11
    delete items[3]; // return true
    items.length; // return 11
    /* items 结果为 [12, 548, "a", undefined × 1, 5478, "foo", 8852, undefined × 1, "Doe", 2154, 119] */
    // 删除对象的属性时可以使用delete。
    
    // 下面是真确的使用
    var items = [12, 548 ,'a' , 2 , 5478 , 'foo' , 8852, , 'Doe' ,2154 , 119 ]; 
    items.length; // return 11
    items.splice(3,1) ;
    items.length; // return 10
    /* items 结果为 [12, 548, "a", 5478, "foo", 8852, undefined × 1, "Doe", 2154, 119]
    
  15. 使用length属性截断数组

    前面的例子中用length属性清空数组,同样还可用它来截断数组:

    	var myArray = [12 , 222 , 1000 , 124 , 98 , 10 ];
    myArray.length = 4; // myArray will be equal to [12 , 222 , 1000 , 124]
    
    
    // 与此同时,如果把length属性变大,数组的长度值变会增加,会使用undefined来作为新的元素填充。length是一个可写的属性。
    myArray.length = 10; // the new array length is 10
    myArray[myArray.length - 1] ; // undefined
    
  16. 在条件中使用逻辑与或
    	var foo = 10;
    foo == 10 && doSomething(); // is the same thing as if (foo == 10) doSomething();
    foo == 5 || doSomething(); // is the same thing as if (foo != 5) doSomething();
    
    
    // 逻辑或还可用来设置默认值,比如函数参数的默认值。
    function doSomething(arg1){
        arg1 = arg1 || 10; // arg1 will have 10 as a default value if it’s not already set
    }
    
  17. 使得map()函数方法对数据循环

    map()不兼容IE6-8,下面有兼容的方法

    	var squares = [1,2,3,4].map(function (val) {
        return val * val;
    });
    // squares will be equal to [1, 4, 9, 16]
    
  18. 保留指定小数位数

    	var num =2.443242342;
    num = num.toFixed(4);  // num will be equal to 2.4432
    // 注意,toFixec()返回的是字符串,不是数字。
    
  19. 浮点计算的问题

    计算机都是不适合计算小数点的,在银行里面的计算都是没有小数点

    	0.1 + 0.2 === 0.3 // is false
    9007199254740992 + 1 // is equal to 9007199254740992
    9007199254740992 + 2 // is equal to 9007199254740994
    
    // 为什么呢?因为0.1+0.2等于0.30000000000000004。JavaScript的数字都遵循IEEE 754标准构建,在内部都是64位浮点小数表示,具体可以参见JavaScript中的数字是如何编码的.
    
    // 可以通过使用toFixed()和toPrecision()来解决这个问题。
    
  20. 通过for-in循环检查对象的属性

    下面这样的用法,可以防止迭代的时候进入到对象的原型属性中。

    	for (var name in object) {
        if (object.hasOwnProperty(name)) {
            // do something with name
        }
    }
    
  21. 逗号操作符

    下面这样的用法,可以防止迭代的时候进入到对象的原型属性中。

    	var a = 0;
    var b = ( a++, 99 );
    console.log(a);  // a will be equal to 1
    console.log(b);  // b is equal to 99
    
  22. 提前检查传入isFinite()的参数

    isFinite(0/0) ; // false
    isFinite("foo"); // false
    isFinite("10"); // true
    isFinite(10);   // true
    isFinite(undefined);  // false
    isFinite();   // false
    isFinite(null);  // true,这点当特别注意
    
  23. 避免在数组中使用负数做索引

    注意:传给splice的索引参数不要是负数,当是负数时,会从数组结尾处删除元素。

    var numbersArray = [1,2,3,4,5];
    var from = numbersArray.indexOf("foo") ;  // from is equal to -1
    numbersArray.splice(from,2);    // will return [5]
    
  24. 用JSON来序列化与反序列化

    注意:传给splice的索引参数不要是负数,当是负数时,会从数组结尾处删除元素。

    var person = {name :'Saad', age : 26, department : {ID : 15, name : "R&D"} };
    var stringFromPerson = JSON.stringify(person);
    /* stringFromPerson 结果为 "{"name":"Saad","age":26,"department":{"ID":15,"name":"R&D"}}"   */
    var personFromString = JSON.parse(stringFromPerson);
    /* personFromString 的值与 person 对象相同  */
    
  25. 不要使用eval()或者函数构造器

    eval()和函数构造器(Functionconsturctor)的开销较大,每次调用,JavaScript引擎都要将源代码转换为可执行的代码。

    var func1 = new Function(functionCode);
    var func2 = eval('code');
    
  26. setInterval()和setTimeout()第一个参数函数而不是字符串

    如果传给setTimeout()和setInterval()一个字符串,他们将会用类似于eval方式进行转换,这肯定会要慢些,因此不要使用:

    setInterval('doSomethingPeriodically()', 1000);
    setTimeout('doSomethingAfterFiveSeconds()', 5000);
    

    而是用:

    setInterval(doSomethingPeriodically, 1000);
    setTimeout(doSomethingAfterFiveSeconds, 5000);
    
  27. 在switch/case中使用数字区间

    其实,switch/case中的case条件,还可以这样写:

    function getCategory(age) {
        var category = "";
        switch (true) {
            case isNaN(age):
                category = "not an age";
                break;
            case (age >= 50):
                category = "Old";
                break;
            case (age <= 20):
                category = "Baby";
                break;
            default:
                category = "Young";
                break;
        };
        return category;
    }
    getCategory(5);  // 将返回 "Baby"
    
  28. 使用对象作为对象的原型

    下面这样,便可以给定对象作为参数,来创建以此为原型的新对象:

    function clone(object) {
        function OneShotConstructor(){};
        OneShotConstructor.prototype = object;
        return new OneShotConstructor();
    }
    clone(Array).prototype ;  // []
    
  29. HTML字段转换函数
    function escapeHTML(text) {
        var replacements= {"<": "<", ">": ">","&": "&", "\"": """};
        return text.replace(/[<>&"]/g, function(character) {
            return replacements[character];
        });
    }
    
  30. JavaScript数组方法的兼容性写法indexOf()、forEach()、map()、filter()、some()

    ECMA Script5中数组方法如indexOf()、forEach()、map()、filter()、some()并不支持IE6~8

    indexOf()方法 返回根据给定元素找到的第一个索引值,否则返回-1。兼容性写法:

    if (!Array.prototype.indexOf) {
        Array.prototype.indexOf = function(ele) {
            // 获取数组长度
            var len = this.length;
            // 检查值为数字的第二个参数是否存在,默认值为0
            var fromIndex = Number(arguments[1]) || 0;
            // 当第二个参数小于0时,为倒序查找,相当于查找索引值为该索引加上数组长度后的值
            if(fromIndex < 0) {
                fromIndex += len;
            }
            // 从fromIndex起循环数组
            while(fromIndex < len) {
                // 检查fromIndex是否存在且对应的数组元素是否等于ele
                if(fromIndex in this && this[fromIndex] === ele) {
                    return fromIndex;
                }
                fromIndex++;
            }
            // 当数组长度为0时返回不存在的信号:-1
            if (len === 0) {
                return -1;
            }
        }
    }
    // 使用方法,比如:
    var arr = ["a", "b", "c"];
    alert(arr.indexOf("b")); // 1
    

    forEach() 方法让数组的每一项都执行一次给定的函数。forEach()方法会修改原数组,兼容性写法:

    
    		if ( !Array.prototype.forEach) {
      Array.prototype.forEach = function forEach(callback) {
          // 获取数组长度
        var len = this.length;
        if(typeof callback != "function") {
            throw new TypeError();
        }
        // thisArg为callback 函数的执行上下文环境
        var thisArg = arguments[1];
        for(var i = 0; i < len; i++) {
            if(i in this) {
                // callback函数接收三个参数:当前项的值、当前项的索引和数组本身
                callback.call(thisArg, this[i], i, this);
            }
        }
      }
    }
    // 使用方法,比如:
    var arr = ["a", "b", "c", "a", "d", "a"];
    arr.forEach(function(ele, index, array){
        if(ele == "a") {
            array[index] = "**";
        }
    });
    alert(newArr); // ["**", "b", "c", "**", "d", "**"]
    		

    map() 方法返回一个由原数组中的每个元素调用一个指定方法后的返回值组成的新数组。兼容性写法:

    if (!Array.prototype.map) {
      Array.prototype.map = function(callback) {
          // 获取数组长度
          var len = this.length;
          if(typeof callback != "function") {
              throw new TypeError();
          }
          // 创建跟原数组相同长度的新数组,用于承载经回调函数修改后的数组元素
          var newArr = new Array(len);
          // thisArg为callback 函数的执行上下文环境
          var thisArg = arguments[1];
          for(var i = 0; i < len; i++) {
              if(i in this) {
                  newArr[i] = callback.call(thisArg, this[i], i, this);
              }
          }
          return newArr;
      }
    }
    // 使用方法,比如:
    var arr = ["a", "b", "c"];
    var newArr = arr.map(function(ele, index, array){
        ele += "12";
        return ele;
    });
    alert(newArr); // ["a12", "b12", "c12"]
    

    filter() 方法利用所有通过指定函数测试的元素创建一个新的数组,并返回。兼容性写法:

    if (!Array.prototype.filter) {
        Array.prototype.filter = function(callback) {
          // 获取数组长度
          var len = this.length;
          if(typeof callback != "function") {
              throw new TypeError();
          }
          // 创建新数组,用于承载经回调函数修改后的数组元素
          var newArr = new Array();
          // thisArg为callback 函数的执行上下文环境
          var thisArg = arguments[1];
          for(var i = 0; i < len; i++) {
              if(i in this) {
                  if(callback.call(thisArg, this[i], i, this)) {
                      newArr.push(val);
                  }
              }
          }
          return newArr;
      }
    }
    // 使用方法,比如:
    var arr = [1, 2, 3, 4, 3, 2, 5];
    var newArr = arr.filter(function(ele, index, array){
        if(ele < 3) {
            return true;
        }else {
            return false;
        }
    });
    alert(newArr); // [1, 2, 2]
    

    some() 方法测试数组中的某些元素是否通过了指定函数的测试。返回布尔值。some() 被调用时不会改变数组。兼容性写法:

    if (!Array.prototype.some) {
      Array.prototype.some = function(callback) {
          // 获取数组长度
          var len = this.length;
          if(typeof callback != "function") {
              throw new TypeError();
          }
          // thisArg为callback 函数的执行上下文环境
          var thisArg = arguments[1];
          for(var i = 0; i < len; i++) {
              if(i in this && callback.call(thisArg, this[i], i, this)) {
                  return true;
              }
          }
          return false;
      }
    }
    // 使用方法,比如:
    var arr = [1, 2, 3, 4, 3, 2, 5];
    var newArr = arr.some(function(ele, index, array){
        if(ele < 2) {
            return true;
        }else {
            return false;
        }
    });
    alert(newArr); // true
    

    every() 方法测试数组的所有元素是否都通过了指定函数的测试。every() 不会改变原数组。兼容性写法:

    if (!Array.prototype.every) {
      Array.prototype.every = function(callback) {
          // 获取数组长度
          var len = this.length;
          if(typeof callback != "function") {
              throw new TypeError();
          }
          // thisArg为callback 函数的执行上下文环境
          var thisArg = arguments[1];
          for(var i = 0; i	< len; i++) {
              if(i in this && !callback.call(thisArg, this[i], i, this)) {
                  return false;
              }
          }
          return true;
      }
    }
    // 使用方法,比如:
    var arr = [1, 2, 3, 4, 3, 2, 5];
    var newArr = arr.every(function(ele, index, array){
        if(ele < 3) {
            return true;
        }else {
            return false;
        }
    });
    alert(newArr); // false
    
  31. 【实用】清除空格

    兼容低版本浏览器的去除空格的话,请使用下面的

    String.prototype.trim = function(){
        return this.replace(/^\s+/,'').replace(/\s+$/,'');
    }
    // 比如下面:
    var str = '   word space   ';
    alert('!'+str.trim()+'!');//!word space!
    

面对对象编程

  1. 选项卡实战