जावास्क्रिप्ट 'बाइंड' पद्धति का उपयोग क्या है?


650

bind()जावास्क्रिप्ट में क्या उपयोग है ?


8
मेरा मानक उपयोग मामला:select = document.querySelector.bind(document)
छत

1
^ और किसी को भी आश्चर्य हो रहा है, इसके लिए जिस कारण की आवश्यकता है thisवह है, अन्यथा window, वैश्विक वस्तु। साथ document.querySelector.bind(document)में, हम यह सुनिश्चित करें कि selectके thisलिए संदर्भित करता है के लिए document, और नहीं करने के लिए window। किसी ने मुझे सही किया अगर मैंने गलत समझा, हालांकि।
AleksandrH

जवाबों:


612

बाइंड एक नया फंक्शन बनाता है जो फंक्शन के thisअंदर को पैरामीटर पास होने के लिए मजबूर करेगा bind()

यहां एक उदाहरण दिया गया है, जिसमें दिखाया bindगया है कि सही तरीके से पास सदस्य विधि पास करने के लिए कैसे उपयोग किया जाए this:

var myButton = {
  content: 'OK',
  click() {
    console.log(this.content + ' clicked');
  }
};

myButton.click();

var looseClick = myButton.click;
looseClick(); // not bound, 'this' is not myButton - it is the globalThis

var boundClick = myButton.click.bind(myButton);
boundClick(); // bound, 'this' is myButton

जो प्रिंट करता है:

OK clicked
undefined clicked
OK clicked

आप 1 ( this) पैरामीटर के बाद अतिरिक्त पैरामीटर भी जोड़ सकते हैं और bindउन मानों को मूल फ़ंक्शन में पास करेंगे। किसी भी अतिरिक्त पैरामीटर जो आप बाद में बाउंड फ़ंक्शन को पास करते हैं, उन्हें बाउंड मापदंडों के बाद पास किया जाएगा:

// Example showing binding some parameters
var sum = function(a, b) {
  return a + b;
};

var add5 = sum.bind(null, 5);
console.log(add5(10));

जो प्रिंट करता है:

15

की जाँच करें जावास्क्रिप्ट समारोह बाँध अधिक जानकारी और इंटरैक्टिव उदाहरण के लिए।

अद्यतन: ECMAScript 2015 =>कार्यों के लिए समर्थन जोड़ता है । =>फ़ंक्शन अधिक कॉम्पैक्ट हैं और thisपॉइंटर को उनके परिभाषित दायरे से नहीं बदलते हैं , इसलिए आपको bind()अक्सर उपयोग करने की आवश्यकता नहीं हो सकती है । उदाहरण के लिए, यदि आप किसी कॉलबैक को DOM ईवेंट के Buttonलिए हुक करने के लिए पहले उदाहरण से एक फ़ंक्शन चाहते थे click, तो निम्न सभी करने के वैध तरीके हैं:

var myButton = {
  ... // As above
  hookEvent(element) {
    // Use bind() to ensure 'this' is the 'this' inside click()
    element.addEventListener('click', this.click.bind(this));
  }
};

या:

var myButton = {
  ... // As above
  hookEvent(element) {
    // Use a new variable for 'this' since 'this' inside the function
    // will not be the 'this' inside hookEvent()
    var me = this;
    element.addEventListener('click', function() { me.click() });
  }
};    

या:

var myButton = {
  ... // As above
  hookEvent(element) {
    // => functions do not change 'this', so you can use it directly
    element.addEventListener('click', () => this.click());
  }
};

6
उत्कृष्ट अन्वेषण, लेकिन मैं उन उदाहरणों को खोजने के लिए संघर्ष कर रहा हूं जहां मैं पहले विकल्प के बजाय आपके द्वारा वर्णित तीसरे विकल्प का उपयोग करना चाहता हूं। क्या आप उन स्थितियों का वर्णन कर सकते हैं जहां आपको तीसरे विकल्प का उपयोग करने की आवश्यकता महसूस हुई?
डैरिल

