ความหมายของ“ =>” (ลูกศรที่สร้างขึ้นจากค่าเท่ากับ & มากกว่า) ใน JavaScript คืออะไร


444

ฉันรู้ว่า>=โอเปอเรเตอร์มีความหมายมากกว่าหรือเท่ากับ แต่ฉันเห็น=>ในซอร์สโค้ดบางตัว ความหมายของผู้ประกอบการนั้นคืออะไร?

นี่คือรหัส:

promiseTargetFile(fpParams, aSkipPrompt, relatedURI).then(aDialogAccepted => {
    if (!aDialogAccepted)
        return;

    saveAsType = fpParams.saveAsType;
    file = fpParams.file;

    continueSave();
}).then(null, Components.utils.reportError);

5
ดูที่ลิงค์นี้เกี่ยวกับฟังก์ชั่นลูกศร
Mistalis

คำตอบ:


547

มันคืออะไร

นี่คือฟังก์ชั่นลูกศร ฟังก์ชั่นลูกศรเป็นไวยากรณ์สั้น ๆ ที่นำมาใช้โดย ECMAscript 6 ที่สามารถนำมาใช้ในลักษณะเดียวกับวิธีที่คุณใช้ฟังก์ชั่นการแสดงออก ในคำอื่น ๆ function (foo) {...}คุณมักจะสามารถใช้พวกเขาในสถานที่ของการแสดงออกเช่น แต่พวกเขามีความแตกต่างที่สำคัญ ตัวอย่างเช่นพวกเขาไม่ผูกค่าของตนเองthis(ดูด้านล่างสำหรับการสนทนา)

ฟังก์ชั่นลูกศรเป็นส่วนหนึ่งของข้อกำหนด ECMAscript 6 พวกเขายังไม่ได้รับการสนับสนุนในเบราว์เซอร์ทั้งหมด แต่ได้รับการสนับสนุนบางส่วนหรือทั้งหมดใน Node v. 4.0+และเบราว์เซอร์ที่ทันสมัยที่สุดที่ใช้งานตั้งแต่ปี 2018 (ฉันได้รวมรายการเบราว์เซอร์ที่สนับสนุนบางส่วนไว้ด้านล่าง)

คุณสามารถอ่านเพิ่มเติมในเอกสาร Mozillaในหน้าที่ลูกศร

จากเอกสาร Mozilla:

ฟังก์ชั่นการแสดงออกศร (หรือเรียกว่าฟังก์ชั่นลูกศรไขมัน) มีไวยากรณ์สั้นเมื่อเทียบกับสำนวนที่ฟังก์ชั่นและ lexically ผูกthisค่า (ไม่ได้ผูกของตัวเองthis, arguments, superหรือnew.target) ฟังก์ชั่นลูกศรไม่ระบุชื่อเสมอ การแสดงออกของฟังก์ชั่นเหล่านี้เหมาะที่สุดสำหรับฟังก์ชั่นที่ไม่ใช่วิธีการและไม่สามารถใช้เป็นตัวสร้างได้

หมายเหตุเกี่ยวกับวิธีการthisทำงานในฟังก์ชั่นลูกศร

หนึ่งในคุณสมบัติที่มีประโยชน์ที่สุดของฟังก์ชั่นลูกศรฝังอยู่ในข้อความด้านบน:

ฟังก์ชั่นลูกศร ... ผูกthisค่าตามศัพท์(ไม่ผูกตัวเองthis... )

สิ่งนี้หมายความว่าในแง่ที่ง่ายก็คือฟังก์ชั่นที่ลูกศรที่ยังคงมีค่าจากบริบทและไม่ได้มีเป็นของตัวเองthis thisฟังก์ชั่นแบบดั้งเดิมอาจผูกthisค่าของตัวเองขึ้นอยู่กับวิธีการกำหนดและเรียก สิ่งนี้อาจต้องใช้ยิมนาสติกจำนวนมากเช่นself = this;อื่น ๆ เพื่อเข้าถึงหรือจัดการthisจากฟังก์ชั่นหนึ่งภายในฟังก์ชั่นอื่น สำหรับข้อมูลเพิ่มเติมเกี่ยวกับหัวข้อนี้ดูคำอธิบายและตัวอย่างในเอกสาร Mozilla

รหัสตัวอย่าง

ตัวอย่าง (เช่นจากเอกสาร):

