JavaScript promete tutorial com exemplos

Embora anteriormente disponíveis através de bibliotecas de terceiros, as promessas foram introduzidas em JavaScript, como nativo
Recurso, com ECMAScript6.

Eles fornecem uma alternativa aos retornos de chamada ao lidar com código assíncrono, fornecendo,
Entre as outras coisas, uma maneira mais limpa de lidar com erros. Neste tutorial, veremos como as promessas funcionam, como
crie -os e como usar seus métodos.

Neste tutorial, você aprenderá:

• O que é uma promessa de JavaScript.
• Como criar uma promessa de JavaScript.
• Como as promessas podem ser usadas para gerenciar o código assíncrono.
• Quais são os métodos que podem ser usados ​​com uma promessa.

Requisitos de software e convenções usadas

O que é uma "promessa"?

Em JavaScript, um promessa é um objeto retornado como resultado de
uma operação assíncrona e sem bloqueio, como, por exemplo, a realizada pelo buscar
função construída. As promessas foram introduzidas como uma característica nativa, com ECMAScript6: eles representam um
alternativa mais limpa aos retornos de chamada, graças a recursos como métodos de encadeamento e o fato de que eles fornecem um
Maneira de gerenciar erros que se assemelham ao tratamento de exceções em código síncrono. Existem três estados um prometido
pode estar em:

• Pendente
• Resolvido
• Rejeitado

Como o nome sugere, dizemos que uma promessa é pendente Quando seu resultado ainda não foi decidido,
Portanto, ainda pode ser resolvido ou rejeitado. Dizemos que uma promessa é realizada Quando o assíncrono
Operação foi bem -sucedida: a promessa foi resolvida e contém o resultado da própria operação.
Finalmente, diz -se que uma promessa é rejeitado Quando a operação assíncrona falha: nesse caso
promessa conterá o motivo do fracasso.

Criando uma promessa de JavaScript

Como mencionado acima, algumas funções que executam operações assíncronas, como buscar, retornar
uma promessa por padrão, para que possamos usar os métodos e os padrões que descreveremos mais adiante neste tutorial. Outras funções
Ainda não apóia as promessas, então podemos querer criar uma promessa ao seu redor. O construtor de uma promessa leva um argumento,
que é uma função de retorno de chamada que por si só leva dois argumentos: o resolver e rejeitar retornos de chamada, que
são chamados para resolver ou rejeitar a promessa, respectivamente. Vamos ver um exemplo rápido de como criar uma promessa trivial:

const promessa = nova promessa (função (resolver, rejeitar) setTimeout (resolve, 100, 'sucesso!'); ); 

Com o código acima, criamos uma promessa, que será sempre resolvida, porque usando o
setTimeout função, chamamos de resolver retorno de chamada após um tempo limite de 100 milissegundos,
Passando a string "Sucesso!”Como o único argumento do retorno de chamada. Da mesma maneira, se quiséssemos a promessa
Para ser rejeitado, deveríamos ter invocado o rejeitar ligar de volta. Obviamente uma promessa como a
Um acima não é muito útil para nós, então agora tentaremos criar uma promessa em torno de uma função realmente útil.

O ReadFile Método do fs módulo, lê assíncrono o conteúdo de um arquivo e
leva três argumentos: dois deles são obrigatórios e um é opcional. O primeiro argumento é o caminho do arquivo
para ser lido. O segundo argumento é opcional e, com ele, podemos, por exemplo, especificar o
codificação ser usado. O terceiro argumento é uma função de retorno de chamada, que em si leva dois argumentos:
errar e dados.

Se a operação de leitura falhar, o primeiro argumento conterá um Erro
objeto e o segundo serão indefinidos; Se a operação for bem -sucedida, o segundo argumento será um
string representando o conteúdo do arquivo, ou um buffer bruto se nenhuma codificação for especificada, enquanto o primeiro argumento será
ser nulo. Diga, por exemplo, eu quero ler meu .Vimrc Arquivo usando esta função:

const fs = requer ('fs'); fs.ReadFile ('.vimrc ',' utf-8 ', function (err, dados) if (err) tiro err console.log (dados)); 

Primeiro de tudo, exigimos o fs módulo e atribuído ao fs constante, que
Continuamos invocando o ReadFile método. No retorno de chamada aceito como o último argumento da função, nós desempenhamos
as operações necessárias, dependendo do resultado obtido. No código acima nós lançar uma exceção se ocorrer algum erro
Ao tentar ler o arquivo, enquanto apenas imprimimos o conteúdo do arquivo, se tudo correr como o esperado. Neste caso, isso seria
o resultado (truncado):

