JavaScript ES6, oficialmente conhecido como ECMAScript 2015, introduziu melhorias significativas e novos recursos que transformaram a maneira como os desenvolvedores escrevem JavaScript. Aqui estão os 20 principais recursos que definem o ES6 e tornaram a programação em JavaScript mais eficiente e agradável.

Os 20 principais recursos do JavaScript ES6

1 Let e ​​Const

• let permite a declaração de variáveis ​​com escopo de bloco.
• const cria constantes com escopo de bloco, evitando a reatribuição.

2 Funções de seta

• Sintaxe mais curta para expressões de função, mantendo o valor lexical desta.

   const add = (a, b) => a   b;

3 Literais de modelo

• Literais de string aprimorados que suportam interpolação e strings multilinhas.

   const name = 'World';
   const greeting = `Hello, ${name}!`;

4 Tarefa de desestruturação

• Uma sintaxe para descompactar valores de arrays ou propriedades de objetos em variáveis ​​distintas.

   const arr = [1, 2, 3];
   const [x, y, z] = arr;

5 Parâmetros padrão

• Os parâmetros de função podem ter valores padrão, tornando as funções mais flexíveis.

   function multiply(a, b = 1) {
       return a * b;
   }

6 Operadores de descanso e spread

• ... pode ser usado para expandir ou reunir elementos.

   const sum = (...numbers) => numbers.reduce((a, b) => a   b, 0);
   const arr = [1, 2, 3];
   const newArr = [...arr, 4, 5];

7 Módulos

• ES6 introduz um sistema de módulos para melhor organização do código.

   // export
   export const pi = 3.14;
   // import
   import { pi } from './math.js';

8 Aulas

• Açucar sintático sobre a herança baseada em protótipo existente do JavaScript, permitindo definições de classe mais fáceis.

   class Animal {
       constructor(name) {
           this.name = name;
       }
       speak() {
           console.log(`${this.name} makes a noise.`);
       }
   }

9 Promessas

• Uma maneira nativa de lidar com operações assíncronas, fornecendo uma alternativa mais limpa aos retornos de chamada.

   const fetchData = () => new Promise((resolve, reject) => {
       // async operation
   });

10 Literais de objeto aprimorados
- Sintaxe mais concisa para definir propriedades e métodos de objetos.

    const name = 'John';
    const person = {
        name,
        greet() {
            console.log(`Hello, ${this.name}`);
        }
    };

11 Tipo de dados de símbolo
- Um novo tipo de dados primitivo para identificadores exclusivos.

    const sym = Symbol('description');

12 Mapa e coleções de conjuntos
- Novas estruturas de dados para armazenar valores únicos ou pares de valores-chave.

    const mySet = new Set([1, 2, 3]);
    const myMap = new Map([[1, 'one'], [2, 'two']]);

13 WeakMap e WeakSet
- Coleções que permitem a coleta de lixo de suas chaves.

    const weakMap = new WeakMap();

14 Iteradores e Geradores
- Objetos iteráveis ​​personalizados usando o Symbol.iterator e funções que podem ser pausadas usando function*.

    function* generator() {
        yield 1;
        yield 2;
    }

15 para...de Loop
- Uma nova construção de loop para iterar objetos iteráveis, como arrays e strings.

    for (const value of [1, 2, 3]) {
        console.log(value);
    }

16 Array.prototype.find() e Array.prototype.findIndex()
- Métodos para pesquisar arrays e retornar a primeira correspondência ou seu índice.

    const arr = [5, 12, 8, 130, 44];
    const found = arr.find(element => element > 10);

17 String.prototype.includes()
- Um método para verificar se uma string contém uma substring especificada.

    const str = 'Hello, world!';
    console.log(str.includes('world')); // true

18 Object.assign()
- Um método para copiar valores de um ou mais objetos de origem para um objeto de destino.

    const target = { a: 1 };
    const source = { b: 2 };
    Object.assign(target, source);

19 Object.entries() e Object.values()
- Métodos para recuperar as entradas ou valores de um objeto como arrays.

    const obj = { a: 1, b: 2 };
    console.log(Object.entries(obj)); // [['a', 1], ['b', 2]]

20 Promise.all() e Promise.race()
- Métodos para lidar com múltiplas promessas simultaneamente.

    Promise.all([promise1, promise2]).then(results => {
        // handle results
    });

Conclusão

JavaScript ES6 aprimorou fundamentalmente a linguagem, tornando-a mais poderosa e amigável ao desenvolvedor. Ao utilizar esses recursos, os desenvolvedores podem escrever códigos mais limpos, eficientes e de fácil manutenção. Aproveite o poder do ES6 em seu próximo projeto!