Apa yang dilakukan bind () dalam javascript?

Question

Metode bind() Fungsi JavaScript digunakan untuk membuat fungsi baru. Saat sebuah fungsi dipanggil, ia memiliki kata kunci this sendiri yang disetel ke nilai yang diberikan, dengan urutan argumen tertentu

Table of Contents Show

Nilai Pengembalian
Contoh metode fungsi bind() JavaScript
Contoh 2. Menggunakan Metode bind() dengan dua Parameter
Kapan menggunakan bind dalam JavaScript?
Bagaimana cara memanggil () menerapkan () dan mengikat () dalam JavaScript?

Sintaksis

Parameter

thisArg - Nilai this diteruskan ke fungsi target

argumen1,argu2,. ,argn - Ini mewakili argumen untuk fungsi tersebut

Nilai Pengembalian

Ini mengembalikan replika dari fungsi yang diberikan sepanjang memberikan nilai ini dan argumen awal

Contoh metode fungsi bind() JavaScript

Contoh 1

Mari kita lihat contoh sederhana dari metode bind()

Uji Sekarang

Keluaran

Contoh 2

Mari kita lihat contoh metode bind()

Uji Sekarang

Keluaran

Javatpoint Oracle Javatpoint

Karena siswa2 tidak memiliki metode

func.bind(thisArg, arg1, .. argN)

_8, kami meminjamnya dari siswa1 menggunakan fungsi bind()

// object definition
const student1 = {
  name: "Jack",
  grade: "5",
  introduction: function () {
    console.log(this.name + "studies in grade" + this.grade + ".");
  },
};

// object definition
const student2 = {
  name: "Jimmy ",
  grade: " 6",
};

// the object student2 is borrowing introduction method from student1
let result= student1.introduction.bind(student2);

// invoking result() function
result();  // Jimmy studies in grade 6.

0 mengembalikan salinan

func.bind(thisArg, arg1, .. argN)

8 dan menugaskannya ke hasil

Contoh 2. Menggunakan Metode bind() dengan dua Parameter

// object definition
const student1 = {
  name: "Jack",
  introduction: function (score) {
    console.log(this.name + "scored " + score + " in an exam.");
  },
};

// object definition
const student2 = {
  name: "Jimmy ",
};

// passing two parameters student2 and '95'
let result = student1.introduction.bind(student2, 95);

// invoking result() function
result(); // Jimmy scored 95 in an exam.

_

Keluaran

Jimmy scored 95 in an exam.

Dalam contoh di atas, kami telah melewati dua parameter thisArg dan arg1 di bind()

Objek student2 diteruskan sebagai parameter

func.bind(thisArg, arg1, .. argN)

_1 dan 95 diteruskan sebagai argumen untuk parameter skor

Sekarang, sebuah program sederhana untuk mencetak nama yang dipanggil oleh kata kunci ini ketika fungsi printFunc() dipanggil

<script>