var a = [
  "We're up all night 'til the sun",
  "We're up all night to get some",
  "We're up all night for good fun",
  "We're up all night to get lucky"
];

// These two assignments are equivalent:

// Old-school:
var a2 = a.map(function(s){ return s.length });

// ECMAscript 6 using arrow functions
var a3 = a.map( s => s.length );

// both a2 and a3 will be equal to [31, 30, 31, 31]

หมายเหตุเกี่ยวกับความเข้ากันได้

คุณสามารถใช้ฟังก์ชั่นลูกศรในโหนด แต่การสนับสนุนเบราว์เซอร์นั้นขาด ๆ หาย ๆ

การรองรับเบราว์เซอร์สำหรับฟังก์ชั่นนี้ได้รับการปรับปรุงเล็กน้อย แต่ก็ยังไม่แพร่หลายพอสำหรับการใช้งานบนเบราว์เซอร์ส่วนใหญ่ ข้อมูล ณ วันที่ 12 ธันวาคม 2560 ได้รับการสนับสนุนในเวอร์ชันปัจจุบันของ:

  • Chrome (ข้อ 45+)
  • Firefox (เวอร์ชัน 22+)
  • Edge (ข้อ 12+)
  • โอเปร่า (ข้อ 32+)
  • เบราว์เซอร์ Android (v. 47+)
  • Opera Mobile (v. 33+)
  • Chrome สำหรับ Android (v. 47+)
  • Firefox สำหรับ Android (เวอร์ชัน 44+)
  • Safari (เวอร์ชัน 10+)
  • iOS Safari (เวอร์ชัน 10.2+)
  • Samsung Internet (v. 5+)
  • เบราว์เซอร์ Baidu (เวอร์ชัน 7.12+)

ไม่รองรับใน:

  • IE (ถึงเวอร์ชัน 11)
  • Opera Mini (ถึงเวอร์ชัน 8.0)
  • เบราว์เซอร์ Blackberry (ถึงเวอร์ชัน 10)
  • IE Mobile (ถึงเวอร์ชัน 11)
  • UC Browser สำหรับ Android (ถึงเวอร์ชัน 11.4)
  • QQ (ถึงเวอร์ชัน 1.2)

คุณสามารถค้นหาข้อมูลเพิ่มเติม (และเป็นปัจจุบัน) ได้ที่CanIUse.com (ไม่มีส่วนเกี่ยวข้อง)


3
TypeScript ดูเหมือนว่าจะสนับสนุน
mtyson

1
ดูเหมือนว่านี่เป็นการแสดงออกแลมบ์ดาใช่ไหม
Addem

1
ต้องการพูดถึงในแง่ของความเข้ากันได้เบราว์เซอร์ฉันใช้ฟังก์ชั่นลูกศร ES6 / ES7 และคุณสมบัติอื่น ๆ ที่ไม่เข้ากันได้กับ IE11 แต่ฉันใช้ Gulp หรือ Webpack พร้อมกับ Babel เพื่อ transpile ES6 เป็น ES5 เพื่อให้ทำงานได้ใน IE11 ดังนั้นหากคุณต้องการการสนับสนุน IE11 และคุณไม่ต้องสนใจที่จะตั้งค่า Babel ไปเลย
mbokil

76

หรือที่รู้จักกันในชื่อฟังก์ชั่น Arrow ส่วนหนึ่งของข้อมูลจำเพาะ ECMAScript 2015 ...

var foo = ['a', 'ab', 'abc'];

var bar = foo.map(f => f.length);

console.log(bar); // 1,2,3

ไวยากรณ์สั้นกว่าก่อนหน้านี้:

// < ES6:
var foo = ['a', 'ab', 'abc'];

var bar = foo.map(function(f) {
  return f.length;
});
console.log(bar); // 1,2,3

การสาธิต

สิ่งที่ยอดเยี่ยมอีกอย่างคือคำศัพท์ this ... โดยปกติคุณจะทำสิ่งที่ชอบ:

function Foo() {
  this.name = name;
  this.count = 0;
  this.startCounting();
}

Foo.prototype.startCounting = function() {
  var self = this;
  setInterval(function() {
    // this is the Window, not Foo {}, as you might expect
    console.log(this); // [object Window]
    // that's why we reassign this to self before setInterval()
    console.log(self.count);
    self.count++;
  }, 1000)
}

new Foo();

