Terjemahan ini belum lengkap. Mohon bantu menerjemahkan artikel ini dari Bahasa Inggris.

JavaScript dirancang berdasarkan paradigma berbasis objek sederhana. Sebuah objek adalah kumpulan dari properti, dan sebuah properti adalah pasangan hubungan antara sebuah nama (atau kunci) dan sebuah nilai. Nilai dari properti bisa berupa sebuah function/fungsi, Dalam kasus ini properti itu disebut method. Selain objek yang sudah di tentukan pada browser, Kamu bisa menentukan/membuat objek kamu sendiri. Bab ini menjelaskan bagaimana cara menggunakan objek, properti, function, dan method, serta bagaimana cara membuat objek kamu sendiri.

Ikhtisar Objek

 

Objek pada JavaScript sama seperti banyak bahasa pemrograman lainnya, dapat dibandingkan dengan objek dalam kehidupan nyata. Konsep objek dalam JavaScript dapat dipahami dengan kehidupan nyata, objek nyata.

Dalam JavaScript, objek adalah entitas yang berdiri sendiri dengan properti dan tipe. Bandingkan dengan sebuah cangkir, misalnya. Sebuah cangkir adalah objek dengan banyak properti. Cangkir memiliki warna, desain, berat, bahan terbuat dari, dll. Dengan jalan yang sama, objek JavaScript dapat memiliki banyak properti yang menentukan karakteristiknya.

 

Objek dan propertinya

Sebuah objek JavaScript memiliki banyak properti yang terkait dengannya. Sebuah properti dari sebuah objek dapat dijelaskan sebagai variabel yang dilampirkan pada objek itu. Properti-properti objek pada dasarnya sama dengan variabel JavaScript biasa, kecuali lampiran pada objek. Properti-properti dari sebuah objek menentukan karakteristik objek itu. Kamu mengakses properti objek dengan sebuah notasi titik sederhana:

namaObjek.namaProperti

Seperti semua variabel JavaScript, pasangan nama objek (yang bisa menjadi sebuah variabel normal) dan nama properti adalah bersifat peka terhadap huruf. Anda dapat menetapkan properti dengan memberikan sebuah nilai. Sebagai contoh, mari buat sebuah objek bernama mobilKu dan dan berikan dia properti bernama pembuat, model, dan tahun sebagai berikut:

var mobilKu = new Object();
mobilKu.pembuat = 'Ford';
mobilKu.model = 'Mustang';
mobilKu.tahun = 1969;

Properti pada sebuah objek yang tidak ditetapkan/diberi nilai adalah undefined (dan bukan null).

mobilKu.warna; // undefined

Properti-properti dari objek JavaScript juga dapat diakses atau diatur menggunakan notasi kurung siku (untuk lebih jelasnya lihat property accessors). Objek kadang-kadang disebut associative arrays, karena setiap properti dikaitkan dengan nilai string yang bisa digunakan untuk aksesnya. Jadi contohnya, Anda dapat mengakses properti-properti dari objek mobilKu osebagai berikut:

mobilKu['pembuat'] = 'Ford';
mobilKu['model'] = 'Mustang';
mobilKu['tahun'] = 1969;

Sebuah nama properti objek dapat berupa string dari JavaScript yang valid, atau apa pun yang dapat dirubah menjadi string, termasuk string kosong. Namun, nama properti apa pun yang tidak valid sebagai identifikasi di JavaScript (contohnya, nama properti yang memiliki spasi atau tanda hubung, atau yang dimulai dengan angka) hanya dapat diakses menggunakan notasi kurung siku. Notasi ini juga sangat berguna ketika nama properti harus ditentukan secara dinamis (ketika nama properti belum ditentukan hingga waktu proses). Contohnya adalah sebagai berikut:

// empat variabel dibuat dan diberi nilai di sekali jalan, 
// dipisahkan oleh koma
var myObj = new Object(),
    str = 'myString',
    rand = Math.random(),
    obj = new Object();

myObj.type              = 'sintak titik';
myObj['date created']   = 'String dengan spasi';
myObj[str]              = 'nilai String';
myObj[rand]             = 'Angka Acak';
myObj[obj]              = 'Objek';
myObj['']               = 'Bahkan sebuah string kosong';

console.log(myObj);

