JavaScript的技巧

1. 迭代一个空数组

Javascript 中直接创建的数组是松散的，以至于会有很多坑。试着用数组的构造方法创建一个数组，你就会瞬间明白了。

const arr = new Array(4);
[undefined, undefined, undefined, undefined]
// 谷歌浏览器中是 [empty x 4]

你会发现，通过一个松散的数组去循环调用一些转换是非常难的。

const arr = new Array(4);
arr.map((elem, index) => index);
[undefined, undefined, undefined, undefined]

想要解决这个问题，你可以使用在创建新数组的时候使用 Array.apply。

const arr = Array.apply(null, new Array(4));
arr.map((elem, index) => index);
[0, 1, 2, 3]

2. 给方法传一个空参数

如果你想调用一个方法，并不填其中的一个参数时，Javascript 就会报错。

method(&＃39;parameter1&＃39;, , &＃39;parameter3&＃39;); // Uncaught SyntaxError: Unexpected token ,

一个我们常用的解决方法是传递 null 或 undefined。

method(&＃39;parameter1&＃39;, null, &＃39;parameter3&＃39;) // or
method(&＃39;parameter1&＃39;, undefined, &＃39;parameter3&＃39;);

根据 ES6 中对扩展运算符的介绍，有一个更简洁的方法可以将空参数传递给一个方法。正如上面所提到的，数组是松散的，所以给它传空值是可以的，我们正是用到了这个优点。

method(...[&＃39;parameter1&＃39;, , &＃39;parameter3&＃39;]); // 代码执行了...

3. 数组去重

我一直不明白为什么数组不提供一个内置函数可以让我们方便的取到去重以后的值。扩展运算符帮到了我们，使用扩展运算符配合 Set可以生成一个不重复的数组。

const arr = [...new Set([1, 2, 3, 3])];
// [1, 2, 3]

4.从后向前获取数组元素

如果你想从后向前获取一个数组的元素，可以这样写：

var arr = [1, 2, 3, 4]

console.log(arr.slice(-1)) // [4]
console.log(arr.slice(-2)) // [3, 4]
console.log(arr.slice(-3)) // [2, 3, 4]
console.log(arr.slice(-4)) // [1, 2, 3, 4]

5.短路条件句

如果你想在某个条件逻辑值为true时，执行某个函数，就像这样：

if (condition) {
  dosomething()
}

这时，你可以这样子运用短路：

condition && dosomething()

6.用操作符 “||” 来设置默认值

如果你必须给一个变量赋默认值，可以简单的这样写：

var a

console.log(a) // undefined
a = a || &＃39;default value&＃39;
console.log(a) // default value
a = a || &＃39;new value&＃39;
console.log(a) // default value

7.在相等比较中使用 Object.is()

我们都知道 JavasSript 是弱类型的，并且当我们使用==作比较时，在一些情况下由于类型转换或者说“把两个操作数中的一个转换成另一个，然后再比较”，会出现意想不到的结果。就像这样：

0 == &＃39; &＃39; //true
null == undefined //true
[1] == true //true

因此 Javascript 中给我们提供了全等操作符 ===, 它比不全等操作符更加严格并且不会发生类型转换。但是用 === 来进行比较并不是最好的解决方案。你可能会得到：

NaN === NaN //false

ES6 中提供了新的 Object.is() 方法，它具有 === 的一些特点，而且更好、更精确，在一些特殊案例中表现的很好：

Object.is(0 , &＃39; &＃39;); //false
Object.is(null, undefined); //false
Object.is([1], true); //false
Object.is(NaN, NaN); //true

8.给一个函数 Bind 对象

我们经常需要将一个对象绑定到一个方法的 this 上。在 JS 中，如果你想要调用一个函数并指定它的 this 时可以使用 bind 方法。

Bind 语法

fun.bind(thisArg[, arg1[, arg2[, ...]]])

参数

thisArg

当绑定函数被调用时，该参数会作为原函数运行时的 this 指向。

arg1, arg2, …

当绑定函数被调用时，这些参数将置于实参之前传递给被绑定的方法。

返回值

返回由指定的this值和初始化参数改造的原函数拷贝

JS 中的实例

const myCar = {
 brand: &＃39;Ford&＃39;,
 type: &＃39;Sedan&＃39;,
 color: &＃39;Red&＃39;
};

const getBrand = function () {
 console.log(this.brand);
};

const getType = function () {
 console.log(this.type);
};

const getColor = function () {
 console.log(this.color);
};

getBrand(); // object not bind,undefined

getBrand(myCar); // object not bind,undefined

getType.bind(myCar)(); // Sedan

let boundGetColor = getColor.bind(myCar);
boundGetColor(); // Red

9.获取文件拓展名

解决方法 1: 正则表达式

function getFileExtension1(filename) {
  return (/[.]/.exec(filename)) ? /[^.]+$/.exec(filename)[0] : undefined;
}

解决方法 2: String的split方法

function getFileExtension2(filename) {
  return filename.split(&＃39;.&＃39;).pop();
}

