Bagaimana cara cepat memulai VUE3.0: Pelajari
Simbol (simbol) adalah tipe data baru di ES6. Simbol adalah nilai primitif (tipe data yang mendasarinya), dan instance Simbol bersifat unik dan tidak dapat diubah. Ini dihasilkan karena digunakan untuk menandai secara unik dan kemudian digunakan sebagai atribut objek dalam bentuk non-string. Hal ini untuk memastikan bahwa atribut objek menggunakan pengidentifikasi unik dan tidak ada bahaya konflik atribut.
perlu diinisialisasi menggunakan fungsi Simbol(). Karena simbol itu sendiri adalah tipe primitif, operator typeof mengembalikan simbol untuk simbol.
biarkan sim = Simbol(); console.log(typeof sym); //
fungsi simbol Simbol() dapat menerima parameter string untuk dijelaskan, dan kemudian Anda dapat menggunakan string ini untuk men-debug kode. Namun perlu dicatat bahwa meskipun beberapa fungsi Simbol() menerima parameter yang sama, nilainya tidak sama.
biarkan generikSimbol = Simbol();
biarkan otherGenericSymbol = Simbol();
biarkan fooSymbol = Simbol("foo");
biarkan otherFooSymbol = Simbol("foo");
console.log(genericSymbol == otherGenericSymbol);
console.log(fooSymbol == otherFooSymbol); // false Jika Anda perlu menggunakan instance Simbol yang sama di beberapa tempat dalam kode, Anda dapat memasukkan string lalu menggunakan Symbol.for( ) metode untuk membuat Simbol yang dapat digunakan kembali, mirip dengan mode tunggal. Saat menggunakan Symbol.for() untuk pertama kalinya, ia akan mencari secara global apakah akan menggunakan Symbol.for() untuk membuatnya berdasarkan parameter yang diteruskan. instance telah dilewati, jika ada, gunakan kembali, jika tidak, buat
yang baru let fooGlobalSymbol = Symbol.for("foo"); // Buat simbol baru let otherFooGlobalSymbol = Symbol.for("foo"); / Gunakan kembali Signed console.log(fooGlobalSymbol === otherFooGlobalSymbol); // true Perbedaan antara instance yang dibuat oleh Symbol.for() dan instance yang dibuat oleh Symbol(): instance yang dibuat oleh Symbol() selalu unik dan tidak akan berubah karena parameter inputnya sama dan sama dengan instance lain, tetapi instance yang dibuat oleh Symbol.for() akan sama jika parameternya sama, karena mereka akan berbagi instance Simbol yang sama
let fooSymbol = Simbol("foo");
biarkan otherFooSymbol = Simbol("foo");
console.log(fooSymbol == otherFooSymbol);
let fooGlobalSymbol = Symbol.for("foo"); // Buat simbol baru let otherFooGlobalSymbol = Symbol.for("foo"); // Gunakan kembali simbol yang ada console.log(fooGlobalSymbol === otherFooGlobalSymbol); Atribut pada objek umumnya berbentuk string, namun sebenarnya Anda juga dapat menggunakan instance Simbol sebagai atribut. Keuntungannya adalah atribut baru Anda tidak akan menimpa atribut sebelumnya,
misalkan s1 = Simbol ( "foo"),
s2 = Simbol("bilah"),
s3 = Simbol("baz"),
s4 = Simbol("qux");
misalkan o = {
[s1]: "foo val",
};
// Ini juga berfungsi: o[s1] = 'foo val';
konsol.log(o);
// {Simbol(foo): foo val}
Objek.defineProperty(o, s2, { nilai: "bar val" });
konsol.log(o);
// {Simbol(foo): foo val, Simbol(bar): bar val}
Objek.defineProperties(o, {
[s3]: { nilai: "baz val" },
[s4]: { nilai: "qux val" },
});
konsol.log(o);
// {Simbol(foo): foo val, Simbol(bar): bar val,
// Simbol(baz): baz val, Simbol(qux): qux val} Catatan: Saat membuat instance Simbol sebagai atribut objek, jika Anda mengubah simbol tanpa mendeklarasikan variabel untuk menerimanya di awal, Anda harus melakukan traverse selanjutnya semua simbol properti untuk menemukan kunci properti yang sesuai:
misalkan o = {
[Simbol("foo")]: "foo val",
[Simbol("bar")]: "bar val",
};
konsol.log(o);
// {Simbol(foo): "foo val", Simbol(bar): "bar val"}
biarkan barSymbol = Object.getOwnPropertySymbols(o).find(symbol => simbol.toString().match(/bar/));
console.log(barSimbol);
// Simbol(batang) ES6 juga memperkenalkan sejumlah simbol bawaan yang umum digunakan (simbol terkenal) untuk mengekspos perilaku internal bahasa tersebut perilaku. Jika atribut default ini diubah, hasil eksekusi akhir dari beberapa operasi dapat diubah. Misalnya, perulangan for-of akan menggunakan properti Symbol.iterator pada objek yang relevan, sehingga Anda dapat mengubah perilaku for-of saat melakukan iterasi objek dengan mendefinisikan ulang nilai Symbol.iterator pada objek kustom.
sebenarnya adalah Generator yang mengembalikan Promise, umumnya digunakan dengan menunggu dari
Menurut spesifikasi ECMAScript, simbol ini sebagai atribut mewakili "metode yang mengembalikan AsyncIterator default objek. Oleh for- menunggu -of pernyataan menggunakan ". Dengan kata lain, simbol ini mewakili fungsi yang mengimplementasikan API iterator asinkron.
Properti ini didefinisikan pada prototipe Fungsi. Kita semua tahu bahwa operator instanceof dapat digunakan untuk menentukan apakah suatu instance objek milik konstruktor tertentu. Prinsipnya adalah operator instanceof akan menggunakan fungsi Symbol.hasInstance untuk menentukan
fungsi hubungan Foo() {}
biarkan f = new Foo();
konsol.log(f instanceof Foo); // benar
bilah kelas {}
misalkan b = Bar baru();
console.log(b instanceof Bar); // trueJika Anda mendefinisikan ulang properti Symbol.hasInstance suatu fungsi, Anda bisa meminta metode instanceof mengembalikan sesuatu yang tidak diharapkan
dari kelas Bar {}
kelas Baz memperluas Bar {
statis [Simbol.hasInstance]() {
kembali salah;
}
}
misalkan b = baz baru();
console.log(Bar[Symbol.hasInstance](b)); // benar
console.log(b instanceof Bar); // benar
console.log(Baz[Symbol.hasInstance](b)); // salah
console.log(b instanceof Baz); // false Properti ini didefinisikan pada prototipe Array
. Menurut spesifikasi ECMAScript, simbol ini sebagai properti mewakili "nilai Boolean. Jika benar, berarti bahwa objek harus menggunakan Array prototype.concat() meratakan elemen arraynya". Metode Array.prototype.concat() di ES6 akan memilih cara menyambung objek mirip array (array semu) ke dalam instance array berdasarkan tipe objek yang diterima. Jadi mengubah nilai Symbol.isConcatSpreadable dapat mengubah perilaku ini.
adalah salah: menambahkan seluruh objek ke dalam array true: menambahkan seluruh pasangan ke dalam array
let initial = ["foo"];
biarkan array = ["bar"];
console.log(array[Symbol.isConcatSpreadable]); // tidak terdefinisi
console.log(initial.concat(array)); // ['foo', 'bar']
array[Simbol.isConcatSpreadable] = false;
konsol.log(awal.concat(array)); // ['foo', Array(1)]
biarkan arrayLikeObject = { panjang: 1, 0: "baz" };
console.log(arrayLikeObject[Symbol.isConcatSpreadable]); // tidak terdefinisi
console.log(initial.concat(arrayLikeObject)); // ['foo', {...}]
arrayLikeObject[Symbol.isConcatSpreadable] = benar;
console.log(initial.concat(arrayLikeObject)); // ['foo', 'baz']
biarkan OtherObject = new Set().add("qux");
console.log(otherObject[Symbol.isConcatSpreadable]); // tidak terdefinisi
console.log(initial.concat(Objek lain)); // ['foo', Set(1)]
otherObject[Symbol.isConcatSpreadable] = benar;
console.log(initial.concat(otherObject)); // ['foo'] Menurut spesifikasi ECMAScript, simbol ini sebagai atribut mewakili "metode yang mengembalikan iterator default objek. Digunakan oleh for- Pernyataan of menggunakan "
Atribut ini akan mengembalikan fungsi Generator, dan for of akan memanggil metode next() secara bergantian. Inilah sebabnya for of dapat digunakan pada objek tertentu.
kelas Emitor {
konstruktor(maks) {
this.max = maks;
ini.idx = 0;
}
*[Simbol.iterator]() {
while (ini.idx < ini.max) {
hasilkan ini.idx++;
}
}
}
jumlah fungsi() {
biarkan emitor = emitor baru(5);
untuk (const x emitor) {
konsol.log(x);
}
}
menghitung();
// 0
// 1
// 2
// 3
// 4 Menurut spesifikasi ECMAScript, simbol ini sebagai atribut mewakili "metode ekspresi reguler yang menggunakan ekspresi reguler untuk mencocokkan string. Digunakan oleh metode String.prototype.match()."
Metode String.prototype.match() mengevaluasi ekspresi reguler menggunakan fungsi yang dikunci oleh Symbol.match. Jadi mengubah atribut Symbol.match dari ekspresi reguler memungkinkan String.prototype.match() mendapatkan nilai yang Anda inginkan
console.log(RegExp.prototype[Symbol.match]);
// ƒ [Simbol.pertandingan]() { [kode asli] }
console.log("foobar".cocok(/bar/));
// ["bar", indeks: 3, masukan: "foobar", grup: tidak ditentukan]
kelas FooMatcher {
statis [Simbol.pertandingan](target) {
return target.includes("foo");
}
}
console.log("foobar".match(FooMatcher)); // benar
console.log("barbaz".match(FooMatcher)); // salah
kelas StringMatcher {
konstruktor(str) {
ini.str = str;
}
[Simbol.pertandingan](target) {
return target.includes(ini.str);
}
}
console.log("foobar".match(new StringMatcher("foo"))); // benar
console.log("barbaz".match(new StringMatcher("qux"))); // false Simbol ini sebagai atribut mewakili "metode ekspresi reguler yang mengembalikan ekspresi reguler yang cocok dalam indeks string dari rumusnya. Digunakan oleh metode String.prototype.search()"
Simbol ini sebagai atribut mewakili "nilai fungsi yang berfungsi sebagai konstruktor untuk membuat objek turunan."
Simbol ini sebagai atribut mewakili "metode ekspresi reguler yang membagi string pada posisi indeks yang cocok dengan ekspresi reguler. Digunakan oleh metode String.prototype.split()."
Simbol ini sebagai atribut mewakili "suatu metode yang mengubah suatu objek menjadi nilai primitif yang sesuai. Digunakan oleh operasi abstrak ToPrimitive"
Simbol ini sebagai atribut mewakili "string yang digunakan oleh String membuat deskripsi string default objek. Digunakan oleh metode bawaan Object.prototype.toString()."
Simbol ini mewakili objek sebagai properti, dan semua properti objek dan warisan akan diturunkan dari yang terkait Dikecualikan dari objek dengan pengikatan lingkungan