Repository navigation
Promisification - #471
Promisification#471
Conversation
| ``` | ||
|
|
||
| As you can see it's essentially the same as above, but `resolve` is called with only one or all arguments depending on whether `manyArgs` is truthy. | ||
| Como você pode ver, é essencialmente o mesmo que acima, mas o `resolve` é chamado com apenas um ou com todos os argumentos, dependendo se `manyArgs` é verdadeiro. |
There was a problem hiding this comment.
O original diz truthy, não true. "dependendo se manyArgs é verdadeiro" pode levar o leitor a achar que só o booleano true ativa o modo de vários resultados, mas qualquer valor truthy (1, "sim", etc.) também ativa. O resto do tutorial traduz como "valor verdadeiro".
| Como você pode ver, é essencialmente o mesmo que acima, mas o `resolve` é chamado com apenas um ou com todos os argumentos, dependendo se `manyArgs` é verdadeiro. | |
| Como você pode ver, é essencialmente o mesmo que acima, mas o `resolve` é chamado com apenas um ou com todos os argumentos, dependendo se `manyArgs` tem um valor verdadeiro. |
| ``` | ||
|
|
||
| The function loads a script with the given `src`, and then calls `callback(err)` in case of an error, or `callback(null, script)` in case of successful loading. That's a widespread agreement for using callbacks, we saw it before. | ||
| A função carrega um script com o `src` fornecido, e então chama `callback(err)` em caso de erro, ou `callback(null, script)` em caso de carregamento bem-sucedido. Esse é um acordo bastante difundido para usar callbacks, já vimos isso antes. |
There was a problem hiding this comment.
"widespread agreement" aqui significa convenção. "acordo bastante difundido" é uma tradução literal e soa estranho. O capítulo info:callbacks (01-callbacks, linha 193) já chama isso de "convenção".
| A função carrega um script com o `src` fornecido, e então chama `callback(err)` em caso de erro, ou `callback(null, script)` em caso de carregamento bem-sucedido. Esse é um acordo bastante difundido para usar callbacks, já vimos isso antes. | |
| A função carrega um script com o `src` fornecido, e então chama `callback(err)` em caso de erro, ou `callback(null, script)` em caso de carregamento bem-sucedido. Essa é uma convenção bastante difundida para usar callbacks, já vimos isso antes. |
| # Promisificação | ||
|
|
||
| "Promisification" is a long word for a simple transformation. It's the conversion of a function that accepts a callback into a function that returns a promise. | ||
| "Promisificação" é uma palavra longa para uma transformação simples. É a conversão de uma função que aceita um callback em uma função que retorna uma promessa. |
There was a problem hiding this comment.
Terminologia inconsistente com os capítulos vizinhos: este artigo usa "promessa", mas 02-promise-basics, 04-promise-error-handling, 05-promise-api, 07-microtask-queue e 08-async-await usam "promise" (só 03-promise-chaining usa "promessa"). Quem lê a seção em sequência vai ver o termo mudar de capítulo para capítulo. Vale escolher um termo para a seção inteira.
| Mas e se o `f` original espera um callback com mais argumentos `callback(err, res1, res2, ...)`? | ||
|
|
||
| We can improve our helper. Let's make a more advanced version of `promisify`. | ||
| Podemos melhorar nosso auxiliar. Vamos fazer uma versão mais avançada do `promisify`. |
There was a problem hiding this comment.
"nosso auxiliar" fica sem substantivo e muda o gênero: na linha 53 é "uma função auxiliar" e na 55 "Vamos chamá-la" (feminino).
| Podemos melhorar nosso auxiliar. Vamos fazer uma versão mais avançada do `promisify`. | |
| Podemos melhorar nossa função auxiliar. Vamos fazer uma versão mais avançada do `promisify`. |
| ``` | ||
|
|
||
| As we can see, the new function is a wrapper around the original `loadScript` function. It calls it providing its own callback that translates to promise `resolve/reject`. | ||
| Como podemos ver, a nova função é um invólucro ao redor da função original `loadScript`. Ela a chama fornecendo seu próprio callback que traduz para `resolve/reject` da promessa. |
There was a problem hiding this comment.
"seu próprio callback que traduz para resolve/reject da promessa" fica ambíguo e soa estranho em português (o callback traduz o quê?). O sentido é que o callback converte o resultado em resolve/reject.
| Como podemos ver, a nova função é um invólucro ao redor da função original `loadScript`. Ela a chama fornecendo seu próprio callback que traduz para `resolve/reject` da promessa. | |
| Como podemos ver, a nova função é um invólucro ao redor da função original `loadScript`. Ela a chama fornecendo seu próprio callback, que converte o resultado em `resolve/reject` da promessa. |
| Aqui, o `promisify` assume que a função original espera um callback com exatamente dois argumentos `(err, result)`. Isso é o que encontramos com mais frequência. Então nosso callback personalizado está exatamente no formato certo, e o `promisify` funciona ótimo para esse caso. | ||
|
|
||
| But what if the original `f` expects a callback with more arguments `callback(err, res1, res2, ...)`? | ||
| Mas e se o `f` original espera um callback com mais argumentos `callback(err, res1, res2, ...)`? |
There was a problem hiding this comment.
Concordância verbal: depois de "e se" com ideia hipotética, o certo é o futuro do subjuntivo ("esperar").
| Mas e se o `f` original espera um callback com mais argumentos `callback(err, res1, res2, ...)`? | |
| Mas e se o `f` original esperar um callback com mais argumentos `callback(err, res1, res2, ...)`? |
| Uma chamada a `promisify(f)` retorna um invólucro ao redor de `f` `(*)`. Esse invólucro retorna uma promessa e encaminha a chamada para o `f` original, rastreando o resultado no callback personalizado `(**)`. | ||
|
|
||
| Here, `promisify` assumes that the original function expects a callback with exactly two arguments `(err, result)`. That's what we encounter most often. Then our custom callback is in exactly the right format, and `promisify` works great for such a case. | ||
| Aqui, o `promisify` assume que a função original espera um callback com exatamente dois argumentos `(err, result)`. Isso é o que encontramos com mais frequência. Então nosso callback personalizado está exatamente no formato certo, e o `promisify` funciona ótimo para esse caso. |
There was a problem hiding this comment.
"funciona ótimo" é coloquial demais, até para o tom informal do tutorial. "funciona muito bem" é mais natural.
| Aqui, o `promisify` assume que a função original espera um callback com exatamente dois argumentos `(err, result)`. Isso é o que encontramos com mais frequência. Então nosso callback personalizado está exatamente no formato certo, e o `promisify` funciona ótimo para esse caso. | |
| Aqui, o `promisify` assume que a função original espera um callback com exatamente dois argumentos `(err, result)`. Isso é o que encontramos com mais frequência. Então nosso callback personalizado está exatamente no formato certo, e o `promisify` funciona muito bem para esse caso. |
| - When called as `promisify(f)` it should work similar to the version above. | ||
| - When called as `promisify(f, true)`, it should return the promise that resolves with the array of callback results. That's exactly for callbacks with many arguments. | ||
| - Quando chamado como `promisify(f)`, deve funcionar parecido com a versão acima. | ||
| - Quando chamado como `promisify(f, true)`, deve retornar a promessa que é resolvida com o array dos resultados do callback. Isso é exatamente para callbacks com muitos argumentos. |
There was a problem hiding this comment.
CLAUDE.md (raiz do repo): "avoid using foreign words: Words like timer, loop, inline should be avoided." Aqui o texto mantém "array" (também na linha 95) e "callback" em todo o artigo. Se o projeto adotou esses termos como padrão, pode ignorar. Senão, use "vetor"/"lista" e "função de retorno".
|
Obrigado, @gabifs! Apliquei as correções: "verdadeiro"→"tem um valor verdadeiro" (truthy), "acordo"→"convenção", ambiguidade do callback que "traduz", concordância de gênero em "nossa função auxiliar", futuro do subjuntivo "esperar", e "funciona ótimo"→"funciona muito bem". Sobre a terminologia "promise"/"promessa": conferi de novo e todos os capítulos vizinhos (02, 04, 05, 07, 08) já foram corrigidos pra usar "promessa" de forma consistente nas revisões anteriores, então esse já está alinhado. "array"/"callback" mantive, já que são termos padrão usados em todo o tutorial. |
Tradução do artigo "Promisification" para o português.
Conforme comentado na #1.