From c77fadf8bb30d7f4be0d25265ab7694001325b71 Mon Sep 17 00:00:00 2001 From: Fabio Tavares Oliveira Date: Sat, 18 Jul 2020 11:31:27 -0300 Subject: [PATCH 01/10] Update article.md --- 1-js/06-advanced-functions/07-new-function/article.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/1-js/06-advanced-functions/07-new-function/article.md b/1-js/06-advanced-functions/07-new-function/article.md index e0750e321..97a617531 100644 --- a/1-js/06-advanced-functions/07-new-function/article.md +++ b/1-js/06-advanced-functions/07-new-function/article.md @@ -1,17 +1,17 @@ -# The "new Function" syntax +# A sintaxe de "new Function" -There's one more way to create a function. It's rarely used, but sometimes there's no alternative. +Existe mais uma maneira de criar uma funcção. Ela é raramente usada, mas as vezes não existe alternativas. -## Syntax +## Sintaxe -The syntax for creating a function: +A sintaxe para criar uma função: ```js let func = new Function ([arg1[, arg2[, ...argN]],] functionBody) ``` -In other words, function parameters (or, more precisely, names for them) go first, and the body is last. All arguments are strings. +Em outras palavras, os parâmetros da função (ou, mais precisamente, os nomes deles) vêm primeiro, e o corpo da função vem por último. Todos os argumentos são `strings`. It's easier to understand by looking at an example. Here's a function with two arguments: From 1d7566f393e18554e13d6294a338c4f25d0df7da Mon Sep 17 00:00:00 2001 From: Fabio Tavares Oliveira Date: Sat, 18 Jul 2020 12:10:34 -0300 Subject: [PATCH 02/10] Update article.md --- .../07-new-function/article.md | 30 +++++++++---------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/1-js/06-advanced-functions/07-new-function/article.md b/1-js/06-advanced-functions/07-new-function/article.md index 97a617531..d8a4a3df4 100644 --- a/1-js/06-advanced-functions/07-new-function/article.md +++ b/1-js/06-advanced-functions/07-new-function/article.md @@ -13,7 +13,7 @@ let func = new Function ([arg1[, arg2[, ...argN]],] functionBody) Em outras palavras, os parâmetros da função (ou, mais precisamente, os nomes deles) vêm primeiro, e o corpo da função vem por último. Todos os argumentos são `strings`. -It's easier to understand by looking at an example. Here's a function with two arguments: +É mais de compreender olhando um exemplo. Aqui está uma função com dois argumentos: ```js run let sum = new Function('a', 'b', 'return a + b'); @@ -21,34 +21,34 @@ let sum = new Function('a', 'b', 'return a + b'); alert( sum(1, 2) ); // 3 ``` -If there are no arguments, then there's only a single argument, the function body: +Se não existem argumentos, então somente existe um único argumento, que é o corpo da função: ```js run -let sayHi = new Function('alert("Hello")'); +let sayHi = new Function('alert("Olá")'); -sayHi(); // Hello +sayHi(); // Olá ``` -The major difference from other ways we've seen is that the function is created literally from a string, that is passed at run time. +A maior diferença de outros métodos vistos é que a função é literalmente criada a partir de uma `string`, que é passada em tempo de execução. -All previous declarations required us, programmers, to write the function code in the script. +Todas as declarações anteriores requeriam de nós, programadores, escrever o código da função dentro do `script`. -But `new Function` allows to turn any string into a function. For example, we can receive a new function from a server and then execute it: +Mas `new Function` permite transformar qualquer `string` em uma função. Por exemplo, nós podemos receber uma nova função de um servidor e executa-la: ```js -let str = ... receive the code from a server dynamically ... +let str = ... recebe o código de um servidor dinamicamente ... let func = new Function(str); func(); ``` -It is used in very specific cases, like when we receive code from a server, or to dynamically compile a function from a template. The need for that usually arises at advanced stages of development. +Ela é usada em casos muito específicos, como quando nós recebemos código de um servidor, ou para compilar dinamicamente a função a partir de um template. A necessidade disso geralmente surge em estágios avançados de desenvolvimento. ## Closure -Usually, a function remembers where it was born in the special property `[[Environment]]`. It references the Lexical Environment from where it's created. +No geral, uma função se "lembra" de onde ela foi criada na propiedade especial `[[Environment]]`. Ela referencia o escopo léxico de onde ela foi criada. -But when a function is created using `new Function`, its `[[Environment]]` references not the current Lexical Environment, but instead the global one. +Porém quando uma função é criada usando `new Function`, a sua `[[Environment]]` não referencia o atual escopo léxico, mas sim o escopo global. ```js run @@ -62,10 +62,10 @@ function getFunc() { return func; } -getFunc()(); // error: value is not defined +getFunc()(); // erro: value não foi definido ``` -Compare it with the regular behavior: +Compare-a com o comportamento padrão: ```js run function getFunc() { @@ -78,10 +78,10 @@ function getFunc() { return func; } -getFunc()(); // *!*"test"*/!*, from the Lexical Environment of getFunc +getFunc()(); // *!*"test"*/!*, do escopo léxico de getFunc ``` -This special feature of `new Function` looks strange, but appears very useful in practice. +Essa caracteristica especial de `new Function` parece estranha, mas se apresenta muito útil na prática. Imagine that we must create a function from a string. The code of that function is not known at the time of writing the script (that's why we don't use regular functions), but will be known in the process of execution. We may receive it from the server or from another source. From 23be3842ad96e74cbf29b990a4dc28d061f261da Mon Sep 17 00:00:00 2001 From: Fabio Tavares Oliveira Date: Sat, 18 Jul 2020 12:11:02 -0300 Subject: [PATCH 03/10] Update article.md --- 1-js/06-advanced-functions/07-new-function/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/06-advanced-functions/07-new-function/article.md b/1-js/06-advanced-functions/07-new-function/article.md index d8a4a3df4..63dc325c1 100644 --- a/1-js/06-advanced-functions/07-new-function/article.md +++ b/1-js/06-advanced-functions/07-new-function/article.md @@ -1,7 +1,7 @@ # A sintaxe de "new Function" -Existe mais uma maneira de criar uma funcção. Ela é raramente usada, mas as vezes não existe alternativas. +Existe mais uma maneira de criar uma função. Ela é raramente usada, mas as vezes não existem alternativas. ## Sintaxe From 9cb9ff6a8ef5be48b054df23f964b49476cfa626 Mon Sep 17 00:00:00 2001 From: Fabio Tavares Oliveira Date: Sat, 18 Jul 2020 18:34:46 -0300 Subject: [PATCH 04/10] Update article.md --- .../07-new-function/article.md | 42 +++++++++---------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/1-js/06-advanced-functions/07-new-function/article.md b/1-js/06-advanced-functions/07-new-function/article.md index 63dc325c1..f708bca66 100644 --- a/1-js/06-advanced-functions/07-new-function/article.md +++ b/1-js/06-advanced-functions/07-new-function/article.md @@ -13,7 +13,7 @@ let func = new Function ([arg1[, arg2[, ...argN]],] functionBody) Em outras palavras, os parâmetros da função (ou, mais precisamente, os nomes deles) vêm primeiro, e o corpo da função vem por último. Todos os argumentos são `strings`. -É mais de compreender olhando um exemplo. Aqui está uma função com dois argumentos: +É mais fácil de compreender olhando um exemplo. Aqui está uma função com dois argumentos: ```js run let sum = new Function('a', 'b', 'return a + b'); @@ -42,7 +42,7 @@ let func = new Function(str); func(); ``` -Ela é usada em casos muito específicos, como quando nós recebemos código de um servidor, ou para compilar dinamicamente a função a partir de um template. A necessidade disso geralmente surge em estágios avançados de desenvolvimento. +Ela é usada em casos muito específicos, como quando nós recebemos código de um servidor, ou para compilar dinamicamente a função a partir de um `template`. A necessidade disso geralmente surge em estágios avançados de desenvolvimento. ## Closure @@ -83,25 +83,25 @@ getFunc()(); // *!*"test"*/!*, do escopo léxico de getFunc Essa caracteristica especial de `new Function` parece estranha, mas se apresenta muito útil na prática. -Imagine that we must create a function from a string. The code of that function is not known at the time of writing the script (that's why we don't use regular functions), but will be known in the process of execution. We may receive it from the server or from another source. +Imagine que nós precisamos criar uma função a partir de uma `string`. O código dessa função é desconhecida durante a escrita do script (por esse motivo nós não usamos funções regulares), mas vai ser conhecido durante o processo de execução. Nós podemos recebe-la do servidor ou de outra fonte. -Our new function needs to interact with the main script. +Nossa nova função precisa interagir com o `script` principal. -Perhaps we want it to be able to access outer local variables? +Talvez nós queremos que ela consiga acessar variáveis locias externas? -The problem is that before JavaScript is published to production, it's compressed using a *minifier* -- a special program that shrinks code by removing extra comments, spaces and -- what's important, renames local variables into shorter ones. +O Problema é que antes do JavaScript ser publicado para produção, ele é comprimido usando um *minificador* -- um programa especial que encolhe código removendo comentários, espaços e -- o mais importante, renomeia variáveis locais em variáveis mais curtas. -For instance, if a function has `let userName`, minifier replaces it `let a` (or another letter if this one is occupied), and does it everywhere. That's usually a safe thing to do, because the variable is local, nothing outside the function can access it. And inside the function, minifier replaces every mention of it. Minifiers are smart, they analyze the code structure, so they don't break anything. They're not just a dumb find-and-replace. +Por exemplo, se uma função tem `let userName`, o minificador o troca por `let a` (ou outra letra se esta estiver ocupada), e ele faz isso em toda parte. Isso usualmente é uma coisa segura de se fazer, porque a variável é local, nada fora da função pode acessar ela. E dentro da função, o minificador troca todas as suas menções. Minificadores são inteligentes, eles analisam a estrutura do código, para que eles não quebrem nada. Eles não são um simples "encontra-e-repõem". -But, if `new Function` could access outer variables, then it would be unable to find `userName`, since this is passed in as a string *after* the code is minified. +Entretanto, se `new Function` pudesse acessar variáveis externas, então ele não conseguiria encontrar `userName`, pois ele é passado como uma string *depois* que o código é minificado. -**Even if we could access outer lexical environment in `new Function`, we would have problems with minifiers.** +**Mesmo se nós pudessemos acessar o escopo léxico externo na `new Function`, nós teriamos problemas com minificadores.** -The "special feature" of `new Function` saves us from mistakes. +A "característica especial" de `new Function` nos salva de erros. -And it enforces better code. If we need to pass something to a function created by `new Function`, we should pass it explicitly as an argument. +E ela assegura um código melhor. Se nós precisarmos passar algo para uma função criada por `new Function`, nós devemos passar ele explicitamente como um argumento. -Our "sum" function actually does that right: +A nossa função "sum" faz isso corretamente: ```js run *!* @@ -111,27 +111,27 @@ let sum = new Function('a', 'b', 'return a + b'); let a = 1, b = 2; *!* -// outer values are passed as arguments +// variáveis externas são passdas como argumentos alert( sum(a, b) ); // 3 */!* ``` -## Summary +## Resumo -The syntax: +A sintaxe: ```js let func = new Function(arg1, arg2, ..., body); ``` -For historical reasons, arguments can also be given as a comma-separated list. +Por razões históricas, arguments can also be given as a comma-separated list. -These three mean the same: +Estes três significam o mesmo: ```js -new Function('a', 'b', 'return a + b'); // basic syntax -new Function('a,b', 'return a + b'); // comma-separated -new Function('a , b', 'return a + b'); // comma-separated with spaces +new Function('a', 'b', 'return a + b'); // sintaxe básica +new Function('a,b', 'return a + b'); // separada por vírgula +new Function('a , b', 'return a + b'); // separada por vírgula com espaços ``` -Functions created with `new Function`, have `[[Environment]]` referencing the global Lexical Environment, not the outer one. Hence, they cannot use outer variables. But that's actually good, because it saves us from errors. Passing parameters explicitly is a much better method architecturally and causes no problems with minifiers. +Funções criadas com `new Function`, têm `[[Environment]]` referenciando o escopo léxico global, e não o escopo externo. Por isso, elas não podem usar variáveis externas. Porém isso na verdade é bom, porque isto nos salva de erros. Passar parametros explicitamente é um método muito melhor arquiteturamente e não causa problemas com minificadores. From 805791da59ace2fb363c9a718a02faf36ccee908 Mon Sep 17 00:00:00 2001 From: Fabio Tavares Oliveira Date: Sat, 18 Jul 2020 18:50:32 -0300 Subject: [PATCH 05/10] Update article.md --- 1-js/06-advanced-functions/07-new-function/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/06-advanced-functions/07-new-function/article.md b/1-js/06-advanced-functions/07-new-function/article.md index f708bca66..debc0e98a 100644 --- a/1-js/06-advanced-functions/07-new-function/article.md +++ b/1-js/06-advanced-functions/07-new-function/article.md @@ -46,7 +46,7 @@ Ela é usada em casos muito específicos, como quando nós recebemos código de ## Closure -No geral, uma função se "lembra" de onde ela foi criada na propiedade especial `[[Environment]]`. Ela referencia o escopo léxico de onde ela foi criada. +No geral, uma função se "lembra" de onde ela foi criada na propriedade especial `[[Environment]]`. Ela referencia o escopo léxico de onde ela foi criada. Porém quando uma função é criada usando `new Function`, a sua `[[Environment]]` não referencia o atual escopo léxico, mas sim o escopo global. From 168a08a2d583d3885c4b4e55e36f4ac49e09f91e Mon Sep 17 00:00:00 2001 From: Fabio Tavares Oliveira Date: Sat, 18 Jul 2020 19:05:25 -0300 Subject: [PATCH 06/10] Update article.md --- 1-js/06-advanced-functions/07-new-function/article.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/1-js/06-advanced-functions/07-new-function/article.md b/1-js/06-advanced-functions/07-new-function/article.md index debc0e98a..02c7c6c8d 100644 --- a/1-js/06-advanced-functions/07-new-function/article.md +++ b/1-js/06-advanced-functions/07-new-function/article.md @@ -83,13 +83,13 @@ getFunc()(); // *!*"test"*/!*, do escopo léxico de getFunc Essa caracteristica especial de `new Function` parece estranha, mas se apresenta muito útil na prática. -Imagine que nós precisamos criar uma função a partir de uma `string`. O código dessa função é desconhecida durante a escrita do script (por esse motivo nós não usamos funções regulares), mas vai ser conhecido durante o processo de execução. Nós podemos recebe-la do servidor ou de outra fonte. +Imagine que nós precisamos criar uma função a partir de uma `string`. O código dessa função é desconhecido durante a escrita do script (por esse motivo nós não usamos funções regulares), mas vai ser conhecido durante o processo de execução. Nós podemos recebe-lo do servidor ou de outra fonte. Nossa nova função precisa interagir com o `script` principal. Talvez nós queremos que ela consiga acessar variáveis locias externas? -O Problema é que antes do JavaScript ser publicado para produção, ele é comprimido usando um *minificador* -- um programa especial que encolhe código removendo comentários, espaços e -- o mais importante, renomeia variáveis locais em variáveis mais curtas. +O problema é que antes do JavaScript ser publicado para produção, ele é comprimido usando um *minificador* -- um programa especial que encolhe código removendo comentários, espaços e -- o mais importante, renomeia variáveis locais em variáveis mais curtas. Por exemplo, se uma função tem `let userName`, o minificador o troca por `let a` (ou outra letra se esta estiver ocupada), e ele faz isso em toda parte. Isso usualmente é uma coisa segura de se fazer, porque a variável é local, nada fora da função pode acessar ela. E dentro da função, o minificador troca todas as suas menções. Minificadores são inteligentes, eles analisam a estrutura do código, para que eles não quebrem nada. Eles não são um simples "encontra-e-repõem". From 96568bf7c639c379c97832298023340c182b3ad5 Mon Sep 17 00:00:00 2001 From: Fabio Tavares Oliveira Date: Sat, 18 Jul 2020 19:07:36 -0300 Subject: [PATCH 07/10] Update article.md --- 1-js/06-advanced-functions/07-new-function/article.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/1-js/06-advanced-functions/07-new-function/article.md b/1-js/06-advanced-functions/07-new-function/article.md index 02c7c6c8d..ddb1741d2 100644 --- a/1-js/06-advanced-functions/07-new-function/article.md +++ b/1-js/06-advanced-functions/07-new-function/article.md @@ -53,7 +53,7 @@ Porém quando uma função é criada usando `new Function`, a sua `[[Environment ```js run function getFunc() { - let value = "test"; + let value = "teste"; *!* let func = new Function('alert(value)'); @@ -69,7 +69,7 @@ Compare-a com o comportamento padrão: ```js run function getFunc() { - let value = "test"; + let value = "teste"; *!* let func = function() { alert(value); }; @@ -78,7 +78,7 @@ function getFunc() { return func; } -getFunc()(); // *!*"test"*/!*, do escopo léxico de getFunc +getFunc()(); // *!*"teste"*/!*, do escopo léxico de getFunc ``` Essa caracteristica especial de `new Function` parece estranha, mas se apresenta muito útil na prática. From c5b63ba621c4d0facf9292e62c8b1e1102d38da5 Mon Sep 17 00:00:00 2001 From: Fabio Tavares Oliveira Date: Sat, 18 Jul 2020 19:25:22 -0300 Subject: [PATCH 08/10] Update article.md --- .../07-new-function/article.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/1-js/06-advanced-functions/07-new-function/article.md b/1-js/06-advanced-functions/07-new-function/article.md index ddb1741d2..42dadae70 100644 --- a/1-js/06-advanced-functions/07-new-function/article.md +++ b/1-js/06-advanced-functions/07-new-function/article.md @@ -31,7 +31,7 @@ sayHi(); // Olá A maior diferença de outros métodos vistos é que a função é literalmente criada a partir de uma `string`, que é passada em tempo de execução. -Todas as declarações anteriores requeriam de nós, programadores, escrever o código da função dentro do `script`. +Todas as declarações anteriores requeriam de nós, programadores, escrever o código da função dentro do *script*. Mas `new Function` permite transformar qualquer `string` em uma função. Por exemplo, nós podemos receber uma nova função de um servidor e executa-la: @@ -42,7 +42,7 @@ let func = new Function(str); func(); ``` -Ela é usada em casos muito específicos, como quando nós recebemos código de um servidor, ou para compilar dinamicamente a função a partir de um `template`. A necessidade disso geralmente surge em estágios avançados de desenvolvimento. +Ela é usada em casos muito específicos, como quando nós recebemos código de um servidor, ou para compilar dinamicamente a função a partir de um *template*. A necessidade disso geralmente surge em estágios avançados de desenvolvimento. ## Closure @@ -83,17 +83,17 @@ getFunc()(); // *!*"teste"*/!*, do escopo léxico de getFunc Essa caracteristica especial de `new Function` parece estranha, mas se apresenta muito útil na prática. -Imagine que nós precisamos criar uma função a partir de uma `string`. O código dessa função é desconhecido durante a escrita do script (por esse motivo nós não usamos funções regulares), mas vai ser conhecido durante o processo de execução. Nós podemos recebe-lo do servidor ou de outra fonte. +Imagine que nós precisamos criar uma função a partir de uma `string`. O código dessa função é desconhecido durante a escrita do *script* (por esse motivo nós não usamos funções regulares), mas vai ser conhecido durante o processo de execução. Nós podemos recebe-lo do servidor ou de outra fonte. -Nossa nova função precisa interagir com o `script` principal. +Nossa nova função precisa interagir com o *script* principal. Talvez nós queremos que ela consiga acessar variáveis locias externas? -O problema é que antes do JavaScript ser publicado para produção, ele é comprimido usando um *minificador* -- um programa especial que encolhe código removendo comentários, espaços e -- o mais importante, renomeia variáveis locais em variáveis mais curtas. +O problema é que antes do JavaScript ser publicado para produção, ele é comprimido usando um "minificador" -- um programa especial que encolhe código removendo comentários, espaços e -- o mais importante, renomeia variáveis locais em variáveis mais curtas. Por exemplo, se uma função tem `let userName`, o minificador o troca por `let a` (ou outra letra se esta estiver ocupada), e ele faz isso em toda parte. Isso usualmente é uma coisa segura de se fazer, porque a variável é local, nada fora da função pode acessar ela. E dentro da função, o minificador troca todas as suas menções. Minificadores são inteligentes, eles analisam a estrutura do código, para que eles não quebrem nada. Eles não são um simples "encontra-e-repõem". -Entretanto, se `new Function` pudesse acessar variáveis externas, então ele não conseguiria encontrar `userName`, pois ele é passado como uma string *depois* que o código é minificado. +Entretanto, se `new Function` pudesse acessar variáveis externas, então ele não conseguiria encontrar `userName`, pois ele é passado como uma string **depois** que o código é minificado. **Mesmo se nós pudessemos acessar o escopo léxico externo na `new Function`, nós teriamos problemas com minificadores.** @@ -124,7 +124,7 @@ A sintaxe: let func = new Function(arg1, arg2, ..., body); ``` -Por razões históricas, arguments can also be given as a comma-separated list. +Por razões históricas, argumentos também podem ser dados como uma lista separada por vírgulas. Estes três significam o mesmo: From 77ae7ca039b079fabbac363e123d06a3f5ee0201 Mon Sep 17 00:00:00 2001 From: Fabio Tavares Oliveira Date: Sat, 18 Jul 2020 19:36:19 -0300 Subject: [PATCH 09/10] Update article.md --- 1-js/06-advanced-functions/07-new-function/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/06-advanced-functions/07-new-function/article.md b/1-js/06-advanced-functions/07-new-function/article.md index 42dadae70..8b5cc5d67 100644 --- a/1-js/06-advanced-functions/07-new-function/article.md +++ b/1-js/06-advanced-functions/07-new-function/article.md @@ -93,7 +93,7 @@ O problema é que antes do JavaScript ser publicado para produção, ele é comp Por exemplo, se uma função tem `let userName`, o minificador o troca por `let a` (ou outra letra se esta estiver ocupada), e ele faz isso em toda parte. Isso usualmente é uma coisa segura de se fazer, porque a variável é local, nada fora da função pode acessar ela. E dentro da função, o minificador troca todas as suas menções. Minificadores são inteligentes, eles analisam a estrutura do código, para que eles não quebrem nada. Eles não são um simples "encontra-e-repõem". -Entretanto, se `new Function` pudesse acessar variáveis externas, então ele não conseguiria encontrar `userName`, pois ele é passado como uma string **depois** que o código é minificado. +Entretanto, se `new Function` pudesse acessar variáveis externas, então ele não conseguiria encontrar `userName`, pois ele é passado como uma `string` **depois** que o código é minificado. **Mesmo se nós pudessemos acessar o escopo léxico externo na `new Function`, nós teriamos problemas com minificadores.** From 8c915f899cd960f944738249666a5314b72d375b Mon Sep 17 00:00:00 2001 From: Jonnathan Santos Date: Sun, 5 May 2024 11:49:40 -0300 Subject: [PATCH 10/10] refactor: corrects syntax and concordance errors --- .../07-new-function/article.md | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/1-js/06-advanced-functions/07-new-function/article.md b/1-js/06-advanced-functions/07-new-function/article.md index 76ea55246..41c5704ab 100644 --- a/1-js/06-advanced-functions/07-new-function/article.md +++ b/1-js/06-advanced-functions/07-new-function/article.md @@ -1,7 +1,7 @@ # A sintaxe de "new Function" -Existe mais uma maneira de criar uma função. Ela é raramente usada, mas as vezes não existem alternativas. +Existe mais uma maneira de criar uma função. Ela é raramente usada, mas às vezes não existem alternativas. ## Sintaxe @@ -29,7 +29,7 @@ let sayHi = new Function('alert("Olá")'); sayHi(); // Olá ``` -A principal diferença de outras formas que vimos é que a função é criada literalmente a partir de uma string, que é passada em tempo de execução. +A principal diferença de outras formas que vimos é a função ser criada literalmente a partir de uma string, e passada em tempo de execução. Todas as declarações anteriores requeriam de nós, programadores, escrever o código da função dentro do *script*. @@ -46,7 +46,7 @@ func(); ## Closure -Normalmente, uma função lembra onde nasceu na propriedade especial `[[Environment]]`. Ele faz referência ao Ambiente Lexical de onde foi criado (abordaremos isso no capítulo ). +Normalmente, uma função lembra onde nasceu na propriedade especial `[[Environment]]`. Ela faz referência ao Ambiente Lexical de onde foi criado (abordaremos isso no capítulo ). Mas quando uma função é criada usando `new Function`, seu `[[Environment]]` é definido para fazer referência não ao Ambiente Lexical atual, mas ao ambiente global. @@ -82,25 +82,25 @@ function getFunc() { getFunc()(); // *!*"teste"*/!*, do escopo léxico de getFunc ``` -Essa caracteristica especial de `new Function` parece estranha, mas se apresenta muito útil na prática. +Essa característica especial de `new Function` parece estranha, mas se apresenta muito útil, na prática. -Imagine que nós precisamos criar uma função a partir de uma `string`. O código dessa função é desconhecido durante a escrita do *script* (por esse motivo nós não usamos funções regulares), mas vai ser conhecido durante o processo de execução. Nós podemos recebe-lo do servidor ou de outra fonte. +Imagine que nós precisamos criar uma função a partir de uma `string`. O código dessa função é desconhecido durante a escrita do *script* (por esse motivo, nós não usamos funções regulares), mas vai ser conhecido durante o processo de execução. Nós podemos receber do servidor ou de outra fonte. Nossa nova função precisa interagir com o *script* principal. E se você pudesse acessar as variáveis ​​externas? -O problema é que antes do JavaScript ser publicado para produção, ele é comprimido usando um "minificador" -- um programa especial que encolhe código removendo comentários, espaços e -- o mais importante, renomeia variáveis locais em variáveis mais curtas. +O problema é que antes de o JavaScript ser publicado para produção, ele é comprimido usando um "minificador" -- um programa especial que encolhe código removendo comentários, espaços e -- o mais importante, renomeia variáveis locais em variáveis mais curtas. -Por exemplo, se uma função tem `let userName`, o minificador o troca por `let a` (ou outra letra se esta estiver ocupada), e ele faz isso em toda parte. Isso usualmente é uma coisa segura de se fazer, porque a variável é local, nada fora da função pode acessar ela. E dentro da função, o minificador troca todas as suas menções. Minificadores são inteligentes, eles analisam a estrutura do código, para que eles não quebrem nada. Eles não são um simples não-inteligente "encontra-e-substitui". +Por exemplo, se uma função tem uma variável `let userName`, o minificador a troca por `let a` (ou outra letra se esta estiver ocupada), e ele faz isso em toda parte. Isso usualmente é uma coisa segura de se fazer, por a variável ser local, nada fora da função pode acessar ela. E dentro da função, o minificador troca todas as suas menções. Minificadores são inteligentes, eles analisam a estrutura do código, para que eles não quebrem nada. Eles não são um simples não-inteligente "encontra-e-substitui". Portanto, se `new Function` tivesse acesso a variáveis ​​externas, não seria possível encontrar `userName` renomeado. -**Se a `nova Função` tivesse acesso a variáveis ​​externas, haveria problemas com minificadores.** +**Se a `new Function` tivesse acesso a variáveis ​​externas, haveria problemas com minificadores.** Além disso, esse código seria arquitetonicamente ruim e sujeito a erros. -Para passar algo para uma função, criada como `nova Função`, devemos usar seus argumentos. +Para passar algo para uma função, criada como `new Function`, devemos usar seus argumentos. ## Resumo