แต่นั่นสามารถเขียนใหม่ด้วยลูกศรดังนี้:

function Foo() {
  this.name = name;
  this.count = 0;
  this.startCounting();
}

Foo.prototype.startCounting = function() {
  setInterval(() => {
    console.log(this); // [object Object]
    console.log(this.count); // 1, 2, 3
    this.count++;
  }, 1000)
}

new Foo();

การสาธิต

MDN
เพิ่มเติมเกี่ยวกับไวยากรณ์

สำหรับข้อมูลเพิ่มเติมนี่คือคำตอบที่ดีงามสำหรับเมื่อจะใช้ลูกศรฟังก์ชั่น


มันเป็นการดีที่จะอัปเดตการสาธิตให้ใช้esfiddle.netเนื่องจากes6fiddle.netไม่สามารถใช้งานได้อีกต่อไป
Wavesailor

25

นี่จะเป็น "นิพจน์ฟังก์ชันลูกศร" ที่แนะนำใน ECMAScript 6

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/arrow_functions

เพื่อจุดประสงค์ในอดีต (หากหน้าวิกิมีการเปลี่ยนแปลงในภายหลัง) มันคือ:

การแสดงออกของฟังก์ชั่นลูกศรมีไวยากรณ์ที่สั้นกว่าเมื่อเทียบกับการแสดงออกของฟังก์ชั่นและผูกค่านี้ศัพท์ ฟังก์ชั่นลูกศรไม่ระบุชื่อเสมอ


1
ใจรวมถึงข้อมูลที่เพียงพอเพื่อให้ผู้อ่านส่วนใหญ่ไม่ต้องเจาะลึก?
djechlin

2
วิกิที่ฉันเชื่อมโยงกับคำอธิบายสั้น ๆ คือ: "นิพจน์ฟังก์ชันลูกศรมีไวยากรณ์ที่สั้นกว่าเมื่อเทียบกับนิพจน์ฟังก์ชันและผูกค่านี้ด้วยคำศัพท์ฟังก์ชันลูกศรจะไม่ระบุตัวตนเสมอ"
Kyle Falconer

1
การเพิ่มสิ่งนั้นเป็นคำพูดที่นี่จะช่วยให้คำตอบของคุณ
Hanky ​​Panky

22

นี่คือฟังก์ชั่นลูกศร

หรือที่เรียกว่าฟังก์ชั่นไขมันลูกศร พวกเขากำลังเป็นวิธีที่สะอาดและ consise function() {}การเขียนฟังก์ชั่นการแสดงออกเช่น

ฟังก์ชั่นลูกศรสามารถเอาความต้องการของfunction, returnและ{}เมื่อกำหนดฟังก์ชั่น พวกเขาเป็นหนึ่งใน liners คล้ายกับ Lambda Expressions ใน Java หรือ Python

ตัวอย่างที่ไม่มีพารามิเตอร์

const queue = ['Dave', 'Sarah', 'Sharon'];
const nextCustomer = () => queue[0];

console.log(nextCustomer()); // 'Dave'

ถ้างบหลายจะต้องทำภายในลูกศรฟังก์ชั่นเดียวกันคุณต้องห่อในตัวอย่างนี้ในวงเล็บqueue[0] Curley {}ในกรณีนี้ไม่สามารถละเว้นข้อความส่งคืนสินค้าได้

ตัวอย่างที่มี 1 พารามิเตอร์

const queue = ['Dave', 'Sarah', 'Sharon'];
const addCustomer = name => {
  queue.push(name);
};

addCustomer('Toby');

console.log(queue); // ['Dave', 'Sarah', 'Sharon', 'Toby']

คุณสามารถละเว้น{}จากด้านบน

เมื่อมีพารามิเตอร์เดียววงเล็บเหลี่ยม()รอบพารามิเตอร์สามารถละเว้นได้

ตัวอย่างที่มีหลายพารามิเตอร์

const addNumbers = (x, y) => x + y

console.log(addNumbers(1, 5)); // 6

ตัวอย่างที่มีประโยชน์

const fruits = [
    {name: 'Apple', price: 2},
    {name: 'Bananna', price: 3},
    {name: 'Pear', price: 1}
];

ถ้าเราต้องการรับผลไม้ทุกอย่างในแถวเดียวใน ES5 เราทำได้:

fruits.map(function(fruit) {
    return fruit.price;
}); // [2, 3, 1]

