Berapa byte objek javascript?

JavaScript adalah bahasa yang dinamis dengan. Variabel dalam JavaScript tidak secara langsung dikaitkan dengan jenis nilai tertentu, dan variabel apa pun dapat diberikan (dan ditugaskan kembali) nilai dari semua jenis

let foo = 42; // foo is now a number foo = "bar"; // foo is now a string foo = true; // foo is now a boolean _

JavaScript juga merupakan bahasa yang diketik dengan lemah, yang berarti memungkinkan konversi tipe implisit ketika suatu operasi melibatkan tipe yang tidak cocok, alih-alih melemparkan kesalahan tipe.

const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421

Paksaan implisit sangat nyaman, tetapi bisa menjadi pijakan potensial jika pengembang tidak berniat melakukan konversi, atau berniat mengonversi ke arah lain (misalnya, string ke angka, bukan angka ke string). Untuk dan , JavaScript sengaja melarang konversi tipe implisit tertentu

Semua jenis kecuali mendefinisikan nilai-nilai yang tidak dapat diubah yang diwakili secara langsung pada tingkat bahasa yang paling rendah. Kami menyebut nilai jenis ini sebagai nilai primitif

Semua tipe primitif, kecuali null_, dapat diuji oleh operator typeof. typeof null mengembalikan "object", jadi seseorang harus menggunakan === null untuk menguji null

Semua tipe primitif, kecuali null dan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2, memiliki tipe pembungkus objek yang sesuai, yang menyediakan metode berguna untuk bekerja dengan nilai primitif. Misalnya, objek const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 _3 menyediakan metode seperti const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 4. Ketika sebuah properti diakses pada nilai primitif, JavaScript secara otomatis membungkus nilai ke dalam objek pembungkus yang sesuai dan mengakses properti pada objek sebagai gantinya. Namun, mengakses properti di null_ atau const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2 memunculkan pengecualian const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 7, yang memerlukan pengenalan operator rangkaian opsional

Halaman referensi kelas pembungkus objek berisi lebih banyak informasi tentang metode dan properti yang tersedia untuk setiap jenis, serta deskripsi terperinci untuk semantik dari jenis primitif itu sendiri

Tipe Null dihuni oleh tepat satu nilai. null

Tipe Undefined dihuni oleh tepat satu nilai. const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2

Secara konseptual, const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2 menunjukkan tidak adanya nilai, sedangkan null menunjukkan tidak adanya objek (yang juga bisa dijadikan alasan untuk ). Bahasa biasanya default ke const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 _2 ketika ada sesuatu yang tidak memiliki nilai

