From 181b543e8b301b611df2ecdea96fc5001912a975 Mon Sep 17 00:00:00 2001 From: Osvaldo Dias dos Santos Date: Wed, 27 May 2020 00:18:13 +0100 Subject: [PATCH 1/4] Update formatting --- .../18-javascript-specials/article.md | 126 +++++++++--------- 1 file changed, 63 insertions(+), 63 deletions(-) diff --git a/1-js/02-first-steps/18-javascript-specials/article.md b/1-js/02-first-steps/18-javascript-specials/article.md index cdd0ab8d5..aaf7d5684 100644 --- a/1-js/02-first-steps/18-javascript-specials/article.md +++ b/1-js/02-first-steps/18-javascript-specials/article.md @@ -7,22 +7,22 @@ Este capítulo brevemente revê as funcionalidades de JavaScript que aprendemos Instruções são delimitadas por ponto-e-vírgula: ```js run no-beautify -alert('Olá'); alert('Mundo'); + alert('Olá'); alert('Mundo'); ``` Geralmente, uma quebra de linha é também tratada como um delimitador, assim o acima também funcionaria como: ```js run no-beautify -alert('Olá') -alert('Mundo') + alert('Olá') + alert('Mundo') ``` Isto chama-se "inserção automática de ponto-e-vírgula". Por vezes, não funciona, a exemplo: ```js run -alert("Haverá um erro depois desta mensagem") + alert("Haverá um erro depois desta mensagem") -[1, 2].forEach(alert) + [1, 2].forEach(alert) ``` A maioria dos guias de estilo-de-código concorda que deveríamos colocar um ponto-e-vírgula após cada instrução. @@ -30,13 +30,13 @@ A maioria dos guias de estilo-de-código concorda que deveríamos colocar um pon Pontos-e-vírgula não são necessários depois de blocos de código `{...}` e outras construções sintáticas que os utilizem, como laços (*loops*): ```js -function f() { - ... -} // nenhum ponto-e-vírgula necessário depois da declaração de função + function f() { + ... + } // nenhum ponto-e-vírgula necessário depois da declaração de função -for(;;) { - ... -} // nenhum ponto-e-vírgula necessário depois do laço + for(;;) { + ... + } // nenhum ponto-e-vírgula necessário depois do laço ``` ...Mas mesmo que coloquemos um ponto-e-vírgula "extra" algures, isso não é um erro. Será ignorado. @@ -48,9 +48,9 @@ Mais em: . Para activar completamente todas as funcionalidades do JavaScript moderno, devemos começar programas (*scripts*) com `"use strict"`. ```js -'use strict'; + 'use strict'; -... + ... ``` A diretiva deve estar no topo de um *script* ou no início de uma função. @@ -70,6 +70,7 @@ Podem ser declaradas usando: - `var` (estilo-antigo, veremos mais tarde) O nome de uma varável pode incluir: + - Letras e dígitos, mas o primeiro caráter não pode ser um dígito. - Carateres `$` e `_` são normais, *on par* às letras. - Alfabetos não-latinos e hieróglifos também são permitidos, mas geralmente não utilizados. @@ -77,8 +78,8 @@ O nome de uma varável pode incluir: Variáveis obtêm tipos dinâmicamente. Elas podem armazenar qualquer valor: ```js -let x = 5; -x = "John"; + let x = 5; + x = "John"; ``` Existem 7 tipos de dados: @@ -91,9 +92,10 @@ Existem 7 tipos de dados: - `object` and `symbol` -- para estruturas de dados complexas e identificadores únicos, que ainda não aprendemos. O operador `typeof` retorna o tipo de um valor, com duas exceções: + ```js -typeof null == "object" // erro da linguagem -typeof function(){} == "function" // funções são tratadas especialmente + typeof null == "object" // erro da linguagem + typeof function(){} == "function" // funções são tratadas especialmente ``` Mais em: e . @@ -116,11 +118,11 @@ Todas estas funções são *modal* (modais), elas suspendem o código em execuç Por exemplo: ```js run -let userName = prompt("Como se chama?", "Alice"); -let isTeaWanted = confirm("Quer chá?"); + let userName = prompt("Como se chama?", "Alice"); + let isTeaWanted = confirm("Quer chá?"); -alert( "Visitante: " + userName ); // Alice -alert( "Chá aceite: " + isTeaWanted ); // true + alert( "Visitante: " + userName ); // Alice + alert( "Chá aceite: " + isTeaWanted ); // true ``` Mais em: . @@ -132,12 +134,12 @@ JavaScript suporta os seguintes operadores: Aritmétricos : Regulares: `* + - /`, e também `%` para o resto de uma divisão inteira, e `**` para a potência de um número. - O operador binário mais `+` concatena *strings*. E se um dos operandos for uma *string*, o outro também é convertido para *string*: +O operador binário mais `+` concatena *strings*. E se um dos operandos for uma *string*, o outro também é convertido para *string*: - ```js run - alert( '1' + 2 ); // '12', *string* - alert( 1 + '2' ); // '12', *string* - ``` +```js run + alert( '1' + 2 ); // '12', *string* + alert( 1 + '2' ); // '12', *string* +``` De atribuição : Existe uma atribuição simples: `a = b` e combinadas como `a *= 2`. @@ -154,18 +156,18 @@ Lógicos Comparisons : O de verificação de igualdade `==` para valores de tipos diferentes, os converte para números (exceto `null` e `undefined` que igualam-se a si próprios, e a nada mais); assim os seguintes são similares: - ```js run - alert( 0 == false ); // verdadeiro - alert( 0 == '' ); // verdadeiro - ``` +```js run + alert( 0 == false ); // verdadeiro + alert( 0 == '' ); // verdadeiro +``` - Em outras comparações também são convertidos para números. +Em outras comparações também são convertidos para números. - O operador de igualdade exata (*strict equality*) `===` não executa a conversão; para ele com tipos diferentes sempre são valores diferentes, assim: +O operador de igualdade exata (*strict equality*) `===` não executa a conversão; para ele com tipos diferentes sempre são valores diferentes, assim: - Os valores `null` e `undefined` são especiais: eles são iguais `==` a si próprios e a mais nenhum outro. +Os valores `null` e `undefined` são especiais: eles são iguais `==` a si próprios e a mais nenhum outro. - Comparações maior/menor, comparam *strings* (cadeias-de-carateres) caráter-por-caráter, outros tipos são convertidos para número. +Comparações maior/menor, comparam *strings* (cadeias-de-carateres) caráter-por-caráter, outros tipos são convertidos para número. Outros operadores : Existem mais uns outros poucos, como o operador vírgula. @@ -177,20 +179,20 @@ Mais em: , , . - Vimos 3 tipos de laços: ```js - // 1 - while (condition) { - ... - } - - // 2 - do { - ... - } while (condition); - - // 3 - for(let i = 0; i < 10; i++) { - ... - } + // 1 + while (condition) { + ... + } + + // 2 + do { + ... + } while (condition); + + // 3 + for(let i = 0; i < 10; i++) { + ... + } ``` - A variável declarada no laço `for(let...)` apenas é visível dentro do laço. Mas também podemos omitir `let` e reusar uma variável já existente. @@ -207,19 +209,19 @@ A construção "*switch*" permite substituir múltiplas verificações `if`. Ela Por exemplo: ```js run -let age = prompt('Que idade tem?', 18); + let age = prompt('Que idade tem?', 18); -switch (age) { - case 18: - alert("Não funcionará"); // o resultado de *prompt* é uma *string*, não um número + switch (age) { + case 18: + alert("Não funcionará"); // o resultado de *prompt* é uma *string*, não um número - case "18": - alert("Isto funciona!"); - break; + case "18": + alert("Isto funciona!"); + break; - default: - alert("Qualquer valor não igual aos dos 'case' acima"); -} + default: + alert("Qualquer valor não igual aos dos 'case' acima"); + } ``` Detalhes em: . @@ -230,7 +232,7 @@ Vimos três formas de criar uma função em JavaScript: 1. Declaração de função: a função no fluxo principal do código - ```js + ```js function sum(a, b) { let result = a + b; @@ -240,7 +242,7 @@ Vimos três formas de criar uma função em JavaScript: 2. Expressão de função: a função no contexto de uma expressão - ```js + ```js let sum = function(a, b) { let result = a + b; @@ -252,7 +254,7 @@ Vimos três formas de criar uma função em JavaScript: 3. Arrow functions: - ```js + ```js // expressão no lado direito let sum = (a, b) => a + b; @@ -269,12 +271,10 @@ Vimos três formas de criar uma função em JavaScript: let double = n => n * 2; ``` - - Funções podem ter variáveis locais: aquelas declaradas no seu corpo. Tais variáveis apenas são visíveis dentro da função. - Parâmetros podem ter valores por defeito: `function sum(a = 1, b = 2) {...}`. - Funções sempre retornam algo. Se não houver uma instrução `return`, então o resultado é `undefined`. - | Declaração de Função | Expressão de Função | |----------------------|---------------------| | visível em todo o bloco de código | criada quando a execução a alcança | From 7c64346043dff4730a637362b07c48cf806cf368 Mon Sep 17 00:00:00 2001 From: Osvaldo Dias dos Santos Date: Tue, 8 Dec 2020 22:28:17 +0100 Subject: [PATCH 2/4] Update "JavaScript-specials" article. --- .../18-javascript-specials/article.md | 151 +++++++++--------- 1 file changed, 74 insertions(+), 77 deletions(-) diff --git a/1-js/02-first-steps/18-javascript-specials/article.md b/1-js/02-first-steps/18-javascript-specials/article.md index aaf7d5684..73f5ee0db 100644 --- a/1-js/02-first-steps/18-javascript-specials/article.md +++ b/1-js/02-first-steps/18-javascript-specials/article.md @@ -1,6 +1,6 @@ # Especiais em JavaScript -Este capítulo brevemente revê as funcionalidades de JavaScript que aprendemos até agora, dando atenção especial a momentos subtis. +Este capítulo brevemente revê as funcionalidades do JavaScript que aprendemos até agora, dando atenção especial a momentos subtis. ## Estrutura do código @@ -10,14 +10,14 @@ Instruções são delimitadas por ponto-e-vírgula: alert('Olá'); alert('Mundo'); ``` -Geralmente, uma quebra de linha é também tratada como um delimitador, assim o acima também funcionaria como: +Geralmente, uma quebra de linha também é tratada como um delimitador, então isto também iria resultar: ```js run no-beautify alert('Olá') alert('Mundo') ``` -Isto chama-se "inserção automática de ponto-e-vírgula". Por vezes, não funciona, a exemplo: +Isto chama-se de "inserção automática de ponto-e-vírgula". Por vezes, não funciona, como neste exemplo: ```js run alert("Haverá um erro depois desta mensagem") @@ -25,27 +25,27 @@ Isto chama-se "inserção automática de ponto-e-vírgula". Por vezes, não func [1, 2].forEach(alert) ``` -A maioria dos guias de estilo-de-código concorda que deveríamos colocar um ponto-e-vírgula após cada instrução. +A maioria dos guias de estilo-de-código concorda que deveríamos colocar um ponto-e-vírgula no final de cada instrução. -Pontos-e-vírgula não são necessários depois de blocos de código `{...}` e outras construções sintáticas que os utilizem, como laços (*loops*): +Pontos-e-vírgula não são necessários depois de blocos de código `{...}` e construções sintáticas que os utilizem, como *loops* (laços): ```js function f() { - ... - } // nenhum ponto-e-vírgula necessário depois da declaração de função + // nenhum ponto-e-vírgula é necessário depois da declaração de função + } for(;;) { - ... - } // nenhum ponto-e-vírgula necessário depois do laço + // nenhum ponto-e-vírgula é necessário depois do loop + } ``` -...Mas mesmo que coloquemos um ponto-e-vírgula "extra" algures, isso não é um erro. Será ignorado. +...Mas mesmo que coloquemos um ponto-e-vírgula "extra" em um lugar, isso não é um erro. Ele será ignorado. Mais em: . ## Modo *strict* -Para activar completamente todas as funcionalidades do JavaScript moderno, devemos começar programas (*scripts*) com `"use strict"`. +Para ativar completamente todas as funcionalidades do JavaScript moderno, devemos começar os programas (*scripts*) com `"use strict"`. ```js 'use strict'; @@ -53,11 +53,11 @@ Para activar completamente todas as funcionalidades do JavaScript moderno, devem ... ``` -A diretiva deve estar no topo de um *script* ou no início de uma função. +A diretiva deve estar no topo de um *script* ou no início do corpo de uma função. -Sem `"use strict"`, tudo ainda funciona, mas algumas funcionalidades comportam-se à forma antiga, no modo "compatível". Nós geralmente preferiríamos o comportamento moderno. +Sem `"use strict"`, tudo ainda funciona, mas algumas funcionalidades se comportam de maneira antiga, de uma forma "compatível". Nós geralmente iriamos preferir o comportamento moderno. -Algumas funcionalidades modernas da linguagem (como classes que estudaremos no futuro) ativam o modo *strict* implícitamente. +Algumas funcionalidades modernas da linguagem (como classes que iremos estudar no futuro) ativam o modo *strict* implícitamente. Mais em: . @@ -70,31 +70,30 @@ Podem ser declaradas usando: - `var` (estilo-antigo, veremos mais tarde) O nome de uma varável pode incluir: - -- Letras e dígitos, mas o primeiro caráter não pode ser um dígito. +- Letras e dígitos, mas o primeiro caractere não pode ser um dígito. - Carateres `$` e `_` são normais, *on par* às letras. - Alfabetos não-latinos e hieróglifos também são permitidos, mas geralmente não utilizados. -Variáveis obtêm tipos dinâmicamente. Elas podem armazenar qualquer valor: +Variáveis recebem os tipos dinâmicamente. Elas podem armazenar qualquer valor: ```js let x = 5; x = "John"; ``` -Existem 7 tipos de dados: +Existem 8 tipos de dados: -- `number` para números, quer inteiros (*integer*) como em ponto-flutuante (*floating-point*), +- `number` para números, tanto inteiros (*integer*) como em ponto-flutuante (*floating-point*), +- `bigint` para números inteiros com um comprimento arbitrário, - `string` para cadeias-de-carateres (*strings*), - `boolean` para valores lógicos: `true/false` (verdadeiro/falso), -- `null` -- um tipo de dados com apenas um valor `null`, significando "vazio" ou "não existe", -- `undefined` -- um tipo de dados com apenas um valor `undefined`, significando "não atribuido", -- `object` and `symbol` -- para estruturas de dados complexas e identificadores únicos, que ainda não aprendemos. +- `null` -- um tipo de dados com só um valor `null`, significando "vazio" ou "não existe", +- `undefined` -- um tipo de dados com só um valor `undefined`, significando "não atribuído", +- `object` e `symbol` -- para estruturas de dados complexas e identificadores únicos, mas ainda não aprendemos ambos. O operador `typeof` retorna o tipo de um valor, com duas exceções: - ```js - typeof null == "object" // erro da linguagem + typeof null == "object" // erro na linguagem typeof function(){} == "function" // funções são tratadas especialmente ``` @@ -102,92 +101,95 @@ Mais em: e . ## Interação -Estamos a utilizar um navegador (*browser*) como ambiente de trabalho, assim funções básicas de *UI* (Interface/interação com o Utilizador) serão: +Estamos a utilizar um navegador (*browser*) como ambiente de trabalho, assim funções básicas de *UI* (Interface com o Utilizador) serão: [`prompt(question, [default])`](mdn:api/Window/prompt) -: Faz uma `question`, e retorna o que o visitante inseriu ou `null` se a pessoa "cancelou". +: Faz uma `question`, e retorna o que o visitante inseriu ou `null` se a pessoa clicou em "cancel". [`confirm(question)`](mdn:api/Window/confirm) : Faz uma `question` e sugere que a pessoa escolha entre *Ok* e *Cancel*. A escolha é retornada como `true/false` (verdadeiro/falso). [`alert(message)`](mdn:api/Window/alert) -: Mostra `message`. +: Exibe uma `message`. -Todas estas funções são *modal* (modais), elas suspendem o código em execução e impedem o visitante de interagir com a página até obterem uma resposta. +Todas estas funções são *modais* (*modal*), elas fazem uma pausa no código em execução e impedem o visitante de interagir com a página até que ele responda. Por exemplo: ```js run let userName = prompt("Como se chama?", "Alice"); - let isTeaWanted = confirm("Quer chá?"); + let isTeaWanted = confirm("Quer um pouco de chá?"); alert( "Visitante: " + userName ); // Alice - alert( "Chá aceite: " + isTeaWanted ); // true + alert( "Quer chá: " + isTeaWanted ); // true ``` Mais em: . ## Operadores -JavaScript suporta os seguintes operadores: +O JavaScript suporta os seguintes operadores: -Aritmétricos +Aritméticos : Regulares: `* + - /`, e também `%` para o resto de uma divisão inteira, e `**` para a potência de um número. -O operador binário mais `+` concatena *strings*. E se um dos operandos for uma *string*, o outro também é convertido para *string*: + O operador binário mais `+` concatena *strings*. E se um dos operandos for uma *string*, o outro também é convertido para *string*: -```js run - alert( '1' + 2 ); // '12', *string* - alert( 1 + '2' ); // '12', *string* -``` + ```js run + alert( '1' + 2 ); // '12', *string* + alert( 1 + '2' ); // '12', *string* + ``` De atribuição -: Existe uma atribuição simples: `a = b` e combinadas como `a *= 2`. +: Existe uma atribuição simples: `a = b`, e combinadas como `a *= 2`. *Bit-a-bit* -: Operadores *bit-a-bit* (*bitwise operators*) trabalham com números inteiros ao nível do *bit*: veja em [docs](mdn:/JavaScript/Reference/Operators/Bitwise_Operators) quando são necessários. +: Operadores *bit-a-bit* (*bitwise operators*) trabalham com números inteiros de 32-bits no nível mais baixo, o do *bit*: veja em [docs](mdn:/JavaScript/Guide/Expressions_and_Operators#Bitwise) quando eles são necessários. -Ternários -: O único operador com três parâmetros: `condition ? resultA : resultB`. Se `condition` for verdadeira, retorna `resultA`, senão `resultB`. +Condicional +: O único operador com três parâmetros: `condition ? resultA : resultB`. Se `condition` for verdadeira, retorna `resultA`, senão o `resultB`. Lógicos -: Os lógicos *AND* (E) `&&` e OR (OU) `||` executam evaluação em curto-circuito (*short-circuit evaluation*) e depois retornam o valor em que pararam. O lógico *NOT* (NÃO) `!` converte o operando para o tipo boleano e retorna o valor inverso desse boleano. +: Os lógicos *AND* (E) `&&` e OR (OU) `||` executam uma avaliação em curto-circuito (*short-circuit evaluation*) e depois retornam o valor em que pararam (não necessáriamente `true`/`false`). O lógico *NOT* (NÃO) `!` converte o operando para o tipo booleano e retorna o inverso desse booleano. -Comparisons -: O de verificação de igualdade `==` para valores de tipos diferentes, os converte para números (exceto `null` e `undefined` que igualam-se a si próprios, e a nada mais); assim os seguintes são similares: +De coalescência nula (Nullish coalescing) +: O operador `??` dá uma forma de escolher um certo valor de uma lista de variáveis. O resultado de `a ?? b` é `a` se este não for `null/undefined`, mas se for então é `b`. -```js run - alert( 0 == false ); // verdadeiro - alert( 0 == '' ); // verdadeiro -``` +Comparações +: O de verificação de igualdade `==` para valores de tipos diferentes, os converte para números (exceto `null` e `undefined` que se igualam entre si, e a nada mais); assim os seguintes são similares: -Em outras comparações também são convertidos para números. + ```js run + alert( 0 == false ); // true (verdadeiro) + alert( 0 == '' ); // true (verdadeiro) + ``` + + Outras comparações também convertem para números. -O operador de igualdade exata (*strict equality*) `===` não executa a conversão; para ele com tipos diferentes sempre são valores diferentes, assim: + O operador de igualdade exata (*strict equality*) `===` não executa a conversão: para ele, tipos diferentes significam sempre valores diferentes. -Os valores `null` e `undefined` são especiais: eles são iguais `==` a si próprios e a mais nenhum outro. + Os valores `null` e `undefined` são especiais: eles são iguais `==` entre si e a mais nenhum outro. -Comparações maior/menor, comparam *strings* (cadeias-de-carateres) caráter-por-caráter, outros tipos são convertidos para número. + Comparações maior/menor, comparam *strings* caractere-por-caractere, mas outros tipos são convertidos para números. Outros operadores -: Existem mais uns outros poucos, como o operador vírgula. +: Existem mais uns poucos, como o operador vírgula. -Mais em: , , . +Mais em: , , , . -## Laços +## Loops -- Vimos 3 tipos de laços: +- Nós vimos 3 tipos de *loops* (laços): ```js // 1 - while (condition) { + while (condição) { ... } // 2 do { ... - } while (condition); + } while (condição); // 3 for(let i = 0; i < 10; i++) { @@ -195,12 +197,12 @@ Mais em: , , . } ``` -- A variável declarada no laço `for(let...)` apenas é visível dentro do laço. Mas também podemos omitir `let` e reusar uma variável já existente. -- As diretivas `break/continue` permitem sair completamente-do-laço/da-actual-iteração. Use etiquetas (*labels*) para sair (*break*) de laços aninhados (*nested loops*).. +- A variável declarada no ciclo (*loop*) `for(let...)` só é visível dentro do ciclo. Mas também podemos omitir `let` e re-usar uma variável já existente. +- As diretivas `break/continue` permitem sair completamente-do-laço/da-atual-iteração. Use etiquetas (*labels*) para sair (*break*) de laços aninhados (*nested loops*). Detalhes em: . -Mais adiante estudaremos outros tipos de laços para lidar com objetos. +Mais adiante estudaremos outros tipos de *loops* para lidar com objetos. ## A construção "*switch*" @@ -213,7 +215,8 @@ Por exemplo: switch (age) { case 18: - alert("Não funcionará"); // o resultado de *prompt* é uma *string*, não um número + alert("Não irá funcionar"); // o resultado de 'prompt' é uma 'string', não um número + break; case "18": alert("Isto funciona!"); @@ -228,7 +231,7 @@ Detalhes em: . ## Funções -Vimos três formas de criar uma função em JavaScript: +Vimos três formas para criar uma função em JavaScript: 1. Declaração de função: a função no fluxo principal do código @@ -238,7 +241,7 @@ Vimos três formas de criar uma função em JavaScript: return result; } - ``` + ``` 2. Expressão de função: a função no contexto de uma expressão @@ -248,11 +251,9 @@ Vimos três formas de criar uma função em JavaScript: return result; } - ``` + ``` - Expressões de função podem ter um nome, como `sum = function name(a, b)`, mas esse `name` apenas é visível dentro da função. - -3. Arrow functions: +3. Funções seta (*arrow functions*): ```js // expressão no lado direito @@ -269,19 +270,15 @@ Vimos três formas de criar uma função em JavaScript: // com um único argumento let double = n => n * 2; - ``` + ``` -- Funções podem ter variáveis locais: aquelas declaradas no seu corpo. Tais variáveis apenas são visíveis dentro da função. + +- Funções podem ter variáveis locais: aquelas declaradas no seu corpo. Tais variáveis só são visíveis dentro da função. - Parâmetros podem ter valores por defeito: `function sum(a = 1, b = 2) {...}`. - Funções sempre retornam algo. Se não houver uma instrução `return`, então o resultado é `undefined`. -| Declaração de Função | Expressão de Função | -|----------------------|---------------------| -| visível em todo o bloco de código | criada quando a execução a alcança | -| - | pode ter um nome, visível apenas dentro da função | - -Mais: veja , . +Detalhes: veja , . ## Mais adiante -Esta foi uma breve lista de funcionalidades de JavaScript. Até agora apenas estudámos o básico. Mais adiante no tutorial encontrará mais funcionalidades especiais e avançadas de JavaScript. +Esta foi uma breve lista de funcionalidades do JavaScript. Até agora apenas estudámos o básico. Mais adiante no tutorial você irá encontrar mais funcionalidades especiais e avançadas do JavaScript. From c495fb3d5672c17330abcd055b73993ecf8ef92e Mon Sep 17 00:00:00 2001 From: Osvaldo Dias dos Santos Date: Tue, 25 May 2021 20:41:49 +0100 Subject: [PATCH 3/4] Update translation. --- 1-js/02-first-steps/18-javascript-specials/article.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/1-js/02-first-steps/18-javascript-specials/article.md b/1-js/02-first-steps/18-javascript-specials/article.md index 5fe14644a..25356b0fe 100644 --- a/1-js/02-first-steps/18-javascript-specials/article.md +++ b/1-js/02-first-steps/18-javascript-specials/article.md @@ -45,7 +45,7 @@ Mais em: . ## Modo *strict* -Para ativar completamente todas as funcionalidades do JavaScript moderno, devemos começar os programas (*scripts*) com `"use strict"`. +Para ativar completamente todas as funcionalidades do JavaScript moderno, devemos começar os programas com `"use strict"`. ```js 'use strict'; @@ -53,7 +53,7 @@ Para ativar completamente todas as funcionalidades do JavaScript moderno, devemo ... ``` -A diretiva deve estar no topo de um *script* ou no início do corpo de uma função. +A diretiva deve estar no topo de um *script* (programa) ou no início do corpo de uma função. Sem `"use strict"`, tudo ainda funciona, mas algumas funcionalidades se comportam de maneira antiga, de uma forma "compatível". Nós geralmente iriamos preferir o comportamento moderno. From 4ef9d7c54cb94b8bd35dbecf2574b8d640ba083d Mon Sep 17 00:00:00 2001 From: Osvaldo Dias dos Santos Date: Mon, 23 Jan 2023 20:48:47 +0100 Subject: [PATCH 4/4] Update "JavaScript specials" translation links --- 1-js/02-first-steps/18-javascript-specials/article.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/1-js/02-first-steps/18-javascript-specials/article.md b/1-js/02-first-steps/18-javascript-specials/article.md index 0d9797574..4256f6595 100644 --- a/1-js/02-first-steps/18-javascript-specials/article.md +++ b/1-js/02-first-steps/18-javascript-specials/article.md @@ -103,13 +103,13 @@ Mais em: e . Estamos a utilizar um navegador (*browser*) como ambiente de trabalho, assim funções básicas de *UI* (Interface com o Utilizador) serão: -[`prompt(question, [default])`](mdn:api/Window/prompt) +[`prompt(question, [default])`](https://developer.mozilla.org/pt-BR/docs/Web/API/Window/prompt) : Faz uma `question`, e retorna o que o visitante inseriu ou `null` se a pessoa clicou em "cancel". -[`confirm(question)`](mdn:api/Window/confirm) +[`confirm(question)`](https://developer.mozilla.org/pt-BR/docs/Web/API/Window/confirm) : Faz uma `question` e sugere que a pessoa escolha entre *Ok* e *Cancel*. A escolha é retornada como `true/false` (verdadeiro/falso). -[`alert(message)`](mdn:api/Window/alert) +[`alert(message)`](https://developer.mozilla.org/pt-BR/docs/Web/API/Window/alert) : Exibe uma `message`. Todas estas funções são *modais* (*modal*), elas fazem uma pausa no código em execução e impedem o visitante de interagir com a página até que ele responda. @@ -144,7 +144,7 @@ De atribuição : Existe uma atribuição simples: `a = b`, e combinadas como `a *= 2`. *Bit-a-bit* -: Operadores *bit-a-bit* (*bitwise operators*) trabalham com números inteiros de 32-bits no nível mais baixo, o do *bit*: veja em [docs](mdn:/JavaScript/Guide/Expressions_and_Operators#Bitwise) quando eles são necessários. +: Operadores *bit-a-bit* (*bitwise operators*) trabalham com números inteiros de 32-bits no nível mais baixo, o do *bit*: veja em [docs](https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Expressions_and_Operators#operadores_bit_a_bit) quando eles são necessários. Condicional : O único operador com três parâmetros: `condition ? resultA : resultB`. Se `condition` for verdadeira, retorna `resultA`, senão o `resultB`.