ใน ES6 ที่มีฟังก์ชั่นลูกศรใหม่เราสามารถทำให้เรื่องนี้กระชับยิ่งขึ้น:

fruits.map(fruit => fruit.price); // [2, 3, 1]

ข้อมูลเพิ่มเติมเกี่ยวกับฟังก์ชั่นลูกศรสามารถพบได้ที่นี่

ความเข้ากันได้ของเบราว์เซอร์

  • IE: ยังไม่รองรับ
  • ขอบ: 12+ (ทุกรุ่น)
  • Firefox: 22+
  • Chrome: 45+
  • Safari: 10+
  • iOS Safari: 10.2+
  • เบราว์เซอร์ Android: 56+

สามารถดูข้อมูลล่าสุดเกี่ยวกับความเข้ากันได้ของเบราว์เซอร์ที่นี่


21

เพียงเพิ่มตัวอย่างของสิ่งที่แลมบ์ดาสามารถทำได้โดยไม่ต้องใช้แผนที่:

a = 10
b = 2

var mixed = (a,b) => a * b; 
// OR
var mixed = (a,b) => { (any logic); return a * b };

console.log(mixed(a,b)) 
// 20

13

อย่างที่คนอื่น ๆ พูดกันมันเป็นไวยากรณ์ใหม่ในการสร้างฟังก์ชั่น

อย่างไรก็ตามฟังก์ชั่นประเภทนี้แตกต่างจากฟังก์ชั่นปกติ:

  • พวกเขาผูกthisค่า อธิบายตามสเปค ,

    ArrowFunctionไม่ได้กำหนดผูกท้องถิ่นสำหรับarguments, super, หรือthis new.targetอ้างอิงใด ๆ ถึงarguments, super, thisหรือnew.targetภายในArrowFunctionต้องแก้ไขเพื่อผูกพันในสภาพแวดล้อมที่ lexically ล้อมรอบ โดยทั่วไปจะเป็นสภาพแวดล้อมของฟังก์ชั่นของฟังก์ชั่นการปิดล้อมทันที

    แม้แม้ว่าArrowFunctionอาจมีการอ้างอิงถึงsuperวัตถุฟังก์ชั่นที่สร้างขึ้นในขั้นตอนที่ 4 ไม่ได้ทำในวิธีการโดยการดำเนินการMakeMethod ArrowFunctionที่อ้างอิงsuper อยู่เสมอภายในไม่ใช่ArrowFunctionและรัฐจำเป็นต้องใช้superจะสามารถเข้าถึงได้ผ่านทางขอบเขตที่ถูกจับโดยวัตถุฟังก์ชั่นของArrowFunction

  • พวกเขาไม่ใช่ผู้ก่อสร้าง

    นั่นหมายความว่าพวกเขาไม่มี [ภายในสร้าง] วิธีการภายในและดังนั้นจึงไม่สามารถยกตัวอย่างเช่น

    var f = a => a;
    f(123);  // 123
    new f(); // TypeError: f is not a constructor

8

ฉันอ่านแล้วนี่คือสัญลักษณ์ของ Arrow FunctionsในES6

นี้

var a2 = a.map(function(s){ return s.length });

ใช้Arrow Functionสามารถเขียนเป็น

var a3 = a.map( s => s.length );

เอกสาร MDN


6

เพิ่มตัวอย่าง CRUD อย่างง่าย ๆ ด้วย Arrowfunction

 //Arrow Function
 var customers   = [
   {
     name: 'Dave',
     contact:'9192631770'
   },
   {
     name: 'Sarah',
     contact:'9192631770'
   },
   {
     name: 'Akhil',
     contact:'9928462656' 
   }],

// No Param READ
 getFirstCustomer = () => { 
   console.log(this);
   return customers[0];
 };
  console.log("First Customer "+JSON.stringify(getFirstCustomer())); // 'Dave' 

   //1 Param SEARCH
  getNthCustomer = index=>{
    if( index>customers.length)
    {
     return  "No such thing";
   }
   else{
       return customers[index];
     } 
  };
  console.log("Nth Customer is " +JSON.stringify(getNthCustomer(1))); 

   //2params ADD
  addCustomer = (name, contact)=> customers.push({
     'name': name,
     'contact':contact
    });
  addCustomer('Hitesh','8888813275');
  console.log("Added Customer "+JSON.stringify(customers)); 

  //2 param UPDATE
  updateCustomerName = (index, newName)=>{customers[index].name= newName};
  updateCustomerName(customers.length-1,"HiteshSahu");
  console.log("Updated Customer "+JSON.stringify(customers));

  //1 param DELETE
  removeCustomer = (customerToRemove) => customers.pop(customerToRemove);
  removeCustomer(getFirstCustomer());
  console.log("Removed Customer "+JSON.stringify(customers)); 

