一些 JavaScript 中的代码小技巧

一些 JavaScript 中的代码小技巧 zollero

在上次的 “Chrome DevTools 你可能不知道的小技巧” 文中，获得不少开发朋友的反馈确实不知道这些小技巧。今天，咱们来聊一聊在 EcmaScript 5/6+ 中的一些小技巧，欢迎评论区讨论下更多技巧。

JSON.stringify

咱们平时常常会用到 JSON 对象，好比当咱们要实现对象的深拷贝时，咱们能够用 JSON 对象的 JSON.stringify和 JSON.parse 来拷贝一个彻底同样的对象，而不会对原对象产生任何引用关系。在使用 localStorage 时，也会用到它，由于 localStorage 只能存储字符串格式的内容，因此，咱们在存以前，将数值转换成 JSON字符串，取出来用的时候，再转成对象或数组。

对于 JSON.stringify 方法，它能够帮咱们把一个对象或数组转换成一个 JSON字符串。咱们一般只会用到它的第一个参数，其实它还有另外两个参数，可让它实现一些很是好用的功能。

首先来看语法：

JSON.stringify(value[, replacer [, space]])

参数：

value：将要被序列化的变量的值 replacer：替代器。能够是函数或者是数组，若是是一个函数，则 value 每一个属性都要通过这个函数的处理，该函数的返回值就是最后被序列化后的值。若是是一个数组，则要求该数组的元素是字符串，且这些元素会被当作 value 的键（key）进行匹配，最后序列化的结果，是只包含该数组每一个元素为 key 的值。 space：指定输出数值的代码缩进，美化格式之用，能够是数字或者字符串。若是是数字（最大为10）的话，表明每行代码的缩进是多少个空格。若是是字符串的话，该字符串（最多前十个字符）将做显示在每行代码以前。 这时候，你应该知道了。咱们能够用 JSON.stringify 来作序列化时的过滤，至关于咱们能够自定义 JSON.stringify的解析逻辑。

使用函数过滤并序列化对象：

// 使用“函数”当替代器

function replacer(key, value) {
  if (typeof value === "string") {
    return undefined;
  }
  return value;
}

var foo = {
  foundation: "Mozilla", 
  model: "box", 
  week: 45, 
  transport: "car", 
  month: 7
};
var jsonString = JSON.stringify(foo, replacer);

// {"week":45,"month":7}
使用数组过滤并序列化对象：

// 使用“数组”当替代器
const user = {
  name: 'zollero',
  nick: 'z',
  skills: ['JavaScript', 'CSS', 'HTML5']
};
JSON.stringify(user, ['name', 'skills'], 2);

// "{ // "name": "zollero", // "skills": [ // "JavaScript", // "CSS", // "HTML5" // ] // }"
复制代码

还有一个有意思的东西，是对象的 toJSON 属性。

若是一个对象有 toJSON 属性，当它被序列化的时候，不会对该对象进行序列化，而是将它的toJSON 方法的返回值进行序列化。

见下面的例子：

var obj = {
  foo: 'foo',
  toJSON: function () {
    return 'bar';
  }
};
JSON.stringify(obj);      // '"bar"'
JSON.stringify({x: obj}); // '{"x":"bar"}' 
复制代码

用 Set 来实现数组去重 在 ES6 中，引入了一个新的数据结构类型：Set。而 Set 与 Array 的结构是很相似的，且 Set 和 Array 能够相互进行转换。

数组去重，也算是一个比较常见的前端面试题了，方法有不少种，这里很少赘述。下面咱们看看用 Set 和 ...（拓展运算符）能够很简单的进行数组去重。

const removeDuplicateItems = arr => [...new Set(arr)];
removeDuplicateItems([42, 'foo', 42, 'foo', true, true]);
//=> [42, "foo", true]
复制代码

用块级做用域避免命名冲突 在开发的过程当中，一般会遇到命名冲突的问题，就是须要根据场景不一样来定义不一样的值来赋值给同一个变量。下面介绍一个使用 ES6 中的 块级做用域 来解决这个问题的方法。

好比，在使用 switch case 时，咱们能够这样作：

switch (record.type) {
  case 'added': {
    const li = document.createElement('li');
    li.textContent = record.name;
    li.id = record.id;
    fragment.appendChild(li);
    break;
  }
    
  case 'modified': {
    const li = document.getElementById(record.id);
    li.textContent = record.name;
    break;
  }
}
复制代码

