это известно как функция стрелки, часть ECMAScript 2015 spec...

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
подробнее о синтаксисе

больше, вот!--7--> очень хороший ответ для , когда для использования функций стрелки.

Это будет "выражение функции стрелки", введенное в ECMAScript 6.

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

для исторических целей (если страница wiki изменится позже), это:

выражение функции стрелки имеет более короткий синтаксис по сравнению с выражениями функции и лексически связывает это значение. Функции стрелки всегда анонимны.

просто чтобы добавить еще один пример того, что лямбда может сделать без использования 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

это функции стрелки

также известный как Функции Жирной Стрелкой. Это чистый и удобный способ записи выражений функций, например function() {}.

стрелки функции могут удалить необходимость function,return и {} при определении функции. Это однострочные выражения, похожие на лямбда-выражения в Java или Python.

пример без параметров

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

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

если несколько заявлений нужно сделать в пределах той же функции стрелки, вам нужно обернуть, в этом примере,queue[0] в скобках Керли {}. В этом случае оператор return не может быть опущен.

пример с 1 параметром

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

addCustomer('Toby');

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

можно не указывать {} сверху.

когда есть один параметр, скобки () вокруг параметра можно опустить.

пример с несколькими параметры

var addition = (x, y) => x + y

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

полезный пример

var 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+

дополнительную актуальную информацию можно найти на странице совместимость с браузером здесь

как уже говорили другие, это новый синтаксис для создания функций.

однако этот вид функций отличается от обычных:

• они связывают this значение. Как объяснил спец,

  An ArrowFunction не определяет локальные привязки для arguments, super,this или new.target. Любая ссылка на arguments, super,this или new.target в ArrowFunction должны разрешите привязку в лексически замкнутой среде. Типично это будет функциональная среда немедленно заключающего функция.

  даже если ArrowFunction может содержать ссылки на super, в объект функции, созданный на шаге 4, не превращается в метод с помощью выполнение MakeMethod. Ан ArrowFunction ссылки super всегда содержится в не ArrowFunction и необходимые состояние для реализации super доступно через scope это захвачен объектом функции ArrowFunction.

• они не являются конструкторы.

  это означает, что они не имеют [[построить]] внутренний метод, и поэтому не может быть создан экземпляр, например

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

Я читал, это символ Arrow Functions на ES6

этой

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

используя Arrow Function можно записать как

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

MDN Docs

добавление простого примера 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)); 

Как уже говорилось во всех других ответах, это часть синтаксиса функции стрелки ES2015. Более конкретно, это не оператор, это знак препинания, который отделяет параметры от тела:ArrowFunction : ArrowParameters => ConciseBody. Е. Г. (params) => { /* body */ }.

ES6 стрелка функции:

в javascript the => является символом выражения функции стрелки. Выражение функции стрелки не имеет своего собственного 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));