Classe Promise no TypeScript
Este artigo explica a classe Promise no TypeScript.
YouTube Video
Promise
A classe Promise no TypeScript é basicamente a mesma que a Promise no JavaScript. Uma Promise é uma classe embutida para lidar com operações assíncronas, representando o resultado de uma operação assíncrona quando ela é concluída. Aqui, explicamos o uso básico de Promises e conceitos relacionados.
Uso Básico
Criando uma Promise:
Um objeto Promise é usado para encapsular operações assíncronas. Uma Promise é criada com new Promise(executor) e executa operações assíncronas dentro dela. O executor recebe duas funções, resolve e reject, como argumentos.
1const myPromise = new Promise<number>((resolve, reject) => {
2 // Perform asynchronous operations
3 const success = true; // This is just an example
4 if (success) {
5 resolve(42); // In case of success
6 } else {
7 reject('Failed'); // In case of failure
8 }
9});Usando uma Promise:
A Promise criada é processada usando then() e catch().
1myPromise.then((value) => {
2 console.log(`Success: ${value}`); // Process the value passed with resolve
3}).catch((error) => {
4 console.error(`Error: ${error}`); // Handle the error passed with reject
5});Método finally()
1const myPromise = new Promise<number>((resolve, reject) => {
2 // Perform asynchronous operations
3 const success = false; // This is just an example
4 if (success) {
5 resolve(42); // In case of success
6 } else {
7 reject('Failed'); // In case of failure
8 }
9});
10
11myPromise.then((value) => {
12 console.log(`Success: ${value}`); // Process the value passed with resolve
13}).catch((error) => {
14 console.error(`Error: ${error}`); // Handle the error passed with reject
15}).finally(() => {
16 console.log('The operation has completed');
17});- O método
finally()define um código que sempre será executado, independentemente de aPromiseser resolvida ou rejeitada.
Encadeando Promises:
Encadeando then() após then(), é possível conectar várias operações assíncronas em série.
1const myPromise = new Promise<number>((resolve, reject) => {
2 // Perform asynchronous operations
3 const success = true; // This is just an example
4 if (success) {
5 resolve(42); // In case of success
6 } else {
7 reject('Failed'); // In case of failure
8 }
9});
10
11myPromise
12 .then((value) => {
13 console.log(`Success: ${value}`);
14 return value + 1; // Pass the value to the next then
15 })
16 .then((newValue) => {
17 console.log(`New value: ${newValue}`);
18 })
19 .catch((error) => {
20 console.error(`Error: ${error}`);
21 });async/await:
No TypeScript, você pode lidar com Promises de forma mais direta usando async/await. Dentro de uma função async, você pode usar a palavra-chave await para aguardar o resultado de uma Promise.
1const myPromise = new Promise<number>((resolve, reject) => {
2 // Perform asynchronous operations
3 const success = true; // This is just an example
4 if (success) {
5 resolve(42); // In case of success
6 } else {
7 reject('Failed'); // In case of failure
8 }
9});
10
11async function asyncFunction() {
12 try {
13 const value = await myPromise;
14 console.log(`Success: ${value}`);
15 } catch (error) {
16 console.error(`Error: ${error}`);
17 }
18}
19
20asyncFunction();Métodos de Promise
Promise.all()
Promise.all executa várias Promises simultaneamente e aguarda até que todas sejam resolvidas.
1const promise1 = Promise.resolve(1);
2const promise2 = Promise.resolve(2);
3const promise3 = Promise.resolve(3);
4
5Promise.all([promise1, promise2, promise3])
6 .then((results) => {
7 console.log(results); // [1, 2, 3]
8 })
9 .catch((error) => {
10 console.error('Error :', error);
11 });then()é chamado apenas quando todas asPromisessão resolvidas.catch()é chamado se ao menos uma falhar.
Promise.race()
Promise.race retorna o resultado da primeira Promise que é concluída entre várias Promises.
1const promise1 = new Promise((resolve) => setTimeout(resolve, 100, 'First'));
2const promise2 = new Promise((resolve) => setTimeout(resolve, 500, 'Second'));
3
4Promise.race([promise1, promise2]).then((result) => {
5 console.log(result); // "First"
6});- Como neste exemplo, o resultado da primeira
Promiseque for concluída é retornado.
Promise.allSettled()
Promise.allSettled espera todas as Promises serem concluídas e retorna um array com todos os resultados, incluindo tanto as resolvidas quanto as rejeitadas.
1const promise1 = Promise.resolve(1);
2const promise2 = Promise.reject("Failed");
3const promise3 = Promise.resolve(3);
4
5Promise.allSettled([promise1, promise2, promise3])
6 .then((results) => {
7 results.forEach(result => console.log(result));
8 // [
9 // { status: 'fulfilled', value: 1 },
10 // { status: 'rejected', reason: 'Failed' },
11 // { status: 'fulfilled', value: 3 }
12 // ]
13 });then()é chamado quando todas asPromisesforem concluídas (sejam resolvidas ou rejeitadas). Cada resultado inclui uma propriedadestatus('fulfilled'ou'rejected'). Falhas não afetam as outras operações.
Promise.any()
Promise.any espera até que a primeira Promise seja resolvida e a retorna.
1const promise1 = new Promise((resolve) => setTimeout(() => resolve("A ok"), 300));
2const promise2 = new Promise((_, reject) => setTimeout(() => reject("B fail"), 100));
3const promise3 = new Promise((resolve) => setTimeout(() => resolve("C ok"), 200));
4
5Promise.any([promise1, promise2, promise3])
6 .then(value => {
7 // Logs the first fulfilled value ("C ok")
8 console.log("first fulfilled:", value);
9 })
10 .catch(err => {
11 console.log("should not reach here in this example:", err);
12 });- Ela retorna o primeiro valor resolvido entre várias
Promises.
Resumo
Usando o TypeScript, você pode especificar os tipos das Promises adequadamente, permitindo que escreva programas com maior segurança de tipos. Isso ajuda a capturar erros mais cedo durante o desenvolvimento, especificando o tipo de valor que uma Promise retorna com antecedência.
Você pode acompanhar o artigo acima usando o Visual Studio Code em nosso canal do YouTube. Por favor, confira também o canal do YouTube.