Promise

• Promise

info

Representa uma operação futura que inicia quando criada ou await

const loadPosts = async () => {
    const res = await fetch('')
    return await res.json();
    }

const loadUsers = async () => {
    const res = await fetch('url')
    return await res.json();
    }

const loadAll = async ( ) =>{
    const posts = a await loadPosts();
    const users = await loadUsers();
    }

/*Carrega em paralelo*/
 const loadAllWithPromiseAll = async ( ) => {
    const [posts, users] = await Promise.all([
        loadPosts(),
        loadUsers()
    ])
}

Callback e Promises

Definições

Callback: Um callback é uma função que é passada como argumento para outra função e é executada depois que algum tipo de operação é concluída. É uma forma comum de lidar com operações assíncronas em JavaScript.

Exemplo de Callback:

function doSomething(callback) {
  setTimeout(() => {
    console.log("Operação concluída.");
    callback();
  }, 1000);
}

function myCallback() {
  console.log("Callback executado.");
}

doSomething(myCallback);

Promise: Uma promise é um objeto que representa a eventual conclusão (ou falha) de uma operação assíncrona e seu valor resultante. As promises fornecem métodos para lidar com o sucesso ou a falha da operação.

Exemplo de Promise:

function doSomething() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      console.log("Operação concluída.");
      resolve("Resultado da operação");
    }, 1000);
  });
}

doSomething().then(result => {
  console.log(result);
});

Convertendo Callback para Promise

Para converter uma função baseada em callback para usar uma promise, você encapsula a função que usa callback dentro de uma nova Promise.

Exemplo:

Vamos supor que temos uma função readFile que usa callback:

const fs = require('fs');

function readFileCallback(filename, callback) {
  fs.readFile(filename, 'utf8', (err, data) => {
    if (err) return callback(err);
    callback(null, data);
  });
}

Podemos convertê-la para usar uma Promise:

const fs = require('fs');

function readFilePromise(filename) {
  return new Promise((resolve, reject) => {
    fs.readFile(filename, 'utf8', (err, data) => {
      if (err) return reject(err);
      resolve(data);
    });
  });
}

// Uso da função com Promise
readFilePromise('example.txt')
  .then(data => {
    console.log(data);
  })
  .catch(err => {
    console.error(err);
  });

Aninhamento de Callbacks e Promises

Para obter o resultado de uma combinação de callbacks e promises aninhados, você precisa garantir que cada etapa seja executada na ordem correta. Aqui está um exemplo onde temos um callback, uma promise e outro callback aninhados:

// Função que usa callback
function firstCallbackFunction(callback) {
  setTimeout(() => {
    console.log("Primeiro callback executado.");
    callback("Dados do primeiro callback");
  }, 1000);
}

// Função que retorna uma promise
function promiseFunction(data) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      console.log("Promise executada com dados:", data);
      resolve("Dados da promise");
    }, 1000);
  });
}

// Função que usa callback
function secondCallbackFunction(data, callback) {
  setTimeout(() => {
    console.log("Segundo callback executado com dados:", data);
    callback("Dados do segundo callback");
  }, 1000);
}

// Aninhando callbacks e promises
firstCallbackFunction(firstData => {
  promiseFunction(firstData).then(promiseData => {
    secondCallbackFunction(promiseData, secondData => {
      console.log("Resultado final:", secondData);
    });
  });
});

Neste exemplo, firstCallbackFunction é executada, depois promiseFunction, e finalmente secondCallbackFunction, garantindo que os dados sejam passados de uma etapa para a próxima.