var geeks = {

name :"ABC",

//no output is produced by this code//

0

//no output is produced by this code//

1

//no output is produced by this code//

2

//no output is produced by this code//

3

//no output is produced by this code//

4

//no output is produced by this code//

5

//no output is produced by this code//

09

//no output is produced by this code//

10

//no output is produced by this code//

11

//no output is produced by this code//

5

//no output is produced by this code//

13

//no output is produced by this code//

14________7______15

Saat meneruskan metode objek sebagai panggilan balik, misalnya ke

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

6, ada masalah yang diketahui. "kehilangan

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

_7"

Dalam bab ini kita akan melihat cara untuk memperbaikinya

Kami telah melihat contoh kehilangan

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

7. Setelah metode diteruskan ke suatu tempat secara terpisah dari objek –

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

7 hilang

Inilah yang mungkin terjadi dengan

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

6

let user = {
  firstName: "John",
  sayHi() {
    alert(`Hello, ${this.firstName}!`);
  }
};

setTimeout(user.sayHi, 1000); // Hello, undefined!

Seperti yang bisa kita lihat, output menunjukkan bukan “John” sebagai

let user = {
  firstName: "John",
  sayHi() {
    alert(`Hello, ${this.firstName}!`);
  }
};

setTimeout(function() {
  user.sayHi(); // Hello, John!
}, 1000);

1, tetapi

let user = {
  firstName: "John",
  sayHi() {
    alert(`Hello, ${this.firstName}!`);
  }
};

setTimeout(function() {
  user.sayHi(); // Hello, John!
}, 1000);

2

Itu karena

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

_6 mendapatkan fungsi

let user = {
  firstName: "John",
  sayHi() {
    alert(`Hello, ${this.firstName}!`);
  }
};

setTimeout(function() {
  user.sayHi(); // Hello, John!
}, 1000);

4, terpisah dari objek. Baris terakhir dapat ditulis ulang sebagai

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

Metode

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

_6 dalam browser sedikit istimewa. itu menetapkan

let user = {
  firstName: "John",
  sayHi() {
    alert(`Hello, ${this.firstName}!`);
  }
};

setTimeout(function() {
  user.sayHi(); // Hello, John!
}, 1000);

_6 untuk pemanggilan fungsi (untuk Node. js,

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

_7 menjadi objek pengatur waktu, tetapi tidak terlalu penting di sini). Jadi untuk

let user = {
  firstName: "John",
  sayHi() {
    alert(`Hello, ${this.firstName}!`);
  }
};

setTimeout(function() {
  user.sayHi(); // Hello, John!
}, 1000);

_1 mencoba untuk mendapatkan

let user = {
  firstName: "John",
  sayHi() {
    alert(`Hello, ${this.firstName}!`);
  }
};

setTimeout(function() {
  user.sayHi(); // Hello, John!
}, 1000);

9, yang tidak ada. Dalam kasus serupa lainnya, biasanya

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

7 menjadi

let user = {
  firstName: "John",
  sayHi() {
    alert(`Hello, ${this.firstName}!`);
  }
};

setTimeout(function() {
  user.sayHi(); // Hello, John!
}, 1000);

2

Tugasnya cukup khas – kami ingin meneruskan metode objek di tempat lain (di sini – ke penjadwal) di mana ia akan dipanggil. Bagaimana cara memastikan bahwa itu akan dipanggil dalam konteks yang benar?

Solusi paling sederhana adalah dengan menggunakan fungsi pembungkus

let user = {
  firstName: "John",
  sayHi() {
    alert(`Hello, ${this.firstName}!`);
  }
};

setTimeout(function() {
  user.sayHi(); // Hello, John!
}, 1000);

Sekarang berfungsi, karena menerima

setTimeout(() => user.sayHi(), 1000); // Hello, John!

_2 dari lingkungan leksikal luar, dan kemudian memanggil metode secara normal

Sama, tapi lebih pendek

setTimeout(() => user.sayHi(), 1000); // Hello, John!

Terlihat bagus, tetapi sedikit kerentanan muncul di struktur kode kami

Bagaimana jika sebelum

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

_6 dipicu (ada penundaan satu detik. )

setTimeout(() => user.sayHi(), 1000); // Hello, John!

_2 mengubah nilai?

let user = {
  firstName: "John",
  sayHi() {
    alert(`Hello, ${this.firstName}!`);
  }
};

setTimeout(() => user.sayHi(), 1000);

// ...the value of user changes within 1 second
user = {
  sayHi() { alert("Another user in setTimeout!"); }
};

// Another user in setTimeout!

Solusi selanjutnya menjamin hal seperti itu tidak akan terjadi

Fungsi menyediakan pengikatan metode bawaan yang memungkinkan untuk memperbaiki

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

7

Sintaks dasarnya adalah

// more complex syntax will come a little later
let boundFunc = func.bind(context);

Hasil dari

setTimeout(() => user.sayHi(), 1000); // Hello, John!

_6 adalah "objek eksotis" seperti fungsi khusus, yang dapat dipanggil sebagai fungsi dan secara transparan meneruskan panggilan ke pengaturan

setTimeout(() => user.sayHi(), 1000); // Hello, John!

7

setTimeout(() => user.sayHi(), 1000); // Hello, John!

8

Dengan kata lain, memanggil

setTimeout(() => user.sayHi(), 1000); // Hello, John!

_9 seperti

setTimeout(() => user.sayHi(), 1000); // Hello, John!

7 dengan

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

7 tetap

Misalnya, di sini

let user = {
  firstName: "John",
  sayHi() {
    alert(`Hello, ${this.firstName}!`);
  }
};

setTimeout(() => user.sayHi(), 1000);

// ...the value of user changes within 1 second
user = {
  sayHi() { alert("Another user in setTimeout!"); }
};

// Another user in setTimeout!

2 meneruskan panggilan ke

setTimeout(() => user.sayHi(), 1000); // Hello, John!

7 dengan

let user = {
  firstName: "John",
  sayHi() {
    alert(`Hello, ${this.firstName}!`);
  }
};

setTimeout(() => user.sayHi(), 1000);

// ...the value of user changes within 1 second
user = {
  sayHi() { alert("Another user in setTimeout!"); }
};

// Another user in setTimeout!

4

let user = {
  firstName: "John"
};

function func() {
  alert(this.firstName);
}

let funcUser = func.bind(user);
funcUser(); // John

Di sini

let user = {
  firstName: "John",
  sayHi() {
    alert(`Hello, ${this.firstName}!`);
  }
};

setTimeout(() => user.sayHi(), 1000);

// ...the value of user changes within 1 second
user = {
  sayHi() { alert("Another user in setTimeout!"); }
};

// Another user in setTimeout!

_5 sebagai "varian terikat" dari

setTimeout(() => user.sayHi(), 1000); // Hello, John!

7, dengan

let user = {
  firstName: "John",
  sayHi() {
    alert(`Hello, ${this.firstName}!`);
  }
};

setTimeout(() => user.sayHi(), 1000);

// ...the value of user changes within 1 second
user = {
  sayHi() { alert("Another user in setTimeout!"); }
};

// Another user in setTimeout!

4 tetap

Semua argumen diteruskan ke

setTimeout(() => user.sayHi(), 1000); // Hello, John!

_7 asli "sebagaimana adanya", misalnya

let user = {
  firstName: "John"
};

function func(phrase) {
  alert(phrase + ', ' + this.firstName);
}

// bind this to user
let funcUser = func.bind(user);

funcUser("Hello"); // Hello, John (argument "Hello" is passed, and this=user)

Sekarang mari kita coba dengan metode objek

let user = {
  firstName: "John",
  sayHi() {
    alert(`Hello, ${this.firstName}!`);
  }
};

let sayHi = user.sayHi.bind(user); // (*)

// can run it without an object
sayHi(); // Hello, John!

setTimeout(sayHi, 1000); // Hello, John!

// even if the value of user changes within 1 second
// sayHi uses the pre-bound value which is reference to the old user object
user = {
  sayHi() { alert("Another user in setTimeout!"); }
};

Di baris

let user = {
  firstName: "John",
  sayHi() {
    alert(`Hello, ${this.firstName}!`);
  }
};

setTimeout(() => user.sayHi(), 1000);

// ...the value of user changes within 1 second
user = {
  sayHi() { alert("Another user in setTimeout!"); }
};

// Another user in setTimeout!

9 kami mengambil metode

let user = {
  firstName: "John",
  sayHi() {
    alert(`Hello, ${this.firstName}!`);
  }
};

setTimeout(function() {
  user.sayHi(); // Hello, John!
}, 1000);

4 dan mengikatnya ke

setTimeout(() => user.sayHi(), 1000); // Hello, John!

2.

// more complex syntax will come a little later
let boundFunc = func.bind(context);

_2 adalah fungsi "terikat", yang dapat dipanggil sendiri atau diteruskan ke

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

6 - tidak masalah, konteksnya akan benar

Di sini kita dapat melihat bahwa argumen disampaikan "sebagaimana adanya", hanya

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

7 yang diperbaiki oleh

// more complex syntax will come a little later
let boundFunc = func.bind(context);

5

let user = {
  firstName: "John",
  say(phrase) {
    alert(`${phrase}, ${this.firstName}!`);
  }
};

let say = user.say.bind(user);

say("Hello"); // Hello, John! ("Hello" argument is passed to say)
say("Bye"); // Bye, John! ("Bye" is passed to say)

Metode kenyamanan.

// more complex syntax will come a little later
let boundFunc = func.bind(context);

6

Jika sebuah objek memiliki banyak metode dan kami berencana untuk menyebarkannya secara aktif, maka kami dapat mengikat semuanya dalam satu lingkaran

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

0

Pustaka JavaScript juga menyediakan fungsi untuk pengikatan massal yang nyaman, mis. g. di lodash

Sampai saat ini kita hanya berbicara tentang mengikat

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

7. Mari kita melangkah lebih jauh

Kami tidak hanya dapat mengikat

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

_7, tetapi juga argumen. Itu jarang dilakukan, tetapi terkadang bisa berguna

Sintaks lengkap dari

// more complex syntax will come a little later
let boundFunc = func.bind(context);

5

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

1

Ini memungkinkan untuk mengikat konteks sebagai

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

_7 dan memulai argumen dari fungsi tersebut

Misalnya, kita memiliki fungsi perkalian

let user = {
  firstName: "John"
};

function func() {
  alert(this.firstName);
}

let funcUser = func.bind(user);
funcUser(); // John

1

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

2

Mari gunakan

// more complex syntax will come a little later
let boundFunc = func.bind(context);

_5 untuk membuat fungsi

let user = {
  firstName: "John"
};

function func() {
  alert(this.firstName);
}

let funcUser = func.bind(user);
funcUser(); // John

3 pada basisnya

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

3

Panggilan ke

let user = {
  firstName: "John"
};

function func() {
  alert(this.firstName);
}

let funcUser = func.bind(user);
funcUser(); // John

4 membuat fungsi baru

let user = {
  firstName: "John"
};

function func() {
  alert(this.firstName);
}

let funcUser = func.bind(user);
funcUser(); // John

3 yang meneruskan panggilan ke

let user = {
  firstName: "John"
};

function func() {
  alert(this.firstName);
}

let funcUser = func.bind(user);
funcUser(); // John

6, memperbaiki

let user = {
  firstName: "John"
};

function func() {
  alert(this.firstName);
}

let funcUser = func.bind(user);
funcUser(); // John

7 sebagai konteks dan

let user = {
  firstName: "John"
};

function func() {
  alert(this.firstName);
}

let funcUser = func.bind(user);
funcUser(); // John

8 sebagai argumen pertama. Argumen lebih lanjut dilewatkan "sebagaimana adanya"

Itu disebut aplikasi fungsi parsial – kami membuat fungsi baru dengan memperbaiki beberapa parameter yang sudah ada

Harap dicatat bahwa kami sebenarnya tidak menggunakan

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

7 di sini. Tapi

// more complex syntax will come a little later
let boundFunc = func.bind(context);

_5 membutuhkannya, jadi kita harus memasukkan sesuatu seperti

let user = {
  firstName: "John"
};

function func() {
  alert(this.firstName);
}

let funcUser = func.bind(user);
funcUser(); // John

7

Fungsi

let user = {
  firstName: "John"
};

function func(phrase) {
  alert(phrase + ', ' + this.firstName);
}

// bind this to user
let funcUser = func.bind(user);

funcUser("Hello"); // Hello, John (argument "Hello" is passed, and this=user)

_2 dalam kode di bawah melipatgandakan nilainya

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

4

Mengapa kita biasanya membuat fungsi parsial?

Manfaatnya adalah kita dapat membuat fungsi independen dengan nama yang dapat dibaca (

let user = {
  firstName: "John"
};

function func() {
  alert(this.firstName);
}

let funcUser = func.bind(user);
funcUser(); // John

3,

let user = {
  firstName: "John"
};

function func(phrase) {
  alert(phrase + ', ' + this.firstName);
}

// bind this to user
let funcUser = func.bind(user);

funcUser("Hello"); // Hello, John (argument "Hello" is passed, and this=user)

2). Kami dapat menggunakannya dan tidak memberikan argumen pertama setiap saat karena sudah diperbaiki dengan

// more complex syntax will come a little later
let boundFunc = func.bind(context);

5

Dalam kasus lain, aplikasi parsial berguna ketika kita memiliki fungsi yang sangat umum dan menginginkan varian yang kurang universal untuk kenyamanan

Misalnya, kita memiliki fungsi ________60______6. Kemudian, di dalam objek

setTimeout(() => user.sayHi(), 1000); // Hello, John!

_2 kita mungkin ingin menggunakan sebagian variannya.

let user = {
  firstName: "John"
};

function func(phrase) {
  alert(phrase + ', ' + this.firstName);
}

// bind this to user
let funcUser = func.bind(user);

funcUser("Hello"); // Hello, John (argument "Hello" is passed, and this=user)

_8 yang dikirim dari pengguna saat ini

Bagaimana jika kita ingin memperbaiki beberapa argumen, tetapi bukan konteksnya

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

7?

Asli

// more complex syntax will come a little later
let boundFunc = func.bind(context);

_5 tidak mengizinkan itu. Kita tidak bisa begitu saja menghilangkan konteksnya dan beralih ke argumen

Untungnya, fungsi

let user = {
  firstName: "John",
  sayHi() {
    alert(`Hello, ${this.firstName}!`);
  }
};

let sayHi = user.sayHi.bind(user); // (*)

// can run it without an object
sayHi(); // Hello, John!

setTimeout(sayHi, 1000); // Hello, John!

// even if the value of user changes within 1 second
// sayHi uses the pre-bound value which is reference to the old user object
user = {
  sayHi() { alert("Another user in setTimeout!"); }
};

_1 hanya untuk mengikat argumen dapat dengan mudah diimplementasikan

Seperti ini

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

5

Hasil dari

let user = {
  firstName: "John",
  sayHi() {
    alert(`Hello, ${this.firstName}!`);
  }
};

let sayHi = user.sayHi.bind(user); // (*)

// can run it without an object
sayHi(); // Hello, John!

setTimeout(sayHi, 1000); // Hello, John!

// even if the value of user changes within 1 second
// sayHi uses the pre-bound value which is reference to the old user object
user = {
  sayHi() { alert("Another user in setTimeout!"); }
};

2 panggilan adalah pembungkus

let user = {
  firstName: "John",
  sayHi() {
    alert(`Hello, ${this.firstName}!`);
  }
};

setTimeout(() => user.sayHi(), 1000);

// ...the value of user changes within 1 second
user = {
  sayHi() { alert("Another user in setTimeout!"); }
};

// Another user in setTimeout!

9 yang memanggil

setTimeout(() => user.sayHi(), 1000); // Hello, John!

7 dengan

Sama

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

_7 seperti yang didapat (untuk

let user = {
  firstName: "John",
  sayHi() {
    alert(`Hello, ${this.firstName}!`);
  }
};

let sayHi = user.sayHi.bind(user); // (*)

// can run it without an object
sayHi(); // Hello, John!

setTimeout(sayHi, 1000); // Hello, John!

// even if the value of user changes within 1 second
// sayHi uses the pre-bound value which is reference to the old user object
user = {
  sayHi() { alert("Another user in setTimeout!"); }
};

6 panggilan itu

setTimeout(() => user.sayHi(), 1000); // Hello, John!

2)

Kemudian berikan

let user = {
  firstName: "John",
  sayHi() {
    alert(`Hello, ${this.firstName}!`);
  }
};

let sayHi = user.sayHi.bind(user); // (*)

// can run it without an object
sayHi(); // Hello, John!

setTimeout(sayHi, 1000); // Hello, John!

// even if the value of user changes within 1 second
// sayHi uses the pre-bound value which is reference to the old user object
user = {
  sayHi() { alert("Another user in setTimeout!"); }
};

_8 – argumen dari panggilan

let user = {
  firstName: "John",
  sayHi() {
    alert(`Hello, ${this.firstName}!`);
  }
};

let sayHi = user.sayHi.bind(user); // (*)

// can run it without an object
sayHi(); // Hello, John!

setTimeout(sayHi, 1000); // Hello, John!

// even if the value of user changes within 1 second
// sayHi uses the pre-bound value which is reference to the old user object
user = {
  sayHi() { alert("Another user in setTimeout!"); }
};

1 (

let user = {
  firstName: "John",
  say(phrase) {
    alert(`${phrase}, ${this.firstName}!`);
  }
};

let say = user.say.bind(user);

say("Hello"); // Hello, John! ("Hello" argument is passed to say)
say("Bye"); // Bye, John! ("Bye" is passed to say)

0)

Kemudian berikan

let user = {
  firstName: "John",
  say(phrase) {
    alert(`${phrase}, ${this.firstName}!`);
  }
};

let say = user.say.bind(user);

say("Hello"); // Hello, John! ("Hello" argument is passed to say)
say("Bye"); // Bye, John! ("Bye" is passed to say)

_1 – argumen yang diberikan pada pembungkus (

let user = {
  firstName: "John",
  say(phrase) {
    alert(`${phrase}, ${this.firstName}!`);
  }
};

let say = user.say.bind(user);

say("Hello"); // Hello, John! ("Hello" argument is passed to say)
say("Bye"); // Bye, John! ("Bye" is passed to say)

2)

Sangat mudah melakukannya dengan sintaks spread, bukan?

Juga ada implementasi siap pakai dari perpustakaan lodash

Metode

let user = {
  firstName: "John",
  say(phrase) {
    alert(`${phrase}, ${this.firstName}!`);
  }
};

let say = user.say.bind(user);

say("Hello"); // Hello, John! ("Hello" argument is passed to say)
say("Bye"); // Bye, John! ("Bye" is passed to say)

_3 mengembalikan "varian terikat" dari fungsi

setTimeout(() => user.sayHi(), 1000); // Hello, John!

7 yang memperbaiki konteks

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

7 dan argumen pertama jika diberikan

Biasanya kami menerapkan

// more complex syntax will come a little later
let boundFunc = func.bind(context);

_5 untuk memperbaiki

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

7 untuk metode objek, sehingga kami dapat meneruskannya ke suatu tempat. Misalnya, ke

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

6

Saat kami memperbaiki beberapa argumen dari fungsi yang ada, fungsi yang dihasilkan (kurang universal) disebut diterapkan sebagian atau sebagian

Partial nyaman ketika kita tidak ingin mengulangi argumen yang sama berulang kali. Seperti jika kita memiliki fungsi

let user = {
  firstName: "John",
  say(phrase) {
    alert(`${phrase}, ${this.firstName}!`);
  }
};

let say = user.say.bind(user);

say("Hello"); // Hello, John! ("Hello" argument is passed to say)
say("Bye"); // Bye, John! ("Bye" is passed to say)

_9, dan

let f = user.sayHi;
setTimeout(f, 1000); // lost user context

00 harus selalu sama untuk tugas kita, kita bisa mendapatkan sebagian dan melanjutkannya

Kapan menggunakan bind dalam JavaScript?

Kami menggunakan metode Bind() untuk memanggil fungsi dengan nilai this , kata kunci ini mengacu pada objek yang sama yang saat ini dipilih. Dengan kata lain, metode bind() memungkinkan kita untuk dengan mudah mengatur objek mana yang akan diikat oleh kata kunci this ketika suatu fungsi atau metode dipanggil.

Bagaimana cara memanggil () menerapkan () dan mengikat () dalam JavaScript?

Gunakan. panggilan() atau. apply() saat Anda ingin segera menjalankan fungsi, dan mengubah konteksnya. Panggil/terapkan segera panggil fungsi, sedangkan bind mengembalikan fungsi yang, saat dieksekusi nanti, akan memiliki konteks yang benar untuk memanggil fungsi aslinya .

kode javascript