4

ไม่พอใจกับคำตอบอื่น ๆ คำตอบที่ได้รับการโหวตสูงสุดเมื่อวันที่ 2019/3/13 นั้นผิดจริง ๆ

รุ่นย่อสั้น ๆ ของความ=>หมายว่ามันเป็นทางลัดเขียนฟังก์ชั่นและสำหรับการผูกไว้กับปัจจุบันthis

const foo = a => a * 2;

เป็นทางลัดที่มีประสิทธิภาพสำหรับ

const foo = function(a) { return a * 2; }.bind(this);

คุณสามารถเห็นทุกสิ่งที่ถูกทำให้สั้นลง เราไม่ต้องการfunctionหรือreturnไม่.bind(this)หรือแม้กระทั่งการจัดฟันหรือวงเล็บ

ตัวอย่างของฟังก์ชันลูกศรอีกเล็กน้อยอาจจะเป็น

const foo = (width, height) => {
  const area = width * height;
  return area;
};

แสดงว่าถ้าเราต้องการอาร์กิวเมนต์หลายฟังก์ชันเราต้องวงเล็บและถ้าเราต้องการเขียนมากกว่าการแสดงออกเดียวที่เราต้องการวงเล็บปีกกาและชัดเจน returnแสดงให้เห็นว่าถ้าเราต้องการข้อโต้แย้งหลายฟังก์ชั่นที่เราต้องการวงเล็บและถ้าเราต้องการเขียนมากกว่าการแสดงออกที่เดียวที่เราต้องจัดฟันและชัดเจน

สิ่งสำคัญคือการเข้าใจ.bindส่วนนั้นและเป็นหัวข้อใหญ่ มันเกี่ยวข้องกับความthisหมายของ JavaScript

ทุกthisฟังก์ชั่นมีพารามิเตอร์นัยที่เรียกว่า อย่างไรthisตั้งค่าเมื่อเรียกใช้ฟังก์ชันจะขึ้นอยู่กับวิธีเรียกใช้ฟังก์ชันนั้น

เอา

function foo() { console.log(this); }

ถ้าคุณเรียกมันว่าปกติ

function foo() { console.log(this); }
foo();

this จะเป็นวัตถุทั่วโลก

หากคุณอยู่ในโหมดเข้มงวด

`use strict`;
function foo() { console.log(this); }
foo();

// or

function foo() {
   `use strict`;
   console.log(this);
 }
foo();

มันจะเป็น undefined

คุณสามารถตั้งค่าthisได้โดยตรงโดยใช้callหรือapply

function foo(msg) { console.log(msg, this); }

const obj1 = {abc: 123}
const obj2 = {def: 456}

foo.call(obj1, 'hello');  // prints Hello {abc: 123}
foo.apply(obj2, ['hi']);  // prints Hi {def: 456}

คุณยังสามารถตั้งค่าthisโดยนัยโดยใช้ตัวดำเนินการ dot.

function foo(msg) { console.log(msg, this); }
const obj = {
   abc: 123,
   bar: foo,
}
obj.bar('Hola');  // prints Hola {abc:123, bar: f}

ปัญหาเกิดขึ้นเมื่อคุณต้องการใช้ฟังก์ชั่นเป็นโทรกลับหรือฟัง คุณสร้างคลาสและต้องการกำหนดฟังก์ชั่นเป็นการเรียกกลับที่เข้าถึงอินสแตนซ์ของคลาส

class ShowName {
  constructor(name, elem) {
    this.name = name;
    elem.addEventListener('click', function() {
       console.log(this.name);  // won't work
    }); 
  }
}

รหัสด้านบนจะไม่ทำงานเพราะเมื่อองค์ประกอบเริ่มเหตุการณ์และเรียกใช้ฟังก์ชันthisค่าจะไม่เป็นตัวอย่างของคลาส

วิธีการทั่วไปหนึ่งในการแก้ไขปัญหานั้นคือการใช้ .bind

