gaspersic/freeCodeCamp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Update portuguese translation (#28823)

Browse Source 
The name of "Promise" was translated to portuguese, "Promessa", but since it's a name, it should reamin the original name.
Some code examples had been changed. I returned to the original, and only translated the comments.
This commit is contained in:
Bruno Alves da Silva
2019-08-16 13:26:30 -03:00
committed by Randell Dawson
parent 8e1970ce85
commit f2ac393c47
1 changed files with 69 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

139
guide/portuguese/javascript/await-promises/index.md
View File

@ -1,100 +1,98 @@
--- ---
title: Await Promises title: Await Promises
localeTitle: Aguardar Promessas localeTitle: Await Promises
--- ---
## Aguardar Promessas ## Await Promises
Os [operadores](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators) `async` / `await` facilitam a implementação de muitas promessas assíncronas. Eles também permitem que os engenheiros escrevam códigos mais claros, mais sucintos e testáveis. Os [operadores](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators) `async` / `await` facilitam a implementação de muitas `Promises` assíncronas. Eles também permitem que os engenheiros escrevam códigos mais claros, mais sucintos e testáveis.
Para entender esse assunto, você deve ter uma compreensão sólida de como as [Promessas](https://guide.freecodecamp.org/javascript/promises) funcionam. Para entender esse assunto, você deve ter uma compreensão sólida de como as [Promises](https://guide.freecodecamp.org/javascript/promises) funcionam.
* * * * * *
## Sintaxe Básica ## Sintaxe Básica
```javascript ``` javascript
function slowlyResolvedPromiseFunc (string) { function slowlyResolvedPromiseFunc(string) {
return new Promise (resolve => { return new Promise(resolve => {
setTimeout (() => { resolver (string); }, 5000); setTimeout(() => {
}); resolve(string);
}, 5000);
});
} }
função assíncrona doIt () { async function doIt() {
const myPromise = aguardar lentamenteResolvedPromiseFunc ("foo"); const myPromise = await slowlyResolvedPromiseFunc("foo");
console.log (myPromise); // "foo" console.log(myPromise); // "foo"
} }
faça(); doIt();
``` ```
Há outras coisas para se prestar atenção: Há outras coisas para se prestar atenção:
* A função que contém alguma declaração de `await` precisa incluir o operador `async` em sua declaração. Isso irá dizer ao interpretador JS para que ele espere até que a `Promise` seja resolvida ou rejeitada. * A função que contém alguma declaração de `await` precisa incluir o operador `async` em sua declaração. Isso irá dizer ao interpretador JS para que ele espere até que a `Promise` seja resolvida ou rejeitada.
* O operador `await` precisa ser declarado inline. * O operador `await` precisa ser declarado inline, durante a declaração da `const`.
* `const something = await thisReturnsAPromise()`
* Isso funciona tanto para a rejeição ou a resolução de uma `Promise`. * Isso funciona tanto para a rejeição ou a resolução de uma `Promise`.
--- ---
## Promises aninhadas vs. `Async` / `Await` ## Promises aninhadas vs. `Async` / `Await`
Implementar uma unica promise é muito facil. Por outro lado promises aninhadas ou a criação de uma "dependency pattern" pode produzir um código spagetti. Implementar uma unica Promise é muito fácil. Por outro lado Promises aninhadas ou a criação de uma "dependency pattern" pode produzir um "código spagetti".
Os exemplos a seguir assumem que <a href='https://github.com/request/request-promise' target='_blank' rel='nofollow'>`request-promise`</a> está disponível como `rp`. Os exemplos a seguir assumem que <a href='https://github.com/request/request-promise' target='_blank' rel='nofollow'>`request-promise`</a> está disponível como `rp`.
### Promises encadeadas/aninhadas ### Promises encadeadas/aninhadas
```js
// Primeira Promisse ``` javascript
// Primeira Promise
const fooPromise = rp("http://domain.com/foo"); const fooPromise = rp("http://domain.com/foo");
fooPromise.then(resultFoo => { fooPromise.then(resultFoo => {
// deve esperar por "foo" para resolver // Deve aguardar por "foo" para resolver
console.log (resultFoo); console.log(resultFoo);
})
``` const barPromise = rp("http://domain.com/bar");
```js const bazPromise = rp("http://domain.com/baz");
const barPromise = rp("http://domain.com/bar");
const bazPromise = rp("http://domain.com/baz"); return Promise.all([barPromise, bazPromise]);
}).then(resultArr => {
Promise.all([barPromise, bazPromise]) // Lidar com as resoluções "bar" e "baz" aqui
.then(resultArr => { console.log(resultArr[0]);
// Lidar com as resoluções "bar" e "baz" aqui console.log(resultArr[1]);
console.log(resultArr [0]);
console.log(resultArr [1]);
}); });
``` ```
### `async` and `await` Promises
```js
// Enrole tudo em uma função assíncrona função assíncrona
async doItAll () {
// Pega dados do ponto de extremidade "foo", mas aguarde a resolução
console.log (await rp("http://domain.com/foo"));
// Concorrência aconteceConcurrently kick off the next two async calls,
// não espere por "bar" para disparar "baz"
const barPromise = rp("http://domain.com/bar");
const bazPromise = rp("http://domain.com/baz");
// Depois que as duas foram disparadas, espere pelas duas ### `async` e `await` Promises
const barResponse = await barPromise;
const bazResponse = await bazPromise; ``` javascript
// Envolva tudo em uma função assíncrona (async)
console.log(barResponse); async function doItAll() {
console.log(bazResponse); // Pega os dados do ponto final "foo", mas aguarda a resolução
console.log(await rp("http://domain.com/foo"));
// Ao mesmo tempo, inicie as próximas duas chamadas assíncronas,
// Não espera por "bar" para disparar "baz"
const barPromise = rp("http://domain.com/bar");
const bazPromise = rp("http://domain.com/baz");
// Depois que as duas foram disparadas, espere pelas duas
const barResponse = await barPromise;
const bazResponse = await bazPromise;
console.log(barResponse);
console.log(bazResponse);
} }
// Finalmente, chame a função assíncrona
doItAll().then(() => console.log('Done!'));
``` ```
```js As vantagens de usar `async` e `await` devem estar bem claras. O código é mais modular, testavel e legível.
// Finalmente, invoque a função assíncrona
doItAll().then(() => console.log ('Feito!'));
```
As vantagens de usar `async` e `await` deve estar claro. O codigo é mais modular, testavel e legível.
Entretanto há um senso de concorrencia, os processos computacionais que ocorrem são os mesmos do exemplo anterior. É justo notar que, embora exista uma sensação adicional de simultaneidade, os processos computacionais que ocorrem são os mesmos do exemplo anterior.
--- ---
@ -102,20 +100,21 @@ Entretanto há um senso de concorrencia, os processos computacionais que ocorrem
Um bloco `try-catch` consegue lidar com rejeição de promises. Um bloco `try-catch` consegue lidar com rejeição de promises.
```js ``` javascript
async errorExample () { async function errorExample() {
try { try {
const rejectedPromise = await Promise.reject ("Oh-oh!"); const rejectedPromise = await Promise.reject("Oh-oh!");
} catch (erro) { } catch (error) {
console.log (erro); console.log(error); // "Uh-oh!"
} }
}
errorExample (); errorExample();
``` ```
* * * ---
#### Mais Informações: ### Mais informação:
* `await` Operador [MDN Docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/await) * Operador `await` <a href='https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Operators/await' target='_blank' rel='nofollow'>MDN Docs</a>
* [Documentos do MDN do](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/async_function) operador de funções `async` * Função `async` <a href='https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Operators/async_function' target='_blank' rel=''nofollow'>MDN Docs</a>