5
मुझे नहीं लगता कि मैंने कभी भी 'इस' को बाइंड करने के अलावा किसी अन्य प्रकार का उपयोग किया है। अन्य रूप को आंशिक अनुप्रयोग के रूप में जाना जाता है और कार्यात्मक भाषाओं में बहुत आम है। मुझे लगता है कि यह पूर्णता के लिए शामिल है।
नक्रोन

42
मामले में कोई भी सोच रहा है कि क्यों ढीला () myButton के लिए बाध्य नहीं है, ऐसा इसलिए है क्योंकि "यह" उस फ़ंक्शन को संदर्भित करता है जो फ़ंक्शन (looseClick ()) को आमंत्रित करता है। वह वस्तु जो ढीली क्लिक करती है () वैश्विक वस्तु है।
पोकेरो

4
@ डारिल - एक कारण यह है कि इवेंट हैंडलर से पैरामीटर पारित करना होगा। यदि आपके पास यह प्रतिक्रिया कोड है: var Note = React.createClass({ add: function(text){ ... }, render: function () { return <button onClick={this.add.bind(null, "New Note")}/> } }तो जब बटन पर क्लिक किया जाता है, तो यह addविधि के लिए एक पैरामीटर पाठ "नया नोट" पारित करेगा ।
पी। मायर नोर

2
"आप 1 पैरामीटर के बाद अतिरिक्त पैरामीटर भी जोड़ सकते हैं और बाइंड उन मानों को मूल फ़ंक्शन में पास कर देगा जो अतिरिक्त पैरामीटर आप बाध्य फ़ंक्शन को पास करने से पहले करते हैं:" यह शब्दांकन भ्रामक है।
केन इनग्राम

271

bind()एक फ़ंक्शन बनाने के लिए सबसे सरल उपयोग यह है कि, कोई फर्क नहीं पड़ता कि इसे कैसे कहा जाता है, एक विशेष thisमूल्य के साथ कहा जाता है ।

x = 9;
var module = {
    x: 81,
    getX: function () {
        return this.x;
    }
};

module.getX(); // 81

var getX = module.getX;
getX(); // 9, because in this case, "this" refers to the global object

// create a new function with 'this' bound to module
var boundGetX = getX.bind(module);
boundGetX(); // 81

अधिक जानकारी के लिए कृपया इस लिंक को देखें

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind


38
बाँध () के लिए सबसे अच्छा परिचय मैंने कभी देखा है।
thomasfl

3
महान जवाब, क्योंकि आपके उदाहरण के लिए भाषा की विशेषताओं (जैसे prototype) के बारे में ज्ञान की आवश्यकता नहीं है जो शुरुआती लोगों के लिए नया हो सकता है।
एडवर्ड

1
रसीला और बहुत स्पष्ट!
पापी

172

बाइंड की अनुमति देता है-

  • एक विशिष्ट वस्तु के लिए "यह" का मूल्य निर्धारित करें। यह बहुत उपयोगी हो जाता है के रूप में कभी कभी यह क्या करना है नहीं है।
  • पुन: उपयोग के तरीके
  • एक समारोह करी

उदाहरण के लिए, आपके पास मासिक क्लब शुल्क में कटौती करने का एक कार्य है

function getMonthlyFee(fee){
  var remaining = this.total - fee;
  this.total = remaining;
  return this.name +' remaining balance:'+remaining;
}

अब आप एक अलग क्लब के सदस्य के लिए इस फ़ंक्शन का पुनः उपयोग करना चाहते हैं। ध्यान दें कि मासिक शुल्क सदस्य से अलग-अलग होगा।

आइए कल्पना करें कि राहेल के पास 500 का संतुलन है, और मासिक सदस्यता शुल्क 90 है।

var rachel = {name:'Rachel Green', total:500};

अब, हर महीने उसके खाते से शुल्क में कटौती करने के लिए एक फ़ंक्शन का उपयोग करें

//bind
var getRachelFee = getMonthlyFee.bind(rachel, 90);
//deduct
getRachelFee();//Rachel Green remaining balance:410
getRachelFee();//Rachel Green remaining balance:320

अब, समान getMonthlyFee फ़ंक्शन का उपयोग किसी अन्य सदस्य के लिए अलग सदस्यता शुल्क के साथ किया जा सकता है। उदाहरण के लिए, रॉस गेलर के पास 250 शेष राशि और 25 का मासिक शुल्क है

var ross = {name:'Ross Geller', total:250};
//bind
var getRossFee = getMonthlyFee.bind(ross, 25);
//deduct
getRossFee(); //Ross Geller remaining balance:225
getRossFee(); //Ross Geller remaining balance:200

9
आपके उदाहरण में, मुझे लगता है कि मैं नए सदस्य के साथ तात्कालिक रूप से एक सदस्य ऑब्जेक्ट को सेटअप करने के लिए इच्छुक हूं, जहां प्रत्येक सदस्य की अपनी संपत्ति / विधियां थीं। तो फिर यह बस ross.getMonthlyFee (25) की बात है। क्या यह उदाहरण सिर्फ बाँध () के उपयोग को प्रदर्शित करने के लिए था, या आपके दृष्टिकोण से कुछ लाभ है?
डैरिल

एक समारोह एक करी प्यार!
जेरी लियू

मैं नहीं जानता, लेकिन मैं var getRachelFee = getMonthlyFee (राशेल, 90) करूँगा; और फ़ंक्शन फ़ंक्शन getMonthlyFee (सदस्य, शुल्क) {} लाइनों के साथ कुछ होगा।
मिगुएल

1
@KhanSharp आपका उत्तर सही है, लेकिन यह टीवी-सीरीज़ के लिए आपके संदर्भ हैं मित्र मुझे टिप्पणी और अपवित्र करते हैं। उत्तर देने के लिए धन्यवाद 🤗
सौरभ लेंड

79

से MDN डॉक्स पर Function.prototype.bind():

बाँध () विधि एक नया कार्य है कि, जब कहा जाता है, अपने इस कीवर्ड सेट प्रदान किया गया मान के लिए, है पूर्ववर्ती जब नया समारोह कहा जाता है किसी भी प्रदान किए गए तर्कों की दी गई अनुक्रम के साथ बनाता है।

तो उसका क्या मतलब हुआ?!

ठीक है, चलो एक फंक्शन लेते हैं जो इस तरह दिखता है:

var logProp = function(prop) {
    console.log(this[prop]);
};

अब, आइए एक वस्तु लें जो इस तरह दिखती है:

var Obj = {
    x : 5,
    y : 10
};

हम अपने कार्य को इस तरह अपनी वस्तु से बांध सकते हैं:

Obj.log = logProp.bind(Obj);

अब, हम Obj.logअपने कोड में कहीं भी भाग सकते हैं :

Obj.log('x'); // Output : 5
Obj.log('y'); // Output : 10

यह काम करता है, क्योंकि हम thisअपनी वस्तु के मूल्य को बाध्य करते हैं Obj


जहां यह वास्तव में दिलचस्प हो जाता है, जब आप न केवल इसके लिए एक मूल्य बांधते हैं this, बल्कि इसके तर्क के लिए भी prop:

Obj.logX = logProp.bind(Obj, 'x');
Obj.logY = logProp.bind(Obj, 'y');

अब हम यह कर सकते हैं:

Obj.logX(); // Output : 5
Obj.logY(); // Output : 10

इसके विपरीत Obj.log, हमें पास नहीं करना है xया y, क्योंकि हमने उन मूल्यों को पारित किया है जब हमने अपना बंधन किया था।


9
इस जवाब को और अधिक प्यार मिलना चाहिए। अच्छी तरह समझाया।
चाक्स

सामान्य अवलोकन और विशिष्ट उदाहरण का बहुत अच्छा संयोजन।
केन इंग्राम

बटन जहां सीधे 100 अप को गोली मारता है?
कुशाल्वम

इसके साथ मैं बाँध "नल" के उपयोग को समझने के लिए आंशिक रूप से लागू किए गए कार्यों के एमडीएन डॉक्स अनुभाग को पढ़ने की भी सिफारिश करूंगा । यह बाइंड उपयोग के अधिकांश के लिए फाटकों को बंद करना चाहिए। developer.mozilla.org/en/docs/Web/JavaScript/Reference/…
कुशाल्वम

23

चर में स्थानीय और वैश्विक स्कोप होते हैं। मान लें कि हमारे पास एक ही नाम के दो चर हैं। एक विश्व स्तर पर परिभाषित किया गया है और दूसरा एक फ़ंक्शन क्लोजर के अंदर परिभाषित किया गया है और हम वैरिएबल मान प्राप्त करना चाहते हैं जो फ़ंक्शन क्लोजर के अंदर है। उस स्थिति में हम इस बाइंड () विधि का उपयोग करते हैं। कृपया नीचे सरल उदाहरण देखें:

var x = 9; // this refers to global "window" object here in the browser
var person = {
  x: 81,
  getX: function() {
    return this.x;
  }
};

var y = person.getX; // It will return 9, because it will call global value of x(var x=9).

var x2 = y.bind(person); // It will return 81, because it will call local value of x, which is defined in the object called person(x=81).

document.getElementById("demo1").innerHTML = y();
document.getElementById("demo2").innerHTML = x2();
<p id="demo1">0</p>
<p id="demo2">0</p>


18

सारांश:

bind()विधि एक पहले तर्क के रूप में एक वस्तु लेता है और एक नया कार्य बनाता है। जब फ़ंक्शन को फ़ंक्शन में लाया जाता है, thisतो फ़ंक्शन बॉडी का मान ऑब्जेक्ट होगा जिसे bind()फ़ंक्शन में एक तर्क के रूप में पारित किया गया था ।

thisजेएस में वैसे भी कैसे काम करता है

thisजावास्क्रिप्ट का मान निर्भर है हमेशा इस बात पर निर्भर करता है कि फ़ंक्शन को क्या कहा जाता है। इस का मान हमेशा उस बिंदु से बाईं ओर स्थित वस्तु को संदर्भित करता है जहां से फ़ंक्शन कहा जाता है । वैश्विक विस्तार के मामले में यह है window(या globalमें nodeJS)। केवल call, applyऔर bindइस बंधन को अलग तरीके से बदल सकते हैं। यह दिखाने के लिए एक उदाहरण है कि यह कीवर्ड कैसे काम करता है:

let obj = {
  prop1: 1,
  func: function () { console.log(this); } 
}

obj.func();   // obj left of the dot so this refers to obj

const customFunc = obj.func;  // we store the function in the customFunc obj

customFunc();  // now the object left of the dot is window, 
               // customFunc() is shorthand for window.customFunc()
               // Therefore window will be logged

बाँध का उपयोग कैसे किया जाता है?

बिंद thisएक निश्चित ऑब्जेक्ट होने से कीवर्ड के साथ कठिनाइयों पर काबू पाने में मदद कर सकता thisहै। उदाहरण के लिए:

var name = 'globalName';

const obj = {
  name: 'myName',
  sayName: function () { console.log(this.name);}
}

const say = obj.sayName; // we are merely storing the function the value of this isn't magically transferred

say(); // now because this function is executed in global scope this will refer to the global var

const boundSay = obj.sayName.bind(obj); // now the value of this is bound to the obj object

boundSay();  // Now this will refer to the name in the obj object: 'myName'

एक बार जब फ़ंक्शन एक विशेष thisमूल्य के लिए बाध्य होता है, तो हम इसे पास कर सकते हैं और यहां तक ​​कि इसे अन्य वस्तुओं पर भी डाल सकते हैं। का मूल्य thisसमान रहेगा।


3
आपके कोड के बारे में आपकी टिप्पणी objऑब्जेक्ट है क्योंकि यह डॉट के लिए छोड़ दिया windowगया है और ऑब्जेक्ट है क्योंकि यह शॉर्टहैंड है window.custFunc()और windowडॉट के लिए छोड़ा गया है मेरे लिए बहुत ही व्यावहारिक था।
नजलेस्की

12

मैं सैद्धांतिक रूप से और साथ ही व्यावहारिक रूप से बांधने की व्याख्या करूंगा

जावास्क्रिप्ट में बाइंड एक विधि है - Function.prototyp.bind। बाँध एक विधि है। इसे फंक्शन प्रोटोटाइप कहा जाता है। यह विधि एक फ़ंक्शन बनाती है जिसका शरीर उस फ़ंक्शन के समान होता है जिस पर इसे कहा जाता है, लेकिन 'यह' बाइंड पद्धति में दिए गए पहले पैरामीटर को संदर्भित करता है। इसका वाक्य विन्यास है

     var bindedFunc = Func.bind(thisObj,optionsArg1,optionalArg2,optionalArg3,...);

उदाहरण:--

  var checkRange = function(value){
      if(typeof value !== "number"){
              return false;
      }
      else {
         return value >= this.minimum && value <= this.maximum;
      }
  }

  var range = {minimum:10,maximum:20};

  var boundedFunc = checkRange.bind(range); //bounded Function. this refers to range
  var result = boundedFunc(15); //passing value
  console.log(result) // will give true;

यह मूल रूप से फ़ंक्शन के अंदर जो भी 'आप' बनाता है वह जिस भी वस्तु में गुजरता है, सही है?
हार्वे लिन

11

बाइंड () विधि एक नया फ़ंक्शन इंस्टेंस बनाती है जिसका मान इस मान से बंधा होता है जिसे बाइंड () में पारित किया गया था। उदाहरण के लिए:

   window.color = "red"; 
   var o = { color: "blue" }; 
   function sayColor(){ 
       alert(this.color); 
   } 
   var objectSayColor = sayColor.bind(o); 
   objectSayColor(); //blue 

यहाँ, ऑब्जेक्टसेलर () को बाइंड () कॉल करके और ऑब्जेक्ट ओ में पास करके ऑब्जेक्टसॉयकलर () नामक एक नया फ़ंक्शन बनाया जाता है। ObjectSayColor () फ़ंक्शन का यह मान ओ के बराबर है, इसलिए फ़ंक्शन को कॉल करना, यहां तक ​​कि वैश्विक कॉल के रूप में, स्ट्रिंग "ब्लू" में परिणाम प्रदर्शित होता है।

संदर्भ: निकोलस सी। ज़कस - वेब डेवलपरों के लिए व्यावसायिक JAVASCRIPT®


संक्षिप्त और लेकोनिक उदाहरण
अहमद शरीफ

9

मानों को बाइंडिंग तर्क द्वारा एक नया फ़ंक्शन बनाना

यह bindविधि दूसरे फ़ंक्शन से एक नए फ़ंक्शन का निर्माण करती है, जिसमें एक या अधिक तर्क निहित होते हैं, जिसमें निहित मान शामिल होते हैं this

आंशिक आवेदन

यह आंशिक आवेदन का एक उदाहरण है । आम तौर पर हम इसके सभी तर्कों के साथ एक फ़ंक्शन प्रदान करते हैं जो एक मूल्य प्राप्त करता है। इसे फ़ंक्शन एप्लिकेशन के रूप में जाना जाता है। हम फ़ंक्शन को उसके तर्कों पर लागू कर रहे हैं।

एक उच्च आदेश समारोह (HOF)

आंशिक अनुप्रयोग उच्च आदेश फ़ंक्शन (HOF) का एक उदाहरण है क्योंकि यह कम संख्या में तर्क के साथ एक नया फ़ंक्शन देता है।

कई तर्क बाँध रहा है

आप bindकई तर्कों के साथ फ़ंक्शन को नए फ़ंक्शंस में बदलने के लिए उपयोग कर सकते हैं ।

function multiply(x, y) { 
    return x * y; 
}

let multiplyBy10 = multiply.bind(null, 10);
console.log(multiplyBy10(5));

इंस्टैंट मेथड से स्टेटिक फंक्शन में परिवर्तित करना

सबसे आम उपयोग के मामले में, जब एक तर्क के साथ बुलाया जाता है, तो bindविधि एक नया फ़ंक्शन बनाएगी जिसमें thisमूल्य एक विशिष्ट मूल्य के लिए बाध्य होता है। वास्तव में यह एक आवृत्ति विधि को एक स्थिर विधि में बदल देता है।

function Multiplier(factor) { 
    this.factor = factor;
}

Multiplier.prototype.multiply = function(x) { 
    return this.factor * x; 
}

function ApplyFunction(func, value) {
    return func(value);
}

var mul = new Multiplier(5);

// Produces garbage (NaN) because multiplying "undefined" by 10
console.log(ApplyFunction(mul.multiply, 10));

// Produces expected result: 50
console.log(ApplyFunction(mul.multiply.bind(mul), 10));

स्टेटफुल कॉलबैक को लागू करना

निम्नलिखित उदाहरण से पता चलता है कि कैसे बाइंडिंग का उपयोग करके thisऑब्जेक्ट विधि को कॉलबैक के रूप में कार्य करने में सक्षम किया जा सकता है जो किसी ऑब्जेक्ट की स्थिति को आसानी से अपडेट कर सकता है।

function ButtonPressedLogger()
{
   this.count = 0;
   this.onPressed = function() {
      this.count++;
      console.log("pressed a button " + this.count + " times");
   }
   for (let d of document.getElementsByTagName("button"))
      d.onclick = this.onPressed.bind(this);
}

new ButtonPressedLogger();      
<button>press me</button>
<button>no press me</button>


6

जैसा कि उल्लेख किया गया है, Function.bind()आपको उस संदर्भ को निर्दिष्ट करने देता है जो फ़ंक्शन में निष्पादित करेगा (अर्थात, यह आपको thisफ़ंक्शन के शरीर में कीवर्ड को किस ऑब्जेक्ट में हल करेगा , पास करने देता है ।

समरूप टूलकिट एपीआई तरीकों की एक जोड़ी जो एक समान सेवा करती है:

jQuery.proxy ()

Dojo.hitch ()


3
/**
 * Bind is a method inherited from Function.prototype same like call and apply
 * It basically helps to bind a function to an object's context during initialisation 
 * 
 * */

window.myname = "Jineesh";  
var foo = function(){ 
  return this.myname;
};

//IE < 8 has issues with this, supported in ecmascript 5
var obj = { 
    myname : "John", 
    fn:foo.bind(window)// binds to window object
}; 
console.log( obj.fn() ); // Returns Jineesh

3

नीचे सूचीबद्ध सरल कार्यक्रम पर विचार करें,

//we create object user
let User = { name: 'Justin' };

//a Hello Function is created to Alert the object User 
function Hello() {
  alert(this.name);
}

//since there the value of this is lost we need to bind user to use this keyword
let user = Hello.bind(User);
user();

//we create an instance to refer the this keyword (this.name);

2

बाइंड फंक्शन उसी फंक्शन बॉडी के साथ एक नया फंक्शन बनाता है जिस फंक्शन को वह बुला रहा है। इसे इस तर्क के साथ कहा जाता है। हम बाइंड फन का इस्तेमाल करते हैं। : जब हर बार एक नया उदाहरण बनाया जाता है और हमें पहले प्रारंभिक उदाहरण का उपयोग करना होता है तब हम बाइंड फन का उपयोग करते हैं। हम बाइंड फन को ओवरराइड नहीं कर सकते हैं। इसके अलावा यह क्लास के शुरुआती ऑब्जेक्ट को स्टोर करता है।

setInterval(this.animate_to.bind(this), 1000/this.difference);

0

एक अन्य उपयोग यह है कि आप किसी अन्य फ़ंक्शन के तर्क के रूप में बाइंड किए गए फ़ंक्शन को पास कर सकते हैं जो किसी अन्य निष्पादन संदर्भ के तहत चल रहा है।

var name = "sample";
function sample(){
  console.log(this.name);
}
var cb = sample.bind(this);

function somefunction(cb){
  //other code
  cb();
}
somefunction.call({}, cb);

0

सरल उदाहरण है

function lol(text) {
    console.log(this.name, text);
}

lol(); // undefined undefined
lol('first'); // undefined first
lol.call({name: 'karl'}); // karl undefined
lol.call({name: 'karl'}, 'second'); // karl second
lol.apply({name: 'meg'}); // meg undefined
lol.apply({name: 'meg'}, ['third']); // meg third
const newLol = lol.bind({name: 'bob'});
newLol(); // bob undefined
newLol('fourth'); // bob fourth

0

बाँध विधि

एक बाँध कार्यान्वयन कुछ इस तरह दिख सकता है:

Function.prototype.bind = function () {
  const self = this;
  const args = [...arguments];
  const context = args.shift();

  return function () {
    return self.apply(context, args.concat([...arguments]));
  };
};

बाइंड फ़ंक्शन किसी भी संख्या में तर्क ले सकता है और एक नया फ़ंक्शन वापस कर सकता है

नया फ़ंक्शन जेएस Function.prototype.applyविधि का उपयोग करके मूल फ़ंक्शन को कॉल करेगा । विधि उसके संदर्भ (के रूप में लक्ष्य कार्य करने के लिए पारित किया पहला तर्क का उपयोग करेगा ), और की दूसरी सरणी तर्क विधि लक्ष्य समारोह से तर्क के बाकी का एक संयोजन हो जाएगा, तर्क के साथ concat वापसी बुलाते थे फ़ंक्शन (उस क्रम में)। एक उदाहरण कुछ इस तरह दिख सकता है:
applythisapply

function Fruit(emoji) {
  this.emoji = emoji;
}

Fruit.prototype.show = function () {
  console.log(this.emoji);
};

const apple = new Fruit('🍎');
const orange = new Fruit('🍊');

apple.show();  // 🍎
orange.show(); // 🍊

const fruit1 = apple.show;
const fruit2 = apple.show.bind();
const fruit3 = apple.show.bind(apple);
const fruit4 = apple.show.bind(orange);

fruit1(); // undefined
fruit2(); // undefined
fruit3(); // 🍎
fruit4(); // 🍊


0

सरल स्पष्टीकरण:

बाइंड () एक नया फ़ंक्शन बनाते हैं, एक फ़ंक्शन पर एक नया संदर्भ यह आपके पास लौटता है।

इस कीवर्ड के बाद पैरामीटर में, आप उस पैरामीटर में पास होते हैं जिसे आप प्री-कॉन्फ़िगर करना चाहते हैं। वास्तव में यह तुरंत निष्पादित नहीं करता है, बस निष्पादन की तैयारी करता है।

आप जितने चाहें उतने पैरामीटर पूर्व-कॉन्फ़िगर कर सकते हैं।

बाँध समझने के लिए सरल उदाहरण:

function calculate(operation) {
  if (operation === 'ADD') {
   alert('The Operation is Addition');
  } else if (operation === 'SUBTRACT') {
   alert('The Operation is Subtraction');
  }
}

addBtn.addEventListener('click', calculate.bind(this, 'ADD'));
subtractBtn.addEventListener('click', calculate.bind(this, 'SUBTRACT'));

-1

बाइंड एक फ़ंक्शन है जो जावा स्क्रिप्ट प्रोटोटाइप में उपलब्ध है, जैसा कि नाम से पता चलता है कि बाइंड का उपयोग आपके फ़ंक्शन कॉल को संदर्भ के लिए करने के लिए किया जाता है, जो भी आप उदाहरण के लिए काम कर रहे हैं:

    var rateOfInterest='4%';
    var axisBank=
    {
    rateOfInterest:'10%',
    getRateOfInterest:function()
    {
    return this.rateOfInterest;
    }
    }
    axisBank.getRateOfInterest() //'10%' 


    let knowAxisBankInterest=axisBank.getRateOfInterest // when you want to assign the function call to a varaible we use this syntax
    knowAxisBankInterest(); // you will get output as '4%' here by default the function is called wrt global context

let knowExactAxisBankInterest=knowAxisBankInterest.bind(axisBank);     //so here we need bind function call  to its local context


    knowExactAxisBankInterest() // '10%' 

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.