• Pernyataan // BigInt const x = BigInt(Number.MAX_SAFE_INTEGER); // 9007199254740991n x + 1n === x + 2n; // false because 9007199254740992n and 9007199254740993n are unequal // Number Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2; // true because both are 9007199254740992 _7 tanpa nilai (// BigInt const x = BigInt(Number.MAX_SAFE_INTEGER); // 9007199254740991n x + 1n === x + 2n; // false because 9007199254740992n and 9007199254740993n are unequal // Number Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2; // true because both are 9007199254740992 8) secara implisit mengembalikan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2
• Mengakses properti objek yang tidak ada (console.log({} + []); // "[object Object]" 0) mengembalikan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2
• Deklarasi variabel tanpa inisialisasi (console.log({} + []); // "[object Object]" 2) secara implisit menginisialisasi variabel ke const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2
• Banyak metode, seperti console.log({} + []); // "[object Object]" _4 dan console.log({} + []); // "[object Object]" 5, mengembalikan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2 ketika tidak ada elemen yang ditemukan

null_ lebih jarang digunakan dalam bahasa inti. Tempat yang paling penting adalah akhir rantai prototipe — selanjutnya, metode yang berinteraksi dengan prototipe, seperti console.log({} + []); // "[object Object]" 8, console.log({} + []); // "[object Object]" 9, dll. , menerima atau mengembalikan ________148______ bukan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2

null adalah , tetapi const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2 adalah normal yang kebetulan merupakan properti global. Dalam praktiknya, perbedaannya kecil, karena const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2 tidak boleh didefinisikan ulang atau dibayangi

Tipe console.log(42 / +0); // Infinity console.log(42 / -0); // -Infinity _2 mewakili entitas logis dan dihuni oleh dua nilai. null6 dan null7

Nilai Boolean biasanya digunakan untuk operasi bersyarat, termasuk operator ternary, null8, null9, dll

Jenis const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 _3 adalah a. Itu mampu menyimpan angka floating-point positif antara 2-1074 (typeof1) dan 21024 (typeof2) serta angka floating-point negatif antara -2-1074 dan -21024, tetapi hanya dapat menyimpan bilangan bulat dengan aman dalam rentang - . Di luar rentang ini, JavaScript tidak dapat lagi mewakili bilangan bulat dengan aman; . Anda dapat memeriksa apakah suatu angka berada dalam kisaran bilangan bulat aman menggunakan typeof5

Nilai di luar rentang ±(2-1074 hingga 21024) dikonversi secara otomatis

• Nilai positif yang lebih besar dari typeof_2 dikonversi menjadi typeof_7
• Nilai positif yang lebih kecil dari typeof_1 dikonversi menjadi typeof_9
• Nilai negatif yang lebih kecil dari -typeof_2 dikonversi menjadi typeof null1
• Nilai negatif yang lebih besar dari -typeof_1 dikonversi menjadi typeof null3

typeof7 dan typeof null1 berperilaku mirip dengan infinity matematika, tetapi dengan sedikit perbedaan;

Tipe Number hanya memiliki satu nilai dengan beberapa representasi. typeof null_8 direpresentasikan sebagai typeof null3 dan typeof9 (di mana typeof null8 adalah alias untuk typeof9). Dalam praktiknya, hampir tidak ada perbedaan antara representasi yang berbeda; . Namun, Anda dapat melihat ini saat Anda membaginya dengan nol

console.log(42 / +0); // Infinity console.log(42 / -0); // -Infinity

"object"_5 ("Bukan Angka") adalah jenis nilai angka khusus yang biasanya ditemui ketika hasil operasi aritmatika tidak dapat dinyatakan sebagai angka. Itu juga satu-satunya nilai dalam JavaScript yang tidak sama dengan dirinya sendiri

Meskipun angka secara konseptual merupakan "nilai matematika" dan selalu dikodekan secara implisit titik-mengambang, JavaScript menyediakan. Saat menerapkan operator bitwise, angka tersebut pertama kali dikonversi menjadi bilangan bulat 32-bit

Catatan. Meskipun operator bitwise dapat digunakan untuk merepresentasikan beberapa nilai Boolean dalam satu angka menggunakan bit masking, hal ini biasanya dianggap praktik yang buruk. JavaScript menawarkan cara lain untuk mewakili sekumpulan Boolean (seperti larik Boolean, atau objek dengan nilai Boolean yang ditetapkan ke properti bernama). Penyembunyian bit juga cenderung membuat kode lebih sulit dibaca, dipahami, dan dipelihara

Mungkin perlu menggunakan teknik seperti itu di lingkungan yang sangat terbatas, seperti saat mencoba mengatasi keterbatasan penyimpanan lokal, atau dalam kasus ekstrim (seperti saat setiap bit di jaringan diperhitungkan). Teknik ini hanya boleh dipertimbangkan jika merupakan langkah terakhir yang dapat diambil untuk mengoptimalkan ukuran

Tipe console.log(42 / +0); // Infinity console.log(42 / -0); // -Infinity _6 adalah primitif numerik dalam JavaScript yang dapat mewakili bilangan bulat dengan besaran arbitrer. Dengan BigInts, Anda dapat menyimpan dan mengoperasikan bilangan bulat besar dengan aman bahkan di luar batas bilangan bulat aman (typeof_4) untuk Numbers

BigInt dibuat dengan menambahkan "object"8 ke akhir bilangan bulat atau dengan memanggil fungsi "object"9

Contoh ini menunjukkan di mana penambahan typeof4 mengembalikan hasil yang diharapkan

// BigInt const x = BigInt(Number.MAX_SAFE_INTEGER); // 9007199254740991n x + 1n === x + 2n; // false because 9007199254740992n and 9007199254740993n are unequal // Number Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2; // true because both are 9007199254740992

Anda dapat menggunakan sebagian besar operator untuk bekerja dengan BigInts, termasuk === null1, === null2, === null3, === null4, dan === null5 — satu-satunya yang dilarang adalah === null6. BigInt tidak sepenuhnya sama dengan Angka dengan nilai matematika yang sama, tetapi umumnya demikian

Nilai BigInt tidak selalu lebih tepat atau kurang tepat daripada angka, karena BigInt tidak dapat merepresentasikan bilangan pecahan, tetapi dapat merepresentasikan bilangan bulat besar dengan lebih akurat. Tidak ada tipe yang memerlukan yang lain, dan mereka tidak saling menggantikan. A const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 7 dilemparkan jika nilai BigInt dicampur dengan angka reguler dalam ekspresi aritmatika, atau jika mereka satu sama lain

Tipe console.log(42 / +0); // Infinity console.log(42 / -0); // -Infinity _8 merepresentasikan data tekstual dan dikodekan sebagai urutan 16-bit nilai integer tak bertanda yang merepresentasikan. Setiap elemen dalam string menempati posisi dalam string. Elemen pertama ada di indeks typeof null_8, selanjutnya di indeks const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 00, dan seterusnya. Panjang string adalah jumlah unit kode UTF-16 di dalamnya, yang mungkin tidak sesuai dengan jumlah sebenarnya dari karakter Unicode;

String JavaScript tidak dapat diubah. Ini berarti bahwa setelah sebuah string dibuat, tidak mungkin untuk mengubahnya. Metode string membuat string baru berdasarkan konten string saat ini — misalnya

• Substring dari aslinya menggunakan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 _02
• Penggabungan dua string menggunakan operator penggabungan (=== null1) atau const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 04

Waspadalah terhadap "mengetik dengan string" kode Anda

Mungkin tergoda untuk menggunakan string untuk merepresentasikan data yang kompleks. Melakukan hal ini datang dengan manfaat jangka pendek

• Sangat mudah untuk membangun string kompleks dengan penggabungan
• String mudah di-debug (apa yang Anda lihat tercetak selalu apa yang ada di string)
• String adalah penyebut umum dari banyak API (kolom input, nilai penyimpanan lokal, const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 05 tanggapan saat menggunakan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 06, dll. ) dan mungkin tergoda untuk hanya bekerja dengan string

Dengan konvensi, dimungkinkan untuk merepresentasikan struktur data apa pun dalam sebuah string. Ini tidak membuatnya menjadi ide yang bagus. Misalnya, dengan pemisah, seseorang dapat meniru daftar (sementara array JavaScript akan lebih cocok). Sayangnya, ketika pemisah digunakan di salah satu elemen "daftar", maka daftar tersebut rusak. Karakter pelarian dapat dipilih, dll. Semua ini membutuhkan konvensi dan menimbulkan beban pemeliharaan yang tidak perlu

Gunakan string untuk data tekstual. Saat merepresentasikan data kompleks, uraikan string, dan gunakan abstraksi yang sesuai

A // BigInt const x = BigInt(Number.MAX_SAFE_INTEGER); // 9007199254740991n x + 1n === x + 2n; // false because 9007199254740992n and 9007199254740993n are unequal // Number Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2; // true because both are 9007199254740992 _0 adalah nilai primitif yang unik dan tidak dapat diubah dan dapat digunakan sebagai kunci properti Object (lihat di bawah). Dalam beberapa bahasa pemrograman, Simbol disebut "atom". Tujuan simbol adalah untuk membuat kunci properti unik yang dijamin tidak berbenturan dengan kunci dari kode lain

Dalam ilmu komputer, objek adalah nilai dalam memori yang mungkin direferensikan oleh pengidentifikasi. Dalam JavaScript, objek adalah satu-satunya nilai yang bisa berubah. Faktanya, fungsi juga merupakan objek dengan kemampuan tambahan untuk dapat dipanggil

Dalam JavaScript, objek dapat dilihat sebagai kumpulan properti. Dengan , sekumpulan properti terbatas diinisialisasi; . Properti objek setara dengan pasangan kunci-nilai. Kunci properti adalah salah satu atau. Nilai properti dapat berupa nilai dari jenis apa pun, termasuk objek lain, yang memungkinkan pembuatan struktur data yang kompleks

Ada dua jenis properti objek. dan. Setiap properti memiliki atribut yang sesuai. Setiap atribut diakses secara internal oleh mesin JavaScript, tetapi Anda dapat mengaturnya melalui const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 08, atau membacanya melalui const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 09. Anda dapat membaca lebih lanjut tentang berbagai nuansa di halaman const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 08

Properti data

Properti data mengaitkan kunci dengan nilai. Hal ini dapat dijelaskan dengan atribut berikut

Nilai diambil dengan mendapatkan akses properti. Dapat berupa nilai JavaScript apa pun

Nilai boolean yang menunjukkan apakah properti dapat diubah dengan penugasan

Nilai boolean yang menunjukkan apakah properti dapat dihitung dengan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 14 loop. Lihat juga Enumerabilitas dan kepemilikan properti untuk cara enumerabilitas berinteraksi dengan fungsi dan sintaks lainnya

Nilai boolean yang menunjukkan jika properti dapat dihapus, dapat diubah menjadi properti pengakses, dan atributnya dapat diubah

Properti aksesor

Kaitkan kunci dengan salah satu dari dua fungsi pengakses (const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 16 dan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 17) untuk mengambil atau menyimpan nilai

Catatan. Penting untuk mengenali properti pengakses — bukan metode pengakses. Kita dapat memberikan pengakses seperti kelas objek JavaScript dengan menggunakan fungsi sebagai nilai — tetapi itu tidak menjadikan objek sebagai kelas

Properti pengakses memiliki atribut berikut

Fungsi yang dipanggil dengan daftar argumen kosong untuk mengambil nilai properti setiap kali mendapatkan akses ke nilai tersebut dilakukan. Lihat juga getter. Mungkin const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 _2

Fungsi yang dipanggil dengan argumen yang berisi nilai yang ditetapkan. Dieksekusi setiap kali properti tertentu dicoba untuk diubah. Lihat juga setter. Mungkin const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 _2

Nilai boolean yang menunjukkan apakah properti dapat dihitung dengan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 14 loop. Lihat juga Enumerabilitas dan kepemilikan properti untuk cara enumerabilitas berinteraksi dengan fungsi dan sintaks lainnya

Nilai boolean yang menunjukkan jika properti dapat dihapus, dapat diubah menjadi properti data, dan atributnya dapat diubah

Prototipe suatu objek menunjuk ke objek lain atau ke null — ini secara konseptual merupakan properti tersembunyi dari objek tersebut, umumnya direpresentasikan sebagai const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 26. Properti const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 _26 objek juga dapat diakses pada objek itu sendiri

Objek adalah pasangan nilai kunci ad-hoc, sehingga sering digunakan sebagai peta. Namun, mungkin ada masalah ergonomi, keamanan, dan kinerja. Gunakan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 _28 untuk menyimpan data arbitrer sebagai gantinya. Berisi diskusi yang lebih rinci tentang pro & kontra antara objek biasa dan peta untuk menyimpan asosiasi nilai kunci

Saat merepresentasikan tanggal, pilihan terbaik adalah menggunakan utilitas const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 30 bawaan di JavaScript

Array adalah objek biasa yang memiliki hubungan khusus antara properti dengan kunci bilangan bulat dan properti const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 31

Selain itu, array mewarisi dari const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 _32, yang menyediakan beberapa metode praktis untuk memanipulasi array. Misalnya, const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 _33 mencari nilai dalam larik dan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 34 menambahkan elemen ke larik. Ini menjadikan Array kandidat yang sempurna untuk mewakili daftar yang dipesan

Typed Arrays menyajikan tampilan mirip-array dari buffer data biner yang mendasarinya, dan menawarkan banyak metode yang memiliki semantik serupa dengan rekan-rekan array. "Array yang diketik" adalah istilah umum untuk berbagai struktur data, termasuk const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 35, const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 36, dll. Periksa halaman array yang diketik untuk informasi lebih lanjut. Array yang diketik sering digunakan bersamaan dengan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 37 dan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 38

Struktur data ini mengambil referensi objek sebagai kunci. const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 39 dan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 40 mewakili kumpulan nilai unik, sedangkan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 28 dan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 42 mewakili kumpulan asosiasi nilai kunci

Anda dapat menerapkan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 _28s dan ________5______39s sendiri. Namun, karena objek tidak dapat dibandingkan (dalam arti const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 45 "kurang dari", misalnya), mesin juga tidak memaparkan fungsi hash untuk objek, kinerja pencarian harus linier. Implementasi asli dari mereka (termasuk const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 _42s) dapat memiliki kinerja pencarian yang kira-kira logaritmik ke waktu konstan

Biasanya, untuk mengikat data ke simpul DOM, seseorang dapat menyetel properti langsung pada objek, atau menggunakan atribut const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 47. Ini memiliki kelemahan bahwa data tersedia untuk skrip apa pun yang berjalan dalam konteks yang sama. const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 28s dan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 42s memudahkan pengikatan data ke objek secara pribadi

const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 42 dan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 40 hanya mengizinkan kunci objek, dan kunci diizinkan untuk menjadi sampah yang dikumpulkan meskipun tetap berada dalam koleksi. Mereka secara khusus digunakan untuk

JSON (JavaScript Object Notation) adalah format pertukaran data yang ringan, berasal dari JavaScript, tetapi digunakan oleh banyak bahasa pemrograman. JSON membangun struktur data universal yang dapat ditransfer antar lingkungan yang berbeda dan bahkan lintas bahasa. Lihat const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 _52 untuk detail lebih lanjut

JavaScript memiliki perpustakaan standar objek bawaan. Baca referensi untuk mengetahui lebih lanjut tentang objek bawaan

Seperti disebutkan di atas, JavaScript adalah bahasa. Ini berarti Anda sering dapat menggunakan nilai dari satu jenis di mana jenis lain diharapkan, dan bahasa akan mengonversinya menjadi jenis yang tepat untuk Anda. Untuk melakukannya, JavaScript mendefinisikan beberapa aturan paksaan

Proses ini digunakan di mana nilai primitif diharapkan, tetapi tidak ada preferensi yang kuat untuk jenis yang sebenarnya. Ini biasanya ketika a , an , atau a sama-sama dapat diterima. Sebagai contoh

• Konstruktor const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 _53, saat menerima satu argumen yang bukan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 30 — string mewakili string tanggal, sedangkan angka mewakili stempel waktu
• Operator === null1 — jika satu operan adalah string, penggabungan string dilakukan;
• The const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 _56 operator - jika satu operan adalah primitif sementara yang lain adalah objek, objek akan diubah menjadi nilai primitif tanpa tipe yang disukai

Operasi ini tidak melakukan konversi apa pun jika nilainya sudah primitif. Objek dikonversi menjadi primitif dengan memanggil const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 57 (dengan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 58 sebagai petunjuk), const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 59, dan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 60 metode, dalam urutan itu. Perhatikan bahwa panggilan konversi primitif const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 59 sebelum const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 60, yang mirip dengan perilaku tetapi berbeda dari

Metode const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 _57, jika ada, harus mengembalikan primitif — mengembalikan objek menghasilkan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 7. Untuk const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 _59 dan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 60, jika salah satu mengembalikan objek, nilai kembalian diabaikan dan nilai kembalian yang lain digunakan sebagai gantinya; . Misalnya pada kode berikut

console.log({} + []); // "[object Object]"

Baik const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 _68 maupun const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 69 tidak memiliki metode const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 57. Baik const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 _68 dan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 69 mewarisi const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 59 dari const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 74, yang mengembalikan objek itu sendiri. Karena nilai kembalian adalah objek, maka diabaikan. Oleh karena itu, const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 _60 dipanggil sebagai gantinya. const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 76 mengembalikan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 77, sementara const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 78 mengembalikan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 79, jadi hasilnya adalah gabungan mereka. const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 _77

Metode const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 _57 selalu didahulukan saat melakukan konversi ke tipe primitif apa pun. Konversi primitif umumnya berperilaku seperti konversi angka, karena const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 59 dipanggil dalam prioritas; . const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 30 dan // BigInt const x = BigInt(Number.MAX_SAFE_INTEGER); // 9007199254740991n x + 1n === x + 2n; // false because 9007199254740992n and 9007199254740993n are unequal // Number Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2; // true because both are 9007199254740992 0 objek adalah satu-satunya objek bawaan yang menggantikan metode const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 57. const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 87 memperlakukan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 58 petunjuk seolah-olah itu console.log(42 / +0); // Infinity console.log(42 / -0); // -Infinity 7, sementara const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 90 mengabaikan petunjuk dan selalu mengembalikan simbol

Ada dua tipe numerik. dan. Terkadang bahasa secara khusus mengharapkan angka atau BigInt (seperti const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 91, di mana indeks harus berupa angka); . Untuk proses pemaksaan ketat yang tidak mengizinkan konversi implisit dari tipe lain, lihat dan

Paksaan numerik hampir sama dengan , kecuali bahwa BigInts dikembalikan apa adanya alih-alih menyebabkan const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 7. Paksaan numerik digunakan oleh semua operator aritmatika, karena kelebihan beban untuk angka dan BigInts. Satu-satunya pengecualian adalah unary plus, yang selalu melakukan pemaksaan angka

Semua tipe data, kecuali Null, Undefined, dan Symbol, memiliki proses paksaan masing-masing. Lihat , , dan untuk lebih jelasnya

Seperti yang mungkin Anda perhatikan, ada tiga jalur berbeda di mana objek dapat diubah menjadi primitif

• const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 93 → const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 59 → const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 60
• , ,. const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 96 → const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 59 → const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 60
• const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 99 → const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 60 → const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 59

Dalam semua kasus, const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 _57, jika ada, harus dapat dipanggil dan mengembalikan primitif, sementara console.log(42 / +0); // Infinity console.log(42 / -0); // -Infinity 03 atau console.log(42 / +0); // Infinity console.log(42 / -0); // -Infinity 04 akan diabaikan jika tidak dapat dipanggil atau mengembalikan objek. Di akhir proses, jika berhasil, hasilnya dijamin primitif. Primitif yang dihasilkan kemudian tunduk pada paksaan lebih lanjut tergantung pada konteksnya

Berapa ukuran objek JavaScript?

Bagaimana menemukan ukuran objek dalam JavaScript dalam byte?

Berapa byte karakter JavaScript?

Apakah objek JS memiliki panjang?