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 16

回答:


546

それはなんですか

これはアロー関数です。アロー関数はECMAscript 6で導入された短い構文であり、関数式を使用するのと同じように使用できます。つまり、のような式の代わりに使用することができますfunction (foo) {...}。しかし、それらにはいくつかの重要な違いがあります。たとえば、それらは自身の値をバインドしませんthis(以下の説明を参照)。

矢印関数はECMAscript 6仕様の一部です。これらはまだすべてのブラウザーでサポートされているわけではありませんが、Node v。4.0+および2018年の時点で使用されているほとんどの最新ブラウザーで部分的または完全にサポートさています。

アロー関数の詳細については、Mozillaのドキュメントをご覧ください

Mozillaのドキュメントから:

(また、脂肪の矢印機能として知られている)、矢印関数式はに比べて短い構文を持つ関数式と辞書的に結合しthis(それ自身を結合しない値をthisargumentssuper、またはnew.target)。アロー関数は常に匿名です。これらの関数式はメソッド以外の関数に最適であり、コンストラクターとして使用できません。

thisアロー関数での動作に関するメモ

アロー関数の最も便利な機能の1つは、上のテキストに埋め込まれています。

矢印関数...字句的に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]

互換性に関する注意

Nodeで矢印機能を使用できますが、ブラウザのサポートは不安定です。

この機能に対するブラウザのサポートはかなり改善されていますが、ほとんどのブラウザベースの使用にはまだ十分に普及していません。2017年12月12日の時点で、次の最新バージョンでサポートされています。

  • Chrome(v。45以降)
  • Firefox(v。22以降)
  • エッジ(v。12+)
  • Opera(v。32+)
  • Androidブラウザー(v。47以降)
  • Opera Mobile(v。33+)
  • Chrome for Android(v。47以降)
  • Android版Firefox(v。44以降)
  • Safari(v。10以降)
  • iOS Safari(v。10.2+)
  • Samsung Internet(v。5+)
  • Baidu Browser(v。7.12+)

以下ではサポートされていません:

  • IE(v。11まで)
  • Opera Mini(v。8.0まで)
  • Blackberry Browser(v。10まで)
  • IE Mobile(v。11まで)
  • Android用UCブラウザー(v。11.4まで)
  • QQ(v。1.2まで)

CanIUse.com(提携なし)で詳細(および最新)の情報を確認できます。


3
TypeScriptもそれをサポートしているようです。
mtyson

1
これはラムダ式のように見えますね。
Addem

1
ブラウザの互換性について言及したいのですが、ES6 / ES7の矢印関数やIE11とネイティブに互換性のないその他の機能を使用していますが、GulpまたはWebpackをBabelとともに使用してES6をES5にトランスパイルし、IE11で動作します。したがって、IE11のサポートが必要で、Babelの設定を気にしない場合は、それを試してください。
mbokil

76

これは、ECMAScript 2015仕様の一部であるArrow Functionとして知られています...

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

歴史的な目的のため(wikiページが後で変更された場合)、それは次のとおりです。

矢印関数式は、関数式に比べて構文が短く、字句的にthis値をバインドします。アロー関数は常に匿名です。


1
十分な情報を含めて、ほとんどの読者がドリルダウンする必要がないようにしますか?
djechlin 14

2
私がリンクしているwikiは、それが何であるかを非常に簡潔に説明しています。
カイル・ファルコナー2014

1
これを引用としてここに追加すると、答えが非常に役立ちます。
ハンキーパンキー2014

22

これらはアロー関数です

Fat Arrow Functionsとも呼ばれます。これらは、関数式を記述するためのクリーンで簡潔な方法function() {}です。

アロー機能の必要性を除去することができfunctionreturnおよび{}関数を定義するとき。これらは、JavaまたはPythonのラムダ式と同様のワンライナーです。

パラメータなしの例

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

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

同じArrow Function内で複数のステートメントを作成する必要がある場合は、この例でqueue[0]は、中括弧で囲む必要があります{}。この場合、returnステートメントは省略できません。

1つのパラメーターの例

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

addCustomer('Toby');

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

{}上記は省略できます。

パラメーターが1つ()しかない場合は、パラメーターの前後の大括弧を省略できます。