class ShowName {
  constructor(name, elem) {
    this.name = name;
    elem.addEventListener('click', function() {
       console.log(this.name); 
    }.bind(this); // <=========== ADDED! ===========
  }
}

เพราะไวยากรณ์ลูกศรทำสิ่งเดียวกันกับที่เราเขียน

class ShowName {
  constructor(name, elem) {
    this.name = name;
    elem.addEventListener('click',() => {
       console.log(this.name); 
    });
  }
}

bindได้อย่างมีประสิทธิภาพทำให้ฟังก์ชั่นใหม่ หากbindไม่มีอยู่คุณสามารถสร้างของคุณเองได้ตามปกติ

function bind(funcitonToBind, valueToUseForThis) {
  return function(...args) {
    functionToBind.call(valueToUseForThis, ...args);
  };
}

ใน JavaScript รุ่นเก่าที่ไม่มีตัวดำเนินการสเปรด

function bind(funcitonToBind, valueToUseForThis) {
  return function() {
    functionToBind.apply(valueToUseForThis, arguments);
  };
}

การเข้าใจรหัสนั้นต้องมีความเข้าใจในการปิดแต่รุ่นสั้น ๆ นั้นจะbindทำให้เกิดฟังก์ชั่นใหม่ที่จะเรียกฟังก์ชั่นดั้งเดิมด้วยthisค่าที่ถูกผูกไว้กับมัน ฟังก์ชั่นลูกศรทำสิ่งเดียวกันเพราะเป็นทางลัดbind(this)


2

ตามที่ทุกคำตอบอื่น ๆ ได้กล่าวไปแล้วมันเป็นส่วนหนึ่งของไวยากรณ์ลูกศรฟังก์ชัน ES2015 โดยเฉพาะอย่างยิ่งก็ไม่ได้ดำเนินการก็เป็น punctuator ArrowFunction : ArrowParameters => ConciseBodyโทเค็นที่แยกพารามิเตอร์จากร่างกาย: (params) => { /* body */ }เช่น


1

ES6 ฟังก์ชั่นลูกศร:

ในจาวาสคริปต์=>สัญลักษณ์ของการแสดงออกของฟังก์ชั่นลูกศรคือ การแสดงออกของฟังก์ชั่นลูกศรไม่มีthisผลผูกพันของตนเองและดังนั้นจึงไม่สามารถใช้เป็นฟังก์ชันตัวสร้าง ตัวอย่างเช่น:

var words = 'hi from outside object';

let obj = {
  words: 'hi from inside object',
  talk1: () => {console.log(this.words)},
  talk2: function () {console.log(this.words)}
}

obj.talk1();  // doesn't have its own this binding, this === window
obj.talk2();  // does have its own this binding, this is obj

กฎการใช้ฟังก์ชั่นลูกศร:

  • หากมีหนึ่งอาร์กิวเมนต์ที่แน่นอนคุณสามารถละเว้นวงเล็บของอาร์กิวเมนต์
  • หากคุณส่งคืนนิพจน์และทำสิ่งนี้ในบรรทัดเดียวกันคุณสามารถละเว้น{}และreturnคำสั่งนั้นได้

ตัวอย่างเช่น:

let times2 = val => val * 2;  
// It is on the same line and returns an expression therefore the {} are ommited and the expression returns implictly
// there also is only one argument, therefore the parentheses around the argument are omitted

console.log(times2(3));


1

ฟังก์ชั่นลูกศรซึ่งแสดงด้วยสัญลักษณ์ (=>) ช่วยให้คุณสร้างฟังก์ชั่นและวิธีการที่ไม่ระบุชื่อ ซึ่งนำไปสู่ไวยากรณ์ที่สั้นกว่า ตัวอย่างเช่นด้านล่างเป็นฟังก์ชัน“ เพิ่ม” อย่างง่ายซึ่งส่งคืนการเพิ่มของตัวเลขสองตัว

function Add(num1 , num2 ){
return num1 + num2;
}

ฟังก์ชั่นด้านบนจะสั้นลงโดยใช้ไวยากรณ์“ ลูกศร” ดังที่แสดงด้านล่าง

ป้อนคำอธิบายรูปภาพที่นี่

โค้ดด้านบนมีสองส่วนดังแสดงในแผนภาพด้านบน: -

อินพุต: - ส่วนนี้ระบุพารามิเตอร์อินพุตให้กับฟังก์ชันที่ไม่ระบุชื่อ

ลอจิก: - ส่วนนี้อยู่หลังสัญลักษณ์“ =>” ส่วนนี้มีตรรกะของฟังก์ชันจริง

นักพัฒนาหลายคนคิดว่าฟังก์ชั่นลูกศรทำให้ไวยากรณ์ของคุณสั้นลงง่ายขึ้นและทำให้โค้ดของคุณอ่านง่ายขึ้น

หากคุณเชื่อประโยคข้างต้นให้ฉันรับรองคุณว่ามันเป็นตำนาน หากคุณคิดว่าสักครู่ฟังก์ชั่นที่เขียนอย่างถูกต้องและมีชื่อนั้นสามารถอ่านได้มากกว่าฟังก์ชั่นลับที่สร้างขึ้นในหนึ่งบรรทัดโดยใช้สัญลักษณ์ลูกศร

การใช้ฟังก์ชั่นลูกศรหลักเพื่อให้แน่ใจว่ารหัสทำงานในบริบทผู้โทร

ดูรหัสด้านล่างซึ่งมีตัวแปรทั่วโลก "บริบท" ที่กำหนดไว้ตัวแปรทั่วโลกนี้มีการเข้าถึงภายในฟังก์ชั่น "SomeOtherMethod" ซึ่งเรียกว่าจากวิธีอื่น "SomeMethod"

"SomeMethod" นี้มีตัวแปร "บริบท" ในตัวเครื่อง ขณะนี้เนื่องจาก "SomeOtherMethod" ถูกเรียกจาก "" SomeMethod "เราคาดหวังให้แสดง" บริบทท้องถิ่น "แต่จะแสดง" บริบททั่วโลก "

var context = global context”;

function SomeOtherMethod(){
alert(this.context);
}

function SomeMethod(){
this.context = local context”;
SomeOtherMethod();
}

var instance = new SomeMethod();

แต่ถ้าแทนที่การโทรโดยใช้ฟังก์ชั่นลูกศรมันจะแสดง "บริบทท้องถิ่น"

var context = "global context";

    function SomeMethod(){
        this.context = "local context";
        SomeOtherMethod = () => {
            alert(this.context);
        }
        SomeOtherMethod();
    }
    var instance = new SomeMethod();

ฉันอยากจะแนะนำให้คุณอ่านลิงค์นี้ ( ฟังก์ชั่นลูกศรใน JavaScript ) ซึ่งอธิบายสถานการณ์ทั้งหมดของบริบท javascript และสถานการณ์ที่บริบทของผู้โทรไม่ได้รับการเคารพ

นอกจากนี้คุณยังสามารถดูการสาธิตฟังก์ชั่น Arrow ด้วย javascript ในวิดีโอ youtube นี้ซึ่งแสดงให้เห็นถึงคำศัพท์บริบท


0

ขณะที่คนอื่น ๆ ได้กล่าวว่าปกติ (ดั้งเดิม) ฟังก์ชั่นการใช้งานthisจากวัตถุที่เรียกว่าฟังก์ชั่น(ปุ่มเช่นที่ถูกคลิก) ใช้ฟังก์ชั่นลูกศรแทนthisจากวัตถุที่กำหนดฟังก์ชั่นแทน

พิจารณาฟังก์ชั่นที่เหมือนกันเกือบสองอย่าง:

regular = function() {
  ' Identical Part Here;
}


arrow = () => {
  ' Identical Part Here;
}

ตัวอย่างด้านล่างแสดงให้เห็นถึงความแตกต่างพื้นฐานระหว่างสิ่งที่thisแสดงถึงสำหรับแต่ละฟังก์ชั่น ฟังก์ชั่นปกติเอาท์พุท[object HTMLButtonElement]ในขณะที่ฟังก์ชั่นลูกศร[object Window]เอาท์พุท

<html>
 <button id="btn1">Regular: `this` comes from "this button"</button>
 <br><br>
 <button id="btn2">Arrow: `this` comes from object that defines the function</button>
 <p id="res"/>

 <script>
  regular = function() {
    document.getElementById("res").innerHTML = this;
  }

  arrow = () => {
    document.getElementById("res").innerHTML = this;
  }

  document.getElementById("btn1").addEventListener("click", regular);
  document.getElementById("btn2").addEventListener("click", arrow);
 </script>
</html>

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.