[…] Set fileFormat = Unix Definir TextWidth = 79 Definir offile Set FoldMethod = Indent Set Doblevel = 99 Definir Splitright Definir SplitBoLow Conjunto HLSearch Conjunto IncSearch Definir Ignorecase Set SmartCase […] 

O método que acabamos de usar, ReadFile, executa a operação de leitura de forma assíncrona, então não está bloqueando. Por padrão, não,
No entanto, as promessas de apoio. Se queremos "promissificar" o uso desse método, devemos criar uma promessa em torno dele por nós mesmos:

const fs = requer ('fs'); function readfilepromise (filepath) return nova promessa (função (resolve, rejeição) fs.readfile (filepath, 'utf-8', function (err, dados) if (err) rejeit (err); else resolve (data);); );  

Veja o código acima, o que mudamos? Nós criamos o readfilepromise função: dentro disso
uma promessa baseada no resultado do fs.ReadFile O método é criado e devolvido. No exemplo anterior,
Ajustamos o código para lançar uma exceção se um erro na operação de leitura estivesse presente: neste caso, em vez disso, já que nós
estão construindo uma promessa, se ocorrer um erro, chamamos o rejeitar retorno de chamada, passando o erro como seu único argumento,
assim rejeitando a promessa. Se a operação de leitura for executada com sucesso, em vez disso, chamamos resolver, passagem
os dados resultantes da operação de leitura como argumento, cumprindo a promessa. No próximo parágrafo, veremos como
para realmente consumir a promessa que acabamos de criar.

Métodos de promessa

Um objeto de promessa não seria útil se não tivéssemos maneiras de interagir com ele e consumi -lo. Nesta seção nós iremos
Descreva os métodos que podemos usar no objeto Promise. Cada um desses métodos funciona com uma promessa e, por sua vez, retorna uma promessa
por si só, permitindo -nos criar uma "pilha" e executar o método encadeamento.

O então método

O então O método leva dois argumentos, que na verdade são dois retornos de chamada a serem executados, respectivamente, quando a promessa
é cumprido e quando é rejeitado, e retorna uma promessa. Ficando com o exemplo acima, eis como poderíamos usar este método
para interagir com a promessa retornada quando chamamos de readfilepromise função:

readfilepromise ('.vimrc ').Então (função onResolveCallback (Data) Console.log (dados); , função onrejectCallback (Razão) Console.log ('A mensagem de erro é $ reason'); ) 

Quando a promessa sai do pendente estado, e assim é resolvido ou rejeitado, o então método é
executado. Se a promessa for resolvida, o primeiro retorno de chamada (neste caso, nomeamos os retornos de chamada apenas para facilitar o entendimento de seus papéis)
é executado, seu argumento mantendo o resultado da operação assíncrona (neste caso, o conteúdo do “.arquivo vimrc ”como uma string).
Se a promessa for rejeitada, o segundo retorno de chamada (nós o chamamos de OnRejectCallback) seria executado: seu argumento conterá o erro
O que fez com que a operação de leitura falhe.

O pegar método

Diferente então, que lida com ambos quando uma promessa é resolvida e rejeitada, o pegar O método é mais específico,
e lida apenas com o último caso. Usar este método é o equivalente a usar então com indefinido Enquanto o
primeiro argumento, em vez do retorno de chamada usado para lidar com o caso quando a promessa é cumprida e com um retorno de chamada válido para lidar com o
caso quando a promessa é rejeitada, como o segundo. Este método retorna uma promessa e, usando -o, podemos reescrever o código acima dessa maneira:

readfilepromise ('.vimrc ') // dentro' então 'gerenciamos o caso quando a promessa é cumprida, lidando // com possíveis erros dentro de' captura ' .então (function (dados) console.log (dados); ) .Catch (função (Razão) Console.log ('A mensagem de erro é $ reason'); ) 

Observe como anexamos o pegar método depois então: isso é possível
Porque, como dissemos acima, cada método retorna uma promessa em si e, portanto, eles podem ser acorrentados.

O finalmente método

Como os métodos que vimos acima, finalmente retorna uma promessa. É sempre executado independentemente do estado da promessa,
ambos se for resolvido ou rejeitado. Por esse motivo, o retorno de chamada não leva argumentos, pois quando é executado, não há como determinar
Se a promessa foi rejeitada ou resolvida. Usamos este método quando queremos executar código genérico que deve ser executado em qualquer caso.