函数参数值校验 咱们知道，在 ES6 中，为函数增长了参数默认值的特性，能够为参数设定一些默认值，可让代码更简洁，可维护。

其实，咱们能够经过这个特性来作函数参数值的校验。

首先，函数的参数能够是任意类型的值，也能够是函数，好比下面这个：

function fix(a = getA()) {
  console.log('a', a)
}

function getA() {
  console.log('get a')
  return 2
}

fix(1);
// a 1

fix();
// get a
// a 2
复制代码

能够看出，若是在调用 fix 时传了参数 a ，则不会执行函数 getA，只有当不传递参数 a 时，才会执行函数 getA。

这时候，咱们能够利用这一特性，为参数 a 添加一个必传的校验，代码以下：

function fix(a = require()) {
  console.log('a', a)
}

function require() {
  throw new Error('缺乏了参数 a')
}

fix(1);
// a 1

fix();
// Uncaught Error: 缺乏了参数 a
复制代码

用解构赋值过滤对象属性 在前面咱们介绍了使用 JSON.stringify 来过滤对象的属性的方法。这里，咱们介绍另一种使用 ES6 中的 解构赋值 和 拓展运算符 的特性来过滤属性的方法。

好比，下面这段示例：

// 咱们想过滤掉对象 types 中的 inner 和 outer 属性

const { inner, outer, ...restProps } = {
  inner: 'This is inner',
  outer: 'This is outer',
  v1: '1',
  v2: '2',
  v4: '3'
};
console.log(restProps);
// {v1: "1", v2: "2", v4: "3"}
复制代码

用解构赋值获取嵌套对象的属性 解构赋值 的特性很强大，它能够帮咱们从一堆嵌套很深的对象属性中，很方便地拿到咱们想要的那一个。好比下面这段代码：

// 经过解构赋值获取嵌套对象的值

const car = {
    model: 'bmw 2018',
    engine: {
        v6: true,
        turbo: true,
        vin: 12345
    }
};
// 这里使用 ES6 中的简单写法，使用 { vin } 替代 { vin: vin }
const modalAndVIN = ({ model, engine: { vin }}) => {
    console.log(`model: ${model}, vin: ${vin}`);
}

modalAndVIN(car);
// "model: bmw 2018, vin: 12345" 
复制代码

合并对象

ES6 中新增的 拓展运算符，能够用来解构数组，也能够用来解构对象，它能够将对象中的全部属性展开。

经过这个特性，咱们能够作一些对象合并的操做，以下：

// 使用拓展运算符合并对象，在后面的属性会重写前面相同属性的值
const obj1 = { a: 1, b: 2, c: 3 };
const obj2 = { c: 5, d: 9 };
const merged = { ...obj1, ...obj2 };
console.log(merged);
// {a: 1, b: 2, c: 5, d: 9}

const obj3 = { a: 1, b: 2 };
const obj4 = { c: 3, d: { e: 4, ...obj3 } };
console.log(obj4);
// {c: 3, d: {a: 1, b: 2, e: 4} }
复制代码

使用 === 代替 ==

在 JavaScript 中，=== 和 == 是有很大的不一样的，== 会将两边的变量进行转义，而后将转义后的值进行比较，而 === 是严格比较，要求两边的变量不只值要相同，它们自身的类型也要相同。

JavaScript 常常被调侃成一个神奇的语言，就是由于它的转义的特性，而用 == 可能会引入一些深埋的bug。远离 bug，仍是要用 ===：

[10] ==  10      // true
[10] === 10      // false

'10' ==  10      // true
'10' === 10      // false

 []  ==  0       // true
 []  === 0       // false

 ''  ==  false   // true
 ''  === false   // false
复制代码

固然，在用 === 时，也会出问题，好比：

NaN === NaN // false ES6 中提供了一个新的方法：Object.is()，它具备 === 的一些特色，并且更好、更准确，在一些特殊场景下变现的更好：

Object.is(0 , ' ');         //false
Object.is(null, undefined); //false
Object.is([1], true);       //false
Object.is(NaN, NaN);        //true
下图，是关于 ==、=== 和 Object.is 的对比：
复制代码

引用：

developer.mozilla.org/

www.jstips.co/

转自：zhuanlan.zhihu.com/p/42630013