複数のパラメーターの例

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:まだサポートされていません
  • Edge: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は、ローカルのバインディングを定義していないargumentssuperthis、またはnew.target。参照argumentssuperthis、またはnew.targetArrowFunctionは字句的に取り囲む環境での結合に解決される必要があります。通常、これは直接囲んでいる関数の関数環境になります。

    ArrowFunctionにへの参照が含まれている場合でもsuper、手順4で作成された関数オブジェクトはMakeMethodを実行してもメソッドにはなりません。参照するArrowFunctionsuper は常に非ArrowFunction内に含まれ、実装に必要な状態は、ArrowFunctionの関数オブジェクトによってキャプチャされるスコープsuper介してアクセスできます。

  • それらは非コンストラクタです。

    つまり、[[Construct]]内部メソッドがないため、インスタンス化できません。たとえば、

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

8

私は、これはのシンボルであり、読んArrow FunctionsES6

この

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

使用Arrow Functionは次のように書くことができます

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

MDNドキュメント


6

Arrowfunctionを使用した簡単なCRUDの例を追加する

 //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部分を理解することは重要であり、それは大きなトピックです。それはthisJavaScriptの意味と関係があります。

すべての関数には、という暗黙のパラメーターがありますthisthis関数の呼び出し時の設定方法は、その関数の呼び出し方法によって異なります。

取る

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を使用して直接設定できますcallapply

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ドット演算子を使用して暗黙的に設定することもできます.

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値がクラスのインスタンスにならないため、上記のコードは機能しません。

その問題を解決する1つの一般的な方法は、 .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の矢印関数構文の一部です。より具体的には、これは演算子ではなく、本文からパラメーターを区切る区切り記号ですArrowFunction : ArrowParameters => ConciseBody。例えば(params) => { /* body */ }


1

ES6 矢印関数:

JavaScriptでは、これ=>はアロー関数式のシンボルです。アロー関数式には独自の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

記号(=>)で示されるアロー関数は、匿名の関数とメソッドを作成するのに役立ちます。これにより、構文がより短くなります。たとえば、以下は2つの数値の加算を返す単純な「Add」関数です。

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

上記の機能は、以下に示すように「矢印」構文を使用することにより短くなります。

ここに画像の説明を入力してください

上の図に示すように、上記のコードには2つの部分があります。-

入力:—このセクションでは、無名関数への入力パラメーターを指定します。

ロジック:—このセクションは、記号「=>」の後にあります。このセクションには、実際の機能のロジックがあります。

多くの開発者は、アロー関数によって構文が短く簡単になるため、コードが読みやすくなると考えています。

上記の文を信じたら、それが神話であることを保証させてください。ちょっと考えてみれば、名前が正しく記述された関数は、矢印記号を使用して1行で作成された不可解な関数よりもはるかに読みやすくなっています。

arrow関数の主な用途は、コードが呼び出し元のコンテキストで実行されるようにすることです。

グローバル変数「コンテキスト」が定義されている以下のコードを参照してください。このグローバル変数は、他のメソッド「SomeMethod」から呼び出される関数「SomeOtherMethod」内でアクセスされます。

この「SomeMethod」にはローカルの「コンテキスト」変数があります。"SomeOtherMethod"は "" SomeMethod "から呼び出されるので、"ローカルコンテキスト "を表示することを期待していますが、"グローバルコンテキスト "を表示しています。

var context = global context”;

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

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

var instance = new SomeMethod();

ただし、Arrow関数を使用して呼び出しを置き換えると、「ローカルコンテキスト」が表示されます。

var context = "global context";

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

JavaScriptコンテキストのすべてのシナリオを説明し、呼び出し側のコンテキストが尊重されないシナリオについて説明しているこのリンク(JavaScriptのArrow関数)をお読みになることをお勧めします。

このYouTubeビデオでは、コンテキストという用語を実際に示すJavaScriptを使用したArrow関数のデモもご覧いただけます。


0

他の人が述べたように、通常の(従来の)関数はthis、関数を呼び出したオブジェクト(たとえば、クリックされたボタン)から使用します。代わりに、矢印関数thisは、関数を定義するオブジェクトから使用します。

ほぼ同じ2つの関数を考えます。

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.