readfilepromise ('.vimrc ') .então (function (dados) console.log (dados); ) .Catch (função (Razão) Console.log ('A mensagem de erro é $ reason'); ) .Finalmente (function () console.log ("Eu sempre sou executado!");) 

No exemplo acima, se a promessa é resolvida ou rejeitada, a string “Eu sempre sou executada!”Está impresso no console.

O corrida método

Este método exige um iterável (uma matriz, por exemplo) como seu argumento. Ele retorna uma promessa que é resolvida ou rejeitada assim que um
promessa contida no iterável, existe o estado pendente e se torna rejeitado ou resolvido. A promessa retornada, terá o
valor de cumprimento ou o motivo da rejeição da referida promessa.

const p1 = nova promessa (função (resolver, rejeitar) setTimeout (resolver, 100, 'resolvido!'); ); const p2 = nova promessa (função (resolver, rejeitar) setTimeout (rejeição, 50, 'rejeitado!'); ); Promessa.raça ([P1, P2]) .então (function (dados) console.log (dados); ) .Catch (função (Razão) Console.log (razão); ) 

Neste exemplo, criamos duas novas promessas: a primeira, P1, será resolvido após 100 milissegundos;
o segundo, P2, será rejeitado após 50 milissegundos. Passamos um iterável contendo as duas promessas como o
único argumento do Promessa.corrida método. Se executarmos o código acima, obtemos o seguinte resultado:

rejeitado!

O que aconteceu? Como esperado P2 A promessa é a primeira a se estabelecer (é rejeitada), consequentemente a promessa
devolvido pelo Promessa.corrida método, rejeita com o mesmo motivo. Como você pode ver, o estado da promessa não é relevante:
o primeiro que realmente recebe um status que não pendente é o que importa.

O todos método

Como corrida, o todos o método é um argumento iterável como seu único. Ele retorna uma promessa que
resolverá quando todas as promessas contidas no iterável resolverão (ou quando o iterável não contiver promessas) ou será
rejeitar com o motivo da primeira promessa no iterável que rejeitará. Por exemplo:

const p1 = nova promessa (função (resolver, rejeitar) setTimeout (resolver, 100, 'p1 resolvido!'); ) const p2 = nova promessa (função (resolve, rejeição) setTimeout (resolve, 100, 'p2 resolvido!'); ) Promessa.todos ([P1, P2]) .então (function (valores) console.log (valores); ) 

O código acima retornará:

['P1 resolvido!',' P2 resolvido!']

Todas as promessas contidas no iterável resolvidas, então a promessa pendente devolvida pelo todos método
Resolvido também, seu valor sendo uma matriz contendo os valores de todas as promessas resolvidas. Se um (e assim que) uma das promessas
Nas rejeições iteráveis, a promessa devolvida pelo método também rejeita, com o mesmo motivo. Se o iterável passou como argumento teve
estava vazio, uma promessa já resolvida teria sido devolvida. Se o iterável não contivesse promessas, o método teria retornado
uma promessa de forma assíncrona ou uma prometida já resolvida, dependendo do meio ambiente.

O resolver e rejeitar métodos

Esses dois métodos são auto -explicativos.

O resolver o método leva um argumento que é o valor a ser resolvido pela promessa.
Retorna uma promessa que é resolvida com esse valor. O rejeitar o método, da mesma forma, assume um argumento que é a razão de
A promessa deve ser rejeitada e retorna uma promessa que é rejeitada com o motivo dado. Por exemplo:

// Resolva uma promessa.resolve ('valor resolvido'); // rejeitar uma promessa.rejeitar ('razão para rejeitar'); 

Conclusões

Neste tutorial, aprendemos a conhecer e usar promessas em JavaScript. Vimos como podemos construir nossas próprias promessas, quais são os métodos associados
com uma promessa, e como podemos usá -lo para gerenciar o código assíncrono, como uma alternativa mais limpa aos retornos de chamada. Uma fonte válida para aumentar ainda mais
Seu conhecimento de promessas é o fornecido por Mozilla.
No próximo tutorial JavaScript, aprenderemos a usar Funções de seta. Fique ligado no LinuxConfig.org!

Tutoriais do Linux relacionados:

• Como construir um aplicativo Tknter usando um objeto orientado…
• Tutorial de depuração do GDB para iniciantes
• Como trabalhar com a API de Rest WooCommerce com Python
• Expressões regulares do Python com exemplos
• Bash Regex avançado com exemplos
• Mastering Bash Script Loops
• Loops aninhados em scripts de basquete
• Como configurar um servidor OpenVPN no Ubuntu 20.04
• Instale Arch Linux na estação de trabalho VMware
• Bash Loops com exemplos