Tolong dicatat bahwa semua kunci di dalam notasi kurung siku dirubah ke dalam tipe String, karena dalam objek JavaScript hanya bisa memiliki tipe String sebagai tipe kunci. Sebagai contoh, dalam kode di atas, ketika kunci  obj ditambahkan dalam myObj, JavaScript akan memanggil method obj.toString() , dan menggunakan hasil berupa string ini sebagai kunci baru.

Kamu juga dapat mengakses properti dengan menggunakan nilai string yang disimpan dalam sebuah variabel:

var namaProperti = 'pembuat';
mobilKu[namaProperti] = 'Ford';

namaProperti = 'model';
mobilKu[namaProperti] = 'Mustang';

Kamu bisa menggunakan notasi kurung siku dengan for...in untuk mengiterasi ulang semua kumpulan properti yang terdaftar dari sebuah objek. Untuk mengilustrasikan cara kerjanya, fungsi berikut ini menampilkan properti-properti dari objek ketika kamu memasukkan objek dan nama objek sebagai argument pada fungsi/function:

function showProps(obj, objName) {
  var result = '';
  for (var i in obj) {
    // obj.hasOwnProperty() digunakan untuk menyaring properti dari rantai prototipe objek
    if (obj.hasOwnProperty(i)) {
      result += objName + '.' + i + ' = ' + obj[i] + '\n';
    }
  }
  return result;
}

Jadi memanggil fungsi/function showProps(mobilKu, "mobilKu") akan mengembalikan:

mobilKu.pembuat = Ford
mobilKu.model = Mustang
mobilKu.tahun = 1969

Menyebutkan properti dari sebuah objek

Dimulai dengan  ECMAScript 5, ada tiga cara asli untuk mendaftarkan / melintasi properti-properti objek:

  • Perulangan for...in
    Metode ini melintasi semua kumpulan properti yang terdaftar dari sebuah objek dan rantai prototipnya.
  • Object.keys(o)
    Method ini mengembalikan array dengan semua milik (tidak di rantai prototip) nama-nama ("kunci") properti terhitung dari sebuah objek o.
  • Object.getOwnPropertyNames(o)
    Metode ini mengembalikan sebuah array berisikan semua nama-nama properti (kumpulan terhitung atau tidak) dari sebuah objek o.

Sebelum ECMAScript 5, tidak ada cara asli untuk mendaftarkan semua properti-properti dari suatu objek. Namun, ini dapat dicapai dengan fungsi berikut:

function listAllProperties(o) {
	var objectToInspect;     
	var result = [];
	
	for(objectToInspect = o; objectToInspect !== null; objectToInspect = Object.getPrototypeOf(objectToInspect)) {  
      result = result.concat(Object.getOwnPropertyNames(objectToInspect));  
	}
	
	return result; 
}

Ini dapat berguna untuk memperlihatkan properti-properti  tersembunyi" (properti-properti dalam rantai prototip yang tidak dapat diakses melalui objek, karena properti lain memiliki nama yang sama di rantai prototip sebelumnya). Mendaftarkan properti-properti yang dapat diakses hanya dapat dilakukan dengan menghapus duplikat di dalam array.

Membuat Objek Baru

JavaScript mempunyai sejumlah objek yang telah ditetapkan. Selain itu, Kamu dapat membuat objek sendiri. Kamu bisa membuat sebuah objek menngunakan sebuah object initializer. Sebagai alternatif, kamu bisa membuat sebuah fungsi konstruktor lalu menginstanisasi sebuah pemanggilan objek bersama dengan operator new.

Menggunakan object initializers

Selain membuat objek menggunakan fungsi konstruktor, kamu bisa membuat objek menggunakan sebuah object initializer. Menggunakan object initializers terkadang disebut sebagai  membuat objek dengan notasi literal. "Object initializer" sesuai dengan terminologi yang digunakan oleh C++.

Sintak untuk objek yang menggunakan sebuah object initializer adalah:

var obj = { property_1:   value_1,   // property_# may be an identifier...
            2:            value_2,   // or a number...
            // ...,
            'property n': value_n }; // or a string

Dimana obj adalah nama dari objek baru, setiap property_i adalah sebuah pengidentifikasi (baik sebuah nama, sebuah angka, atau sebuah string literal), dan setiap value_i adalah sebuah ekpresi yang nilainya sudah ditetapkan pada property_i.  obj dan penetapan nilai adalah opsional, jika kamu tidak butuh rujukan ke objek ini, kamu tidak perlu menetapkannya ke sebuah variabel. (Catatan bahwa kamu perlu untuk  membungkus objek literal dalam sebaris jika objek muncul dimana sebuah statement di harapkan, jadi kamu tidak punya literal yang bingung dengan sebuah blok statement.)

