didática

Tentarei explicar de forma clara como funciona os métodos por debaixo dos panos.

  SORT():

O método sort() do JavaScript ordena os elementos de um array in-place, ou seja, ele altera o array original e não cria uma cópia. O comportamento padrão do sort() é ordenar os elementos de acordo com a ordem lexicográfica (ou seja, como strings), o que pode gerar resultados inesperados ao ordenar números.

1. Comparação de elementos:

• O sort() compara elementos do array usando uma função de comparação (callback). Se você não fornecer uma função de comparação, ele vai converter os elementos para strings e ordenar com base na sequência de código Unicode.

Exemplo sem função de comparação:

let arr = [10, 5, 30, 1];
arr.sort();  // Resultado: [1, 10, 30, 5]

O resultado parece errado porque a comparação padrão é feita como strings.

2. Comparação de elementos com função de comparação:

Quando usamos sort() com uma função de comparação personalizada, o JavaScript utiliza essa função para determinar a ordem dos elementos no array. A função de comparação recebe dois elementos do array (vamos chamá-los de a e b), e ela deve retornar:

• Um número negativo se a deve vir antes de b (ou seja, a < b).
• Zero se a e b são considerados iguais (ou seja, a === b).
• Um número positivo se a deve vir depois de b (ou seja, a > b).

Como a - b funciona:

Quando você faz a - b em uma função de comparação, o JavaScript:

1. Subtrai o valor de b de a.
2. O resultado da subtração é então usado para determinar a ordem:

• Se o resultado for negativo (a - b < 0), significa que a é menor que b, logo a vem antes de b (ordem crescente).
• Se o resultado for zero (a - b === 0), significa que a é igual a b, então a ordem entre eles não muda.
• Se o resultado for positivo (a - b > 0), significa que a é maior que b, então a vem depois de b.

Exemplo:

let arr = [10, 5, 20, 1];

// Função de comparação (ordem crescente)
arr.sort((a, b) => a - b);
console.log(arr);  // Resultado: [1, 5, 10, 20]

Passo a passo da lógica de a - b:

1. Compara 10 e 5:
   • a - b = 10 - 5 = 5 (positivo, então 10 vem depois de 5).
2. Compara 5 e 20:
   • a - b = 5 - 20 = -15 (negativo, então 5 vem antes de 20).
3. Compara 20 e 1:
   • a - b = 20 - 1 = 19 (positivo, então 20 vem depois de 1).

Assim, o array é reorganizado corretamente em ordem crescente.

  REDUCE():

O método reduce() no JavaScript funciona aplicando uma função de callback a cada elemento do array, acumulando um valor final que é retornado ao final da execução. O que acontece quando você usa acc + atual é essencialmente a repetição de um padrão onde cada valor do array é adicionado ao acumulador (acc) a cada iteração, gerando um único resultado no final.

  Como funciona o acc + atual no reduce() por debaixo dos panos:

1. O reduce() aceita dois parâmetros principais:

   • Uma função de callback que é chamada em cada iteração.
   • Um valor inicial opcional, que serve como o primeiro valor do acumulador.

2. A função de callback: A função de callback passada para o reduce() recebe os seguintes parâmetros:

   • acc (acumulador): O valor retornado da iteração anterior (ou o valor inicial, se fornecido).
   • atual (valor atual): O valor do elemento do array que está sendo processado na iteração atual.

3. Primeira Iteração:

   • Se você fornecer um valor inicial, o acumulador (acc) começa com esse valor, e o reduce() começa a iteração no primeiro elemento do array.
   • Se não fornecer um valor inicial, o acumulador assume o valor do primeiro elemento do array, e a iteração começa no segundo elemento.

Exemplo:

let arr = [1, 2, 3];

// Usando reduce() para somar todos os valores do array
let soma = arr.reduce((acc, atual) => acc + atual, 0);

console.log(soma);  // Resultado: 6

  Passo a passo da lógica do reduce():

1. Valor inicial fornecido: 0

   • Na primeira iteração, o acumulador (acc) começa com 0 e o valor atual (atual) é 1.
   • acc + atual → 0 + 1 = 1.
   • O acumulador agora é 1.

2. Segunda iteração:

   • O acumulador é agora 1 e o valor atual é 2.
   • acc + atual → 1 + 2 = 3.
   • O acumulador agora é 3.

3. Terceira iteração:

   • O acumulador é 3 e o valor atual é 3.
   • acc + atual → 3 + 3 = 6.
   • O acumulador agora é 6.

4. Fim do array:

   • O reduce() terminou de iterar por todos os elementos do array, e o valor final do acumulador, 6, é retornado como o resultado.

    Espero que tenha ficado claro e entendível as explicações dos métodos, qualquer dúvida pode mandar que tentarei explicar.