如何快速入門VUE3.0：進入學習
Symbol（符號）是ES6 新增的資料型別。 Symbol 是原始值（基礎資料型別），且Symbol 實例是唯一、不可變的。它的產生是因為要用來唯一的標記，進而用作非字串形式的物件屬性，是確保物件屬性使用唯一標識符，不會發生屬性衝突的危險。
符號需要使用Symbol()函數初始化。因為符號本身是原始類型，所以typeof 操作符對符號回傳symbol。
let sym = Symbol(); console.log(typeof sym); // symbol
Symbol()函數可以接收一個字串參數用來描述，後，後續可以透過這個字串來除錯程式碼。但值得注意的是，多個Symbol()函數即使接受的參數是一樣的，他們的值也是不相等的。
let genericSymbol = Symbol();
let otherGenericSymbol = Symbol();
let fooSymbol = Symbol("foo");
let otherFooSymbol = Symbol("foo");
console.log(genericSymbol == otherGenericSymbol); // false
console.log(fooSymbol == otherFooSymbol); // false 如果在程式碼中有多個地方需要使用同一個Symbol 實例的時候，可以傳入一個字串，然後使用Symbol.for( )方法來創建一個可以重複使用的Symbol，類似於單例模式，在第一次使用Symbol.for()的時候，它會根據傳入的參數會全局的去尋找是否使用Symbol.for()創建過同樣的實例，如果有，則重複使用，如果沒有，則新建
let fooGlobalSymbol = Symbol.for("foo"); // 建立新符號let otherFooGlobalSymbol = Symbol.for("foo"); // 重用已有符號console.log(fooGlobalSymbol === otherFooGlobalSymbol); // true Symbol.for()創建的實例和Symbol()創建的實例區別： Symbol()創建的實例永遠都是唯一的，不會因為你傳入的參數相同而跟其他的實例相等，但是Symbol.for()創建的實例如果參數相同的話他們是會相等的，因為他們會公用同一個Symbol 實例
let fooSymbol = Symbol("foo");
let otherFooSymbol = Symbol("foo");
console.log(fooSymbol == otherFooSymbol); // false
let fooGlobalSymbol = Symbol.for("foo"); // 建立新符號let otherFooGlobalSymbol = Symbol.for("foo"); // 重複使用已有符號console.log(fooGlobalSymbol === otherFooGlobalSymbol); // true 物件中的屬性一般都是字串的形式，但其實也是可以使用Symbol 實例來作為屬性的，這樣的好處就是你新增的屬性不會覆寫以前的任何屬性
let s1 = Symbol ("foo"),
s2 = Symbol("bar"),
s3 = Symbol("baz"),
s4 = Symbol("qux");
let o = {
[s1]: "foo val",
};
// 這樣也可以：o[s1] = 'foo val';
console.log(o);
// {Symbol(foo): foo val}
Object.defineProperty(o, s2, { value: "bar val" });
console.log(o);
// {Symbol(foo): foo val, Symbol(bar): bar val}
Object.defineProperties(o, {
[s3]: { value: "baz val" },
[s4]: { value: "qux val" },
});
console.log(o);
// {Symbol(foo): foo val, Symbol(bar): bar val,
// Symbol(baz): baz val, Symbol(qux): qux val}注意：創建Symbol 實例作為物件屬性的時候，如果改symbol 一開始沒有宣告一個變數進行接收的話，後續就必須遍歷物件的所有符號屬性才能找到對應的屬性鍵：
let o = {
[Symbol("foo")]: "foo val",
[Symbol("bar")]: "bar val",
};
console.log(o);
// {Symbol(foo): "foo val", Symbol(bar): "bar val"}
let barSymbol = Object.getOwnPropertySymbols(o).find(symbol => symbol.toString().match(/bar/));
console.log(barSymbol);
// Symbol(bar) ES6 也引入了一批常用內建符號（well-known symbol），用於暴露語言內部行為，開發者可以直接存取、重寫或模擬這些行為。如果對這些預設的屬性進行了修改的話，是可以改變一些操作最後執行的結果的。例如for-of 迴圈會在相關物件上使用Symbol.iterator 屬性，那麼就可以透過在自訂物件上重新定義Symbol.iterator 的值，來改變for-of 在迭代該物件時的行為。
其實就是一個返回Promise 的Generator，一般配合for await of 使用
根據ECMAScript 規範，這個符號作為一個屬性表示“一個方法，該方法返回對象默認的AsyncIterator。由for-awaitator -of 語句使用」。換句話說，這個符號表示實現非同步迭代器API 的函數。
這個屬性定義在Function 的原型上。都知道instanceof 運算子可以用來確定一個物件實例是否屬於某個建構子。其原理就是instanceof 運算子會使用Symbol.hasInstance 函數來決定關係式
function Foo() {}
let f = new Foo();
console.log(f instanceof Foo); // true
class Bar {}
let b = new Bar();
console.log(b instanceof Bar); // true如果你重新定義一個函數的Symbol.hasInstance 屬性，你就可以讓instanceof 方法回傳一些意料之外的東西
class Bar {}
class Baz extends Bar {
static [Symbol.hasInstance]() {
return false;
}
}
let b = new Baz();
console.log(Bar[Symbol.hasInstance](b)); // true
console.log(b instanceof Bar); // true
console.log(Baz[Symbol.hasInstance](b)); // false
console.log(b instanceof Baz); // false 這個屬性定義在Array 的原型上
根據ECMAScript 規範，這個符號作為一個屬性表示「一個布林值，如果是true，則表示物件應該用Array. prototype.concat()打平其陣列元素」。 ES6 中的Array.prototype.concat()方法會根據所接收到的物件類型來選擇如何將一個類別陣列(偽數組)物件拼接成陣列實例。所以修改Symbol.isConcatSpreadable 的值可以修改這個行為。
false：將一整個物件加進數組true：將一整個對平添加進數組
let initial = ["foo"];
let array = ["bar"];
console.log(array[Symbol.isConcatSpreadable]); // undefined
console.log(initial.concat(array)); // ['foo', 'bar']
array[Symbol.isConcatSpreadable] = false;
console.log(initial.concat(array)); // ['foo', Array(1)]
let arrayLikeObject = { length: 1, 0: "baz" };
console.log(arrayLikeObject[Symbol.isConcatSpreadable]); // undefined
console.log(initial.concat(arrayLikeObject)); // ['foo', {...}]
arrayLikeObject[Symbol.isConcatSpreadable] = true;
console.log(initial.concat(arrayLikeObject)); // ['foo', 'baz']
let otherObject = new Set().add("qux");
console.log(otherObject[Symbol.isConcatSpreadable]); // undefined
console.log(initial.concat(otherObject)); // ['foo', Set(1)]
otherObject[Symbol.isConcatSpreadable] = true;
console.log(initial.concat(otherObject)); // ['foo'] 根據ECMAScript 規範，這個符號作為一個屬性表示「一個方法，該方法傳回物件預設的迭代器。由for- of 語句使用」
該屬性會傳回一個Generator 函數，for of 就會依序的去呼叫next()方法，這就是為什麼for of 可以使用在某些物件身上。
class Emitter {
constructor(max) {
this.max = max;
this.idx = 0;
}
*[Symbol.iterator]() {
while (this.idx < this.max) {
yield this.idx++;
}
}
}
function count() {
let emitter = new Emitter(5);
for (const x of emitter) {
console.log(x);
}
}
count();
// 0
// 1
// 2
// 3
// 4 根據ECMAScript 規範，這個符號作為一個屬性表示「一個正規表示式方法，該方法用正規表示式去匹配字串。由String.prototype.match()方法使用」。
String.prototype.match()方法會使用以Symbol.match 為鍵的函數來對正規表示式求值。所以更改一個正規表示式的Symbol.match 屬性，可以讓String.prototype.match()得到你想要的值
console.log(RegExp.prototype[Symbol.match]);
// ƒ [Symbol.match]() { [native code] }
console.log("foobar".match(/bar/));
// ["bar", index: 3, input: "foobar", groups: undefined]
class FooMatcher {
static [Symbol.match](target) {
return target.includes("foo");
}
}
console.log("foobar".match(FooMatcher)); // true
console.log("barbaz".match(FooMatcher)); // false
class StringMatcher {
constructor(str) {
this.str = str;
}
[Symbol.match](target) {
return target.includes(this.str);
}
}
console.log("foobar".match(new StringMatcher("foo"))); // true
console.log("barbaz".match(new StringMatcher("qux"))); // false 這個符號作為一個屬性表示「一個正規表示式方法，該方法返回字串中匹配正規表示式的
。
這個符號作為一個屬性表示「一個正規表示式方法，該方法在匹配正規表示式的索引位置拆分字串。由String.prototype.split()方法使用」。
這個符號作為一個屬性表示「一個方法，該方法將物件轉換為對應的原始值。由ToPrimitive 抽像操作使用」
「一個字串，該字符字串用於建立物件的預設字串
。物件的with 環境綁定中排除