Object initializers adalah ekpresi, dan setiap object initializer mengembalikan sebuah objek baru. Sebuah objek baru dibuat sewaktu statement yang muncul di eksekusi. Object initializers identik membuat objek berbeda yang tidak akan sama apabila dibandingkan. Objek dibuat jika sebuah pemanggilan new Object() adalah objek dari ekpresi literal objek instan dari Object.

Pernyataan berikut membuat objek dan menetapkannya ke variabel x jika dan hanya jika ekspresi cond adalah benar:

if (cond) var x = {greeting: 'hi there'};

Contoh berikut membuat myHonda dengan tiga properti. Perhatikan bahwa properti engine juda adalah sebuah objek yang mempunyai properti-propertinya sendiri.

var myHonda = {color: 'red', wheels: 4, engine: {cylinders: 4, size: 2.2}};

Kamu juga bisa menggunakan object initializers untuk membuat arrays. Lihat array literals.

Menggunakan fungsi konstruktor

Kamu bisa membuat sebuah objek dengan dua langkah alternatif ini:

  1. Tetapkan tipe objek dengan menulis sebuah fungsi konstruktor. Ada kebiasaan dengan alasan yang bagus untuk menggunakan huruf besar di awal huruf.
  2. Membuat sebuah instan objek dengan new.

Untuk menetapkan sebuah tipe objek, buat fungsi untuk tipe objek tersebut yang menentukan nama, properti-properti, dan method-methodnya. Misalnya, Anda ingin membuat jenis objek untuk mobi. Kamu ingin jenis objek ini disebut Mobil,  dan kamu ingin memiliki properti pembuat, model, dan tahun. Untuk melakukan ini, kamu akan menulis fungsi berikut:

function Mobil(pembuat, model, tahun) {
  this.pembuat= pembuat;
  this.model = model;
  this.tahun= tahun;
}

Perhatikan penggunaan this untuk menetapkan nilai ke properti objek berdasarkan nilai yang diteruskan kepada fungsi.

Sekarang kamu bisa membuat sbuah objek yang disebut mobilku sebagai berikut:

var mobilku = new Mobil('Eagle', 'Talon TSi', 1993);

Statement ini membuat mobilku dan memberikannya nilai yang spesifik untuk propertinya. Lalu nilai dari mobilku.pembuat adalah string "Eagle", mobilku.tahun adalah integer 1993, dan seterusnya.

Kamu bisa membuat sejumlah objek Mobil dengan memanggil to new. Sebagai contoh.

var mobilkens = new Mobil('Nissan', '300ZX', 1992);
var mobilrap = new Mobil('Mazda', 'Miata', 1990);

Sebuah objek bisa mempunyai properti yang merupakan objek lain. Misalnya, Kamu mendefinisikan objek yang disebut orang sebagai berikut:

function Orang(nama, umur, kelamin) {
  this.nama = nama;
  this.umur = umur;
  this.kelamin = kelamin;
}

dan kemudian instan dua objek baru dengan new orangn sebagai berikut:

var rap = new Orang('Rap McKinnon', 33, 'Pria');
var ken = new Orang('Ken Jones', 39, 'Pria');

Kemudian, Anda dapat menulis ulang definisi Mobil untuk memasukan properti pemilik yang membutuhkan sebuah objek orang sebagai berikut:

function Mobil(pembuat, model, tahun, pemilik) {
  this.pembuat= pembuat;
  this.model = model;
  this.tahun = tahun;
  this.pemilik = pemilik;
}

Untuk membuat instan objek baru, kamu gunakan berikut:

var mobil1 = new Mobil('Eagle', 'Talon TSi', 1993, rap);
var mobil2 = new Mobil('Nissan', '300ZX', 1992, ken);

Catatan pengganti dari memasukkan sebuah nilai string literal dan integer ketika membuat objek baru, statement diatas memasukkan objek rap dan ken sebagai argument untuk pemilik. Kemudian jika kamu ingin mencari nama pemilik mobil2, kamu bisa mengakses properti berikut:

mobil2.pemilik.nama

Catatan bahka kamu selalu bisa menambahkan sebuah properti pada objek yang sebelumnya telah di buat. Contohnya statement

mobil1.warna= 'hitam';

menambahkan sebuah properti warna pada mobil1, dan memberikan sebuah nilai "hitam". Ini tidak mempengaruhi objek lain. Untuk menambahkan properti baru untuk semua objek dari tipe yang sama, kamu harus menambahkan properti pada definisi tipe objek Mobil.

Menggunakan method Object.create

Objek bisa juga di buat menggunakan method Object.create(). Method ini bisa sangat berguna, karena method ini membolehkan kamu memilih prototip objek untuk objek yang ingin kamu buat, tanpa harus mendefiniskan fungsi konstruktor.

//encapsulasi/pembungkusan 
//properti-properti dan method Hewan 
var Hewan = {
  type: 'Tidak bertulang belakang', // nilai awal properti
  displayType: function() {  // Method yang akan menampilkan tipe Hewan
    console.log(this.type);
  }
};

// Membuat hewan baru yang disebut hewan1 
var hewan1 = Object.create(Hewan);
hewan1.displayType(); // Keluaran:Tidak bertulang belakang

// Membuat hewan baru yang disebut Ikan
var ikan = Object.create(Hewan);
ikan.type = 'Ikan';
ikan.displayType(); // Keluaran:Ikan

Inheritance/Turunan

Semua objek pada javascript diturunkan setidaknya dari satu objek lain. Objek yang telah diturunkan disebut prototip, dan properti turunan bisa ditemukan dalam objek prototype dari konstruktor. Lihat Inheritance and the prototype chain untuk informasi lebih lanjut.

Meng-Indek properti objek

Kamu dapat merujuk pada sebuah properti objek dengan nama propertinya atau dengan indek urutannya. Jika kamu awalnya mendefinisikan properti dengan namanya, kamu harus selalu merujuknya dengan namanya, dan jika kamu awalnya mendefinisikan properti berdasarkan indek, kamu harus selalu merujuknya berdasarkan indeknya.

Pembatasan ini berlaku ketika kamu membuat objek dan propertinya dengan fungsi konstruktor (seperti yang kita lakukan sebelumnya dengan jenis objek Mobil) dan ketika kamu mendefinisikan properti individu secara eksplisit (misalnya, mobilKu.warna = "merah"). Jika kamu awalnya mendefinisikan properti objek dengan indek, seperti mobilKu[5] = "25 mpg", kemudian kamu hanya merujuk pada properti mobilKu[5].

Pengecualian terhadap aturan ini adalah objek seperti array yang seperti objek pantulan dari HTML, seperti forms array yang seperti objek. Kamu selalu dapat merujuk pada objek dalam objek-objek array ini yang seperti objects menggunakan nomor urutan mereka (berdasarkan di mana mereka muncul dalam dokumen) atau nama mereka (jika didefinisikan). Misalnya, jika tag <FORM> kedua dalam dokumen mempunyai sebuah NAMA dari atribut "myForm", kamu dapat merujuk pada formulir sebagaidocument.forms[1] atau document.forms["myForm"] atau document.forms.myForm.

Mendefinisikan properti untuk sebuah tipe objek

Kamu dapat menambahkan properti ke jenis objek yang ditetapkan sebelumnya dengan menggunakan properti prototype. Ini definisi sebuah properti yang dibagikan oleh semua objek dari tipe yang ditentukan, bukan hanya oleh satu contoh instan objek. Kode berikut menambahkan sebuah properti warna untuk semua objek dari tipe objek Mobil, dan kemudian menetapkan nilai ke properti warna dari objek mobil1.

Mobil.prototype.warna = null;
mobil1.warna = 'hitam';

Lihat prototype property dari objek Function dalam JavaScript reference untuk informasi lebih lanjut.

Mendefiniskan method

Method adalah sebuah function yang terkait pada sebuah objek, atau sederhananya sebuah method adalah sebuah properti dari sebuah objek yang merupakan sebuah function. Method di definisikan sejalan dengan function normal di definisikan, kecuali mereka ditetapkan sebagai properti dari sebuah objek. Lihat juga method definitions untuk lebih detail. Contohnya adalah:

objectName.methodname = functionName;