这两种解决方法不能解决一些边缘情况，这有另一个更加强大的解决方法。

解决方法 3: String的slice、lastIndexOf方法

function getFileExtension3(filename) {
  return filename.slice((filename.lastIndexOf(".") - 1 >>> 0) + 2);
}

console.log(getFileExtension3(&＃39;&＃39;));                            // &＃39;&＃39;
console.log(getFileExtension3(&＃39;filename&＃39;));                    // &＃39;&＃39;
console.log(getFileExtension3(&＃39;filename.txt&＃39;));                // &＃39;txt&＃39;
console.log(getFileExtension3(&＃39;.hiddenfile&＃39;));                 // &＃39;&＃39;
console.log(getFileExtension3(&＃39;filename.with.many.dots.ext&＃39;)); // &＃39;ext&＃39;

这是如何实现的呢?

• String.lastIndexOf() 方法返回指定值（本例中的&＃39;.&＃39;）在调用该方法的字符串中最后出现的位置，如果没找到则返回 -1。

• 对于&＃39;filename&＃39;和&＃39;.hiddenfile&＃39;，lastIndexOf的返回值分别为0和-1无符号右移操作符(»>) 将-1转换为4294967295，将-2转换为4294967294，这个方法可以保证边缘情况时文件名不变。

• String.prototype.slice() 从上面计算的索引处提取文件的扩展名。如果索引比文件名的长度大，结果为""。

10.预防unapply攻击

重写内置对象的原型方法，外部代码可以通过重写代码达到暴漏和修改已绑定参数的函数。这在es5的方法下使用polyfill时是一个严重的安全问题。

// bind polyfill 示例
function bind(fn) {
  var prev = Array.prototype.slice.call(arguments, 1);
  return function bound() {
    var curr = Array.prototype.slice.call(arguments, 0);
    var args = Array.prototype.concat.apply(prev, curr);
    return fn.apply(null, args);
  };
}


// unapply攻击
function unapplyAttack() {
  var cOncat= Array.prototype.concat;
  Array.prototype.cOncat= function replaceAll() {
    Array.prototype.cOncat= concat; // restore the correct version
    var curr = Array.prototype.slice.call(arguments, 0);
    var result = concat.apply([], curr);
    return result;
  };
}

上面的函数声明忽略了函数bind的prev参数，意味着调用unapplyAttack之后首次调用.concat将会抛出错误。

使用Object.freeze，可以使对象不可变，你可以防止任何内置对象原型方法被重写。

(function freezePrototypes() {
  if (typeof Object.freeze !== &＃39;function&＃39;) {
    throw new Error(&＃39;Missing Object.freeze&＃39;);
  }
  Object.freeze(Object.prototype);
  Object.freeze(Array.prototype);
  Object.freeze(Function.prototype);
}());

11.Javascript多维数组扁平化

下面是将多位数组转化为单一数组的三种不同方法。

var arr = [[1, 2],[3, 4, 5], [6, 7, 8, 9]];

期望结果：

[1, 2, 3, 4, 5, 6, 7, 8, 9]

解决方案1：使用concat()和apply()

var newArr = [].concat.apply([], arr);
// [1, 2, 3, 4, 5, 6, 7, 8, 9]

解决方案2：使用reduce()

var newArr = arr.reduce(function(prev, curr) {
  return prev.concat(curr);
});
// [1, 2, 3, 4, 5, 6, 7, 8, 9]

解决方案3：使用 ES6 的展开运算符

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

12. 函数中如何使用可选参数（包括可选回调函数）

实例函数中第2个与第3个参数为可选参数

function example( err, optionA, optionB, callback ) {
        // 使用数组取出arguments
        var args = new Array(arguments.length);
        for(var i = 0; i  0) optiOnA= args.shift(); else optiOnA= null;
        if (args.length > 0) optiOnB= args.shift(); else optiOnB= null;

        // 像正常一样继续：检查是否有错误
        if (err) { 
            return callback && callback(err);
        }
        
        // 打印可选参数
        console.log(&＃39;optionA:&＃39;, optionA);
        console.log(&＃39;optionB:&＃39;, optionB);
        console.log(&＃39;callback:&＃39;, callback);

        /* 你想做的逻辑 */

    }

    // ES6语法书写更简短
    function example(...args) {
        // 第一个参数为错误参数
        const err = args.shift();
        // 如果最后一个参数是函数，则它为回调函数
        const callback = (typeof args[args.length-1] === &＃39;function&＃39;) ? args.pop() : null;

        // 如果args中仍有元素，那就是你需要的可选参数你可以像这样一个一个的将其取出：
        const optiOnA= (args.length > 0) ? args.shift() : null;
        const optiOnB= (args.length > 0) ? args.shift() : null;
        // ... 重复取更多参数

        if (err && callback) return callback(err);

        /* 你想做的逻辑 */
    }

推荐教程：《JS教程》

以上就是Javascript的技巧的详细内容，更多请关注 第一PHP社区 其它相关文章！