使用函式過濾並序列化物件：

JSON.stringify函式：

value：將要被序列化的變數的值
replacer：替代器。可以是函式或者是陣列
如果是一個函式，則 value 每個屬性都要經過這個函式的處理，該函式的返回值就是最後被序列化後的值。
如果是一個數組，則要求該陣列的元素是字串，且這些元素會被當做 value 的鍵（key）進行匹配，最後序列化的結果，是隻包含該陣列每個元素為 key 的值。
space：指定輸出數值的程式碼縮排，美化格式之用，可以是數字或者字串。

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

// 方法一： 使用“函式”當替代器
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}
 

如果只是去除物件裡面的屬性，可以使用前面我講的ES6的定義方法。

// 方法二：   使用“陣列”當替代器
const user = {
  name: 'zollero',
  nick: 'z',
  skills: ['JavaScript', 'CSS', 'HTML5']
};
JSON.stringify(user, ['name', 'skills'], 2);

// "{
//   "name": "zollero",
//   "skills": [
//     "JavaScript",
//     "CSS",
//     "HTML5"
//   ]
// }"

用塊級作用域避免命名衝突

在開發的過程中，通常會遇到命名衝突的問題，就是需要根據場景不同來定義不同的值來賦值給同一個變數。下面介紹一個使用 ES6 中的 塊級作用域 來解決這個問題的方法。

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;
  }
}

函式引數值校驗

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。

使用場景：

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

function require() {
  throw new Error('缺少了引數 a')
}

fix(1);
// a 1

fix();
// Uncaught Error: 缺少了引數 a

這裡加入引數沒有傳遞a 的值的話，就會進入 報錯函式。

用解構賦值過濾物件屬性

// 我們想過濾掉物件 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"}

用解構賦值獲取巢狀物件的屬性

解構賦值 的特性很強大，它可以幫我們從一堆巢狀很深的物件屬性中，很方便地拿到我們想要的那一個。比如下面這段程式碼：

// 通過解構賦值獲取巢狀物件的值
var car = {
    model: 'bmw 2018',
    engine: {
        v6: true,
        turbo: true,
        vin: 12345
    }
};
// 這裡使用 ES6 中的簡單寫法，使用 { vin } 替代 { vin: vin }
var modalAndVIN = ({ model, engine: { vin }}) => {
    console.log(`model: ${model}, vin: ${vin}`);
}

modalAndVIN(car);
// "model: bmw 2018, vin: 12345" 

這裡可以將獲取物件的巢狀屬性，可以拼接成新的物件。

合併物件

// 使用拓展運算符合並物件，在後面的屬性會重寫前面相同屬性的值
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 中，== 會將兩邊的變數進行轉義，然後將轉義後的值進行比較，而 === 是嚴格比較，要求兩邊的變數不僅值要相同，它們自身的型別也要相同。

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

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

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

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

ES6 中提供了一個新的方法：Object.is()，它具有 === 的一些特點，而且更好、更準確，在一些特殊場景下變現的更好：

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