JavaScript 없음을 약속합니다.

플럭소 어신크로노

O JavaScript é uma linguagem single-threade

결과

Deixa o usuário sem ação durante todo o tempo para a realização de uma operação;

Não permitte que o servidor seja capaz de realizar algum outtra requisição até que a atual termine,,,,,,.

솔루상

Buscar em tornar operações muito extensas em operações assíncronas, dessa forma tornando o codigo mais performático e bem escrito.

콜백

Assim que uma operação for concluída a callback será executada

예:

const fs = require('fs');
fs.readFile('./arquivo.txt', (err, content) => {
  if (err) {
    console.error(`Erro ao ler o arquivo: ${err.message}`);
    return; 
  } 
  console.log(`Arquivo lido. Conteúdo: ${content.toString('utf8')}`);});

No codigo acima é utilizado umanode-style callback(Node.js의 콜백 기본 형식)

O que está acontecendo:

Primeiro parametro é passado o arquivo que sera lido;

no segundo parametro é passado uma callback para tratar a resposta da função

Assim é possível tratar a resposta de forma diferente,dependendo de se ocorreu algum erro em meio ao processo ou se tudo ocorreu como deveria

O lado ruim das 콜백:

Nem tudo são flores, o principal problema em se usar esse método é que seu resultado estará unicamente naquela callback, o que gera a necessidade de executar uma coisa dentro da outra

예:

콜백 지옥

const fs = require('fs');
fs.readFile('file1.txt', (err, file1Content) => {
  if (err) return console.log(Erro ao ler arquivo 1: ${err.message});
  console.log(Lido file1.txt com ${file1Content.byteLength} bytes);
  fs.readFile('file2.txt', (err, file2Content) => {
    if (err) return console.log(Erro ao ler o arquivo 2: ${err.message});
    console.log(Lido file2.txt com ${file2Content.byteLength} bytes);
    fs.readFile('file3.txt', (err, file3Content) => {
      if (err) return console.log(Erro ao ler o arquivo 3: ${err.message});
      console.log(Lido file3.txt com ${file3Content.byteLength} bytes);
    });
  });
});

Como Mostrado no codigo acima, a legibilidade se torna muito mais complexa devido a necessidade de criar uma callback dentro de outra callback até concluir sua tarefa.

가능한 해결책:

const fs = require('fs');
const file3Callback = (err, file3Content) => {
  if (err) return console.log(Erro ao ler o arquivo 3: ${err.message});
  console.log(Lido file3.txt com ${file3Content.byteLength} bytes);
};
const file2Callback = (err, file2Content) => {
  if (err) return console.log(Erro ao ler o arquivo 2: ${err.message});
  console.log(Lido file2.txt com ${file2Content.byteLength} bytes);
  fs.readFile('file3.txt', file3Callback);
};
const file1Callback = (err, file1Content) => {
  if (err) return console.log(Erro ao ler arquivo 1: ${err.message});
  console.log(Lido file1.txt com ${file1Content.byteLength} bytes);
  fs.readFile('file2.txt', file2Callback);
};
fs.readFile('file1.txt', file1Callback);

Como tentativa de tornar o codigo mais legível, são criadas varias funções com o único intuito de chamar a próxima callback, apesar de torná-lo um pouco mais legível, ainda não é performático.

약속

A cereja do bolo para as callbacks, melhorando sua legibilidade e deixando seu código muito mais intuitivo.

Sua principal diferença é que ao invés de uma única callback 리시버 tanto o sucesso quanto o erro, ela tera duas callback com funções únicas, uma lidará com o erro e a outra .como

좋아, mas como essa mágica acontece?

os dois casos a seguir 관찰:

function dividirNumerosSemPromises(num1, num2) {
  if (num2 == 0) throw new Error("Não pode ser feito uma divisão por zero");

  return num1 / num2;
}

try {
  const resultado = dividirNumeros(2, 1);
  console.log(`resultado: ${resultado}`);
} catch (e) {
  console.log(e.message);
}

Na função síncrona dividirNumerosSemPromises o resultado da callback já é tratado dentro da função.

function dividirNumerosComPromises(num1, num2) {
  const promise = new Promise((resolve, reject) => {
    if (num2 == 0) reject(new Error("Não pode ser feito uma divisão por zero"));
    const resultado = num1 / num2;
    resolve(resultado)
  });
  return promise;
}
dividirNumeros(2, 1)
  .then(result => console.log(sucesso: ${result}))
  .catch(err => console.log(erro: ${err.message}));

Agora na função assíncrona dividirNumerosComPromises o resultado não é tratado dentro da função, mas sim onde ela está sendo chamada. Assim, com uma mesma função é possível tratar a resposta em inúmeras formas diferentes

그런 다음 e 해결 x 캐치 e 거부

Caso não tenha percebido, no segundo caso essas duas palavrinhas são utilizadas, mas o que elas significam?

그런 다음: forma de tratar o sucesso de uma callback, pode ser utilizado varias vezes no mesmo contexto;

잡기: igualmente ao then, porém sua tarefa é tratar o erro.

Estrutura da Promese:

const p = new Promise((resolve, reject) => {
  // Aqui é onde vamos realizar a lógica que precisamos
  // para "tentar cumprir" a promessa
});

Ao escrevê-la, não se esqueça de utilizar a palavra-chave new e da arrow function como parâmetro daPromese .

const fs = require('fs');
function readFilePromise (fileName) {
  return new Promise((resolve, reject) => {

    fs.readFile(fileName, (err, content) => {
      if (err) return reject(err);
      resolve(content);
    });

  });
}

Perceba, no exemplo acima estamos utilizando do modulo interno fs apenas com o intuito de ilustrar, o Importante aqui é perceber como o resolve e o reject são utiliz

readFilePromise('./file.txt') // A função me promete que vai ler o arquivo
  .then((content) => { // Caso ela cumpra o que prometeu
    console.log(Lido arquivo com ${content.byteLength} bytes); // Escrevo o resultado no console
  })
  .catch((err) => { // Caso ela não cumpra o que prometeu
    console.error(Erro ao ler arquivo: ${err.message}); // Escrevo o erro no console
  });

Sei que é muita coisa, mas aos pouquinhos você vai pegar o jeito :)