什么'；“的意思是什么=&燃气轮机&引用；（由等于和大于组成的箭头）在JavaScript中？

我知道

=

操作符表示大于或等于，但我在一些源代码中看到了

=>

。那个接线员是什么意思

代码如下：

promiseTargetFile（fpParams、aSkipPrompt、relatedURI）{
如果（！已接受）
返回；
saveAsType=fpParams.saveAsType；
file=fpParams.file；
连续体（）；
}).then（null，Components.utils.reportError）；

这将是ECMAScript 6中引入的“箭头函数表达式”

出于历史目的（如果以后wiki页面发生更改），它是：

与函数表达式相比，箭头函数表达式的语法更短，并且在词汇上绑定此值。箭头函数总是匿名的

是什么 这是一个arrow函数。arrow函数是ECMAscript 6引入的一种简短语法，其使用方式与函数表达式的使用方式类似。换句话说，您可以经常使用它们来代替表达式，如

function（foo）{…}

。但它们有一些重要的区别。例如，它们不绑定自己的

值this

（有关讨论，请参见下文）

箭头函数是ECMAscript 6规范的一部分。它们尚未在所有浏览器中得到支持，但在2018年开始使用的大多数现代浏览器中部分或完全得到支持。（我在下面列出了部分支持浏览器的列表）

从Mozilla文档中：

arrow函数表达式（也称为fat arrow函数）的语法较短，并在词汇上绑定值（不绑定其自身的、或）。箭头函数总是匿名的。这些函数表达式最适合于非方法函数，它们不能用作构造函数

有关此如何在箭头函数中工作的说明 箭头函数最方便的功能之一隐藏在上面的文本中：

一个箭头函数。。。按词汇绑定

此

值（不绑定自己的

此

…）

更简单地说，这意味着箭头函数从上下文中保留

this

值，而没有自己的

this

。传统函数可能会绑定自己的

此
值，具体取决于它的定义和调用方式。这需要很多体操，比如
self=This
等，从一个函数中的另一个函数中访问或操作此
。有关此主题的更多信息，请参阅

示例代码
示例（也来自文档）：


关于兼容性的说明
您可以在节点中使用箭头函数，但浏览器支持参差不齐

浏览器对该功能的支持已经有了很大的改进，但对于大多数基于浏览器的使用来说，它仍然不够广泛。截至2017年12月12日，当前版本的支持：


铬（v.45+）
Firefox（第22+节）
边缘（12+节）
歌剧（32+节）
安卓浏览器（47+节）
Opera Mobile（33+节）
Android版Chrome（第47节+）
Android版Firefox（44+版）
狩猎（10+节）
iOS Safari（版本10.2+）
三星互联网（v.5+）
百度浏览器（7.12+版）

在以下情况下不受支持：


IE（通过第11节）
迷你歌剧院（8.0版）
黑莓浏览器（第10节）
IE Mobile（通过第11节）
适用于Android的UC浏览器（通过第11.4节）
QQ（通过1.2版）

您可以在（无附属机构）上找到更多（和最新）信息。
我已经阅读过，这是
ES6中
箭头功能的符号

这个

使用
箭头功能
可以写为

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

这就是众所周知的箭头函数，它是


var foo=['a'，'ab'，'abc']；
var bar=foo.map（f=>f.length）；
console.log（条）；//1,2,3
仅添加另一个示例，说明lambda在不使用map的情况下可以做什么：

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

正如所有其他答案所说，它是ES2015 arrow函数语法的一部分。更具体地说，它不是运算符，而是分隔参数与正文的标点符号或标记：
ArrowFunction:ArrowParameters=>ConciseBody
。例如，
（params）=>{/*body*/}
正如其他人所说，这是一种创建函数的新语法

但是，此类功能与正常功能不同：


它们将<代码>绑定到此
值。正如他所解释的

arrow函数不为
参数定义本地绑定
，
super
，
此
或
新建。目标
。对
参数的任何引用
，
super
、
this
或
new。箭头函数中的目标必须
解析为词汇封闭环境中的绑定。典型的
这将是一个立即封闭的函数环境
功能

即使箭头函数可能包含对
super
的引用
在步骤4中创建的函数对象不是由
表演。引用
super
始终包含在非箭头函数和必要的
要实施的状态
super
可通过以下范围访问：
由Arrow函数的函数对象捕获


他们是非构造函数

这意味着它们没有[[Construct]]内部方法，因此无法实例化，例如

var f=a=>a；
f（123）；//123
新的f（）；//TypeError:f不是构造函数

这些是箭头功能
也称为胖箭头功能。它们是编写函数表达式的一种干净而简洁的方法，例如
function（）{}

箭头函数可以是r
var a3 = a.map( s => s.length );

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

 //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)); 

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

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();

const foo = a => a * 2;

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

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

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

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

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

// or

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

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}

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
    }); 
  }
}

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); 
    });
  }
}

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

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

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


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