var myObj = {
  myMethod: function(params) {
    // ...do something
  }

  // OR THIS WORKS TOO

  myOtherMethod(params) {
    // ...do something else
  }
};

Dimana objectName adalah method yang sudah ada, methodname adalah nama yang kamu tetapkan untuk method, dan functionName adalah nama dari sebuah function.

Kamu kemudian dapat memanggil method dalam kontek objek sebagai berikut:

object.methodname(params);

Kamu bisa mendefinisikan method untuk sebuah method untuk sebuah tipe objek dengan memasukkan sebuah definisi method pada function konstruktor objek. Kamu bisa menddefinisikan sebuah function yang akan memformat dan menampilkan properti-properti dari objek Mobil yang sudah di definisikan sebelumnya. Sebagai contoh,

function tampilMobil() {
  var hasil = 'Secantik ' + this.tahun + ' ' + this.pembuat
    + ' ' + this.model;
  pretty_print(hasil);
}

Dimana pretty_print adalah sebuah function untuk menampilkan sebuah garis mendatar dan sebuah string. Perhatikan penggunaan this untuk merujuk pada objek yang mempunyai method tersebut.

Kamu bisa menjadikan function sebuah method dari objek Mobil dengan menambahkan statement

this.tampilMobil = tampilMobil;

pada definisi objek. Jadi definisi dari seluruh Mobil sekarang akan terlihat seperti

function Mobil(pembuat, model, tahun, pemilik) {
  this.pembuat = pembuat;
  this.model = model;
  this.tahun = tahun;
  this.pemilik = pemilik;
  this.tampilMobil = tampilMobil;
}

Maka kamu bisa memanggil method tampilMobil untuk masing masih objek sebagai berikut:

mobil1.tampilMobil();
mobil2.tampilMobil();

Menggunakan this untuk referensi Objek

JavaScript mempunyai kata kunci special this, kamu bisa menggunakannya didalam method untuk merujuk ke objek saat ini. Misalnya, kamu memiliki sebuah function yang disebut validate yang memvalidasi sebuah properti value yang diberikan pada objek dan nilai-nilai tinggi dan rendah:

function validate(obj, lowval, hival) {
  if ((obj.value < lowval) || (obj.value > hival)) {
    alert('Invalid Value!');
  }
}

Kemudian kamu bisa memanggil validate di setiap elemen-elemen form yang menangani peristiwa/event onchange, gunakan this untuk meneruskan elemen. Seperti pada contoh berikut:

<input type="text" name="age" size="3"
  onChange="validate(this, 18, 99)">

Secara umum, this mengacu pada pemanggilan objek di sebuah method.

Ketika dikombinasikan dengan properti form, this bisa mengacu pada induk/parent objek form saat ini. Dalam contoh berikut, form myForm berisi sebuah objek Text dan sebuah tombol/button. Ketika pengguna mengklik tombol, nilai dari sebuah objek Text diatur ke nama form tersebut. Yang menangani peristiwa/event onclick pada tombol/button menggunakan this.form untuk merujuk pada induk/parent form, myForm.

<form name="myForm">
<p><label>Form name:<input type="text" name="text1" value="Beluga"></label>
<p><input name="button1" type="button" value="Show Form Name"
     onclick="this.form.text1.value = this.form.name">
</p>
</form>

Mendefinisikan getters dan setters

Sebuah getter adalah sebuah method yang mendapatkan nilai dari sebuah properti khusus. Sebuah setter adalah sebuah method yang mengatur nilai dari sebuah properti khusus. Kamu bisa menetapkan getters dan setters pada objek inti apapun yang sudah ditetapkan atau objek yang ditetapkan pengguna yang mendukung penambahan peroperti-properti baru. Sintak untuk mendefinisikan getters dan setters menggunakan sintak objekt literal.

Berikut ini mengilustrasikan bagaimana getters dan setters bisa bekerja untuk sebuah objek o yang sudah ditetapkan pengguna.

var o = {
  a: 7,
  get b() { 
    return this.a + 1;
  },
  set c(x) {
    this.a = x / 2;
  }
};

console.log(o.a); // 7
console.log(o.b); // 8
o.c = 50;
console.log(o.a); // 25

Properti-properti objek o adalah:

  • o.a — sebuah angka
  • o.b — sebuah getter yang mengembalikan o.a tambah 1
  • o.c — sebuah setter yang mengatur nilai  o.a dari nilai setengah o.c yang sudah diatur.

Harap dicatat bahwa nama function dari getters dan setters didefisinikan dalam sebuah objek literal menggunakan "[gs]et property()" (dibandingkan dengan __define[GS]etter__ ) yang bukan nama-nama dari getters mereka sendiri, meskipun sintak [gs]et propertyName(){ } kamu berpikir lain mungkin mengelirukan. Untuk menamai sebuah function pada sebuah getter atau setter menggunakan sintak "[gs]et property()", mendefiniskan sebuah nama function terprogram secara explisit menggunakan Object.defineProperty (atau alternatiif pengganti Object.prototype.__defineGetter__).

Kode berikut mengilustrasikan bagaimana getters dan setters bisa memperluas prototip Date untuk menambahkan sebuah properti year untuk semua instan-instan dari kelas Date yang sudah didefinisikan. Menggunakan kelas Date  dari method-method yang sudah ada getFullYear dansetFullYear untuk mendukung properti-properti getter and setter year.

Statemen-statemen ini mendefinisikan sebuah getter and setter untuk properti year:

var d = Date.prototype;
Object.defineProperty(d, 'year', {
  get: function() { return this.getFullYear(); },
  set: function(y) { this.setFullYear(y); }
});

Statemen-statemen ini menggunakan getter and setterpada sebuah objek Date:

var now = new Date();
console.log(now.year); // 2000
now.year = 2001; // 987617605170
console.log(now);
// Wed Apr 18 11:13:25 GMT-0700 (Pacific Daylight Time) 2001

In principle, getters and setters can be either

  • defined using object initializers, or
  • added later to any object at any time using a getter or setter adding method.

When defining getters and setters using object initializers all you need to do is to prefix a getter method with get and a setter method with set. Of course, the getter method must not expect a parameter, while the setter method expects exactly one parameter (the new value to set). For instance:

var o = {
  a: 7,
  get b() { return this.a + 1; },
  set c(x) { this.a = x / 2; }
};

Getters and setters can also be added to an object at any time after creation using the Object.defineProperties method. This method's first parameter is the object on which you want to define the getter or setter. The second parameter is an object whose property names are the getter or setter names, and whose property values are objects for defining the getter or setter functions. Here's an example that defines the same getter and setter used in the previous example:

var o = { a: 0 };

Object.defineProperties(o, {
    'b': { get: function() { return this.a + 1; } },
    'c': { set: function(x) { this.a = x / 2; } }
});

o.c = 10; // Runs the setter, which assigns 10 / 2 (5) to the 'a' property
console.log(o.b); // Runs the getter, which yields a + 1 or 6

Which of the two forms to choose depends on your programming style and task at hand. If you already go for the object initializer when defining a prototype you will probably most of the time choose the first form. This form is more compact and natural. However, if you need to add getters and setters later — because you did not write the prototype or particular object — then the second form is the only possible form. The second form probably best represents the dynamic nature of JavaScript — but it can make the code hard to read and understand.

Deleting properties

You can remove a non-inherited property by using the delete operator. The following code shows how to remove a property.

// Creates a new object, myobj, with two properties, a and b.
var myobj = new Object;
myobj.a = 5;
myobj.b = 12;

// Removes the a property, leaving myobj with only the b property.
delete myobj.a;
console.log ('a' in myobj); // yields "false"

You can also use delete to delete a global variable if the var keyword was not used to declare the variable:

g = 17;
delete g;

Comparing Objects

In JavaScript objects are a reference type. Two distinct objects are never equal, even if they have the same properties. Only comparing the same object reference with itself yields true.

// Two variables, two distinct objects with the same properties
var fruit = {name: 'apple'};
var fruitbear = {name: 'apple'};

fruit == fruitbear; // return false
fruit === fruitbear; // return false
// Two variables, a single object
var fruit = {name: 'apple'};
var fruitbear = fruit;  // assign fruit object reference to fruitbear

// here fruit and fruitbear are pointing to same object
fruit == fruitbear; // return true
fruit === fruitbear; // return true
fruit.name = 'grape';
console.log(fruitbear);    // yields { name: "grape" } instead of { name: "apple" }

For more information about comparison operators, see Comparison operators.

See also

Tag Dokumen dan Kontributor

Kontributor untuk laman ini: Fidelstu
Terakhir diperbarui oleh: Fidelstu,