From 68fc8e96a9629e73469ed457abd955e548ec670c Mon Sep 17 00:00:00 2001 From: Florian Merz Date: Thu, 11 Feb 2021 14:49:58 +0100 Subject: unslug pt-br: move --- .../web/javascript/reference/operators/index.html | 329 +++++++++++++++++++++ .../reference/operators/spread_syntax/index.html | 201 +++++++++++++ 2 files changed, 530 insertions(+) create mode 100644 files/pt-br/conflicting/web/javascript/reference/operators/index.html create mode 100644 files/pt-br/conflicting/web/javascript/reference/operators/spread_syntax/index.html (limited to 'files/pt-br/conflicting/web/javascript/reference/operators') diff --git a/files/pt-br/conflicting/web/javascript/reference/operators/index.html b/files/pt-br/conflicting/web/javascript/reference/operators/index.html new file mode 100644 index 0000000000..4ca87eaddd --- /dev/null +++ b/files/pt-br/conflicting/web/javascript/reference/operators/index.html @@ -0,0 +1,329 @@ +--- +title: Arithmetic operators +slug: Web/JavaScript/Reference/Operators/Arithmetic_Operators +tags: + - JavaScript + - Operadores +translation_of: Web/JavaScript/Reference/Operators +translation_of_original: Web/JavaScript/Reference/Operators/Arithmetic_Operators +--- +
{{jsSidebar("Operadores")}}
+ +

Operadores aritméticos tem valores numéricos (literais ou variáveis) como seus operadores e retornam um valor numérico único. Os operadores aritméticos padrões são adição (+), subtração (-), multiplicação (*), e divisão (/).

+ +

Adição (+)

+ +

O operador de adição produz a soma dos operadores numéricos ou a concatenação de strings.

+ +

Sintaxe

+ +
Operador: x + y
+
+ +

Exemplos

+ +
// Número + Número -> adição
+1 + 2 // 3
+
+// Booleano + Número -> adição
+true + 1 // 2
+
+// Booleano + Booleano -> adição
+false + false // 0
+
+// Número + String -> concatenação
+5 + "foo" // "5foo"
+
+// String + Booleano -> concatenação
+"foo" + false // "foofalse"
+
+// String + String -> concatenação
+"foo" + "bar" // "foobar"
+
+ +

Subtração (-)

+ +

O operador de subtração subtrai os dois operandos, produzindo sua diferença.

+ +

Sintaxe

+ +
Operador: x - y
+
+ +

Exemplos

+ +
5 - 3 // 2
+3 - 5 // -2
+"foo" - 3 // NaN
+ +

Divisão (/)

+ +

O operador de divisão produz o quociente de seus operandos onde o operando da esquerda é o dividendo e o da direita é o divisor.

+ +

Sintaxe

+ +
Operador: x / y
+
+ +

Exemplos

+ +
1 / 2      // retorna 0.5 em JavaScript
+1 / 2      // retorna 0 em Java
+// (nenhum dos números é explicitamente um número de ponto flutuante)
+
+1.0 / 2.0  // retorna 0.5 em JavaScript e Java
+
+2.0 / 0    // retorna Infinity em JavaScript
+2.0 / 0.0  // retorna Infinity também
+2.0 / -0.0 // retorna -Infinity em JavaScript
+ +

Multiplicação (*)

+ +

O operador de multiplicação produz o produto dos operandos.

+ +

Sintaxe

+ +
Operador: x * y
+
+ +

Exemplos

+ +
2 * 2 // 4
+-2 * 2 // -4
+Infinity * 0 // NaN
+Infinity * Infinity // Infinity
+"foo" * 2 // NaN
+
+ +

Módulo (%)

+ +

O operador de módulo retorna o primeiro operando módulo o segundo, isto é, var1 módulo var2, na sentença anterior, onde var1 e var 2 são variáveis. A função módulo é o resto inteiro da divisão de var1 por var2. Existe uma proposta de ter um operador real de módulo em uma versão futura do ECMAScript.

+ +

Sintaxe

+ +
Operador: var1 % var2
+
+ +

Examples

+ +
12 % 5 // 2
+-1 % 2 // -1
+NaN % 2 // NaN
+
+ +

Exponenciação (**)

+ +

O operador de exponenciação retorna o resultado do primeiro operando elevado ao segundo operando. É o mesmo que var1var2, onde var1 e var2 são variáveis. O operador de exponenciação é associativo à direita, ou seja, a ** b ** c é igual a a ** (b ** c).

+ +

Sintaxe

+ +
Operador: var1 ** var2
+
+ +

Notas

+ +

Em várias linguagens como PHP e Python e outras que tem o operador de exponenciação (**), a exponenciação tem prioridade do que operações unárias, como + e  -, mas tem algumas exceções. Por exemplo, no Bash o operador ** é definido por ter menos prioridade do que operadores unários. No JavaScript, é impossível escrever uma expressão de exponenciação ambígua, i.e. você não pode colocar um operador unário (+/-/~/!/delete/void/typeof) imediatamente antes do número base.

+ +
-2 ** 2;
+// 4 no Bash, -4 em outras linguagens.
+// Isso é inválido no JavaScript, pois a operação é ambígua.
+
+
+-(2 ** 2);
+// -4 no JavaScript e a intenção do autor não é ambígua.
+
+ +

Exemplos

+ +
2 ** 3 // 8
+3 ** 2 // 9
+3 ** 2.5 // 15.588457268119896
+10 ** -1 // 0.1
+NaN ** 2 // NaN
+
+2 ** 3 ** 2 // 512
+2 ** (3 ** 2) // 512
+(2 ** 3) ** 2 // 64
+
+ +

Para inverter o sinal do resultado de uma expressão de exponenciação:

+ +
-(2 ** 2) // -4
+
+ +

Para forçar a base de uma expressão de exponenciação para ser um número negativo:

+ +
(-2) ** 2 // 4
+
+ +
+

Nota: JavaScript também tem  um operador de lógica binária ^ (XOR). ** e ^ são diferentes (por exemplo : 2 ** 3 === 8 enquanto 2 ^ 3 === 1.)

+
+ +

Incremento (++)

+ +

O operador de incremento incrementa (adiciona um a) seu operando e retorna um valor;

+ + + +

Sintaxe

+ +
Operador: x++ or ++x
+
+ +

Exemplos

+ +
// Posfixo
+var x = 3;
+y = x++; // y = 3, x = 4
+
+// Prefixo
+var a = 2;
+b = ++a; // a = 3, b = 3
+
+ +

Decremento (--)

+ +

O operador de decremento decrementa (subtrai um de) seu operando e retorna um valor.

+ + + +

Sintaxe

+ +
Operador: x-- or --x
+
+ +

Exemplos

+ +
// Posfixo
+var x = 3;
+y = x--; // y = 3, x = 2
+
+// Prefixo
+var a = 2;
+b = --a; // a = 1, b = 1
+
+ +

Negação Unária (-)

+ +

O operador de negação unária precede seu operando e o nega.

+ +

Sintaxe

+ +
Operador: -x
+
+ +

Exemplos

+ +
var x = 3;
+y = -x; // y = -3, x = 3
+
+ +

Soma Unária (+)

+ +

O operador de soma unária precede seu operando e calcula para seu operando mas tenta convertê-lo para um número, caso ainda não o seja. Apesar da negação unária (-) também poder converter não-números, a soma unária é a forma mais rápida e a forma preferida de converter alguma coisa em um número, porque ele não realiza nenhuma outra operação no número. Ele pode converter strings que representam inteiros e ponto flutuante, bem como os valores de não-string true, false, e null. Inteiros em formato decimal e hexadecimal ("0x"-prefixado) são suportados. Números negativos são suportados (não os hexadecimais). Caso não possa analisar um determinado valor, o operador retornará NaN.

+ +

Sintaxe

+ +
Operador: +x
+
+ +

Exemplos

+ +
+3     // 3
++"3"   // 3
++true  // 1
++false // 0
++null  // 0
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
ECMAScript 1ª Edição.PadrãoDefinição inicial.
{{SpecName('ES5.1', '#sec-11.3')}}{{Spec2('ES5.1')}}Definido em várias seções da especificação: Operadores aditivos, Operadores Multiplicativos, Expressões Posfixas, Operadores Unários.
{{SpecName('ES6', '#sec-postfix-expressions')}}{{Spec2('ES6')}}Definido em várias seções da especificação: Operadores aditivos, Operadores Multiplicativos, Expressões Posfixas, Operadores Unários.
+ +

Compatibilidade com Navegadores

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Veja também

+ + diff --git a/files/pt-br/conflicting/web/javascript/reference/operators/spread_syntax/index.html b/files/pt-br/conflicting/web/javascript/reference/operators/spread_syntax/index.html new file mode 100644 index 0000000000..a877d131bc --- /dev/null +++ b/files/pt-br/conflicting/web/javascript/reference/operators/spread_syntax/index.html @@ -0,0 +1,201 @@ +--- +title: Spread operator +slug: Web/JavaScript/Reference/Operators/Spread_operator +tags: + - JavaScript + - Operador +translation_of: Web/JavaScript/Reference/Operators/Spread_syntax +translation_of_original: Web/JavaScript/Reference/Operators/Spread_operator +--- +
{{jsSidebar("Operators")}}
+ +

A sintaxe de propagação (Spread) permite que um objeto iterável, como um array ou string, seja expandida em locais onde zero ou mais argumentos (para chamadas de função) ou elementos (para literais de array) sejam esperados ou uma expressão de objeto seja expandida em locais onde zero ou mais pares de chave-valor (para literais de objeto) são esperados.

+ +

Sintaxe

+ +

Para chamadas de função:

+ +
minhaFuncao(...objIteravel);
+
+ +

Para array literais:

+ +
[...objIteravel, 4, 5, 6]
+ +

Desestruturação:

+ +
[a, b, ...objIteravel] = [1, 2, 3, 4, 5];
+ +

Exemplos

+ +

Uma melhor aplicação

+ +

Exemplo: é comum usar {{jsxref( "Function.prototype.apply")}} em casos onde você quer usar um array como argumentos em uma função.

+ +
function minhaFuncao(x, y, z) { }
+var args = [0, 1, 2];
+minhaFuncao.apply(null, args);
+ +

Com o spread do ES2015 você pode agora escrever isso acima como:

+ +
function minhaFuncao(x, y, z) { }
+var args = [0, 1, 2];
+minhaFuncao(...args);
+ +

Qualquer argumento na lista de argumento pode usar a sintaxe spread e pode ser usado várias vezes.

+ +
function minhaFuncao(v, w, x, y, z) { }
+var args = [0, 1];
+minhaFuncao(-1, ...args, 2, ...[3]);
+ +

Um literal array mais poderoso

+ +

Exemplo:  Hoje se você tiver um array e quer criar um novo array com esse existente fazendo parte dele, a sintaxe literal do array não é mais suficiente e você deve voltar para o código imperativo, usando uma combinação de push, splice, concat, etc. Com a sintaxe spread isso se torna muito mais sucinto:

+ +
var partes = ['ombros', 'joelhos'];
+var letra = ['cabeca', ...partes, 'e', 'dedos']; // ["cabeca", "ombros", "joelhos", "e", "dedos"]
+
+ +

Assim como em spread para listas de argumentos ... pode ser usado em qualquer lugar no literal do array e pode ser usado várias vezes.

+ +

Apply para new

+ +

Exemplo: No ES5 não é possível usar new com apply. (Em ES5 termos, apply faz uma [[Call]] e nao um [[Construct]].) Em ES2015 a sintaxe spread naturalmente suporta isso:

+ +
var camposData = lerCamposData(bancoDeDados);
+var d = new Date(...camposData);
+ +

Um push melhor

+ +

Exemplo: {{jsxref("Global_Objects/Array/push", "push")}} é frequentemente usado para adicionar um array no final de um array existente. No ES5 isso é geralmente feito assim:

+ +
var arr1 = [0, 1, 2];
+var arr2 = [3, 4, 5];
+// Acrescenta todos itens do arr2 ao arr1
+Array.prototype.push.apply(arr1, arr2);
+ +

No ES2015 com spread isso se torna:

+ +
var arr1 = [0, 1, 2];
+var arr2 = [3, 4, 5];
+arr1.push(...arr2);
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES2015', '#sec-array-initializer')}}{{Spec2('ES2015')}}Definido em várias seções da especificação: Inicializador do array, Listas de argumento
{{SpecName('ESDraft', '#sec-array-initializer')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidade com browser

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari (WebKit)
Operação spread em array literais{{CompatChrome("46")}}{{ CompatGeckoDesktop("16") }}{{CompatNo}}{{CompatNo}}7.1
Operação spread em chamadas de função{{CompatChrome("46")}}{{ CompatGeckoDesktop("27") }}{{CompatNo}}{{CompatNo}}7.1
Operação spread em desestruturação{{CompatNo}}{{ CompatGeckoDesktop("34") }}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidAndroid WebviewFirefox Mobile (Gecko)IE MobileOpera MobileSafari MobileChrome for Android
Operação spread em array literais{{CompatNo}}{{CompatChrome("46")}}{{ CompatGeckoMobile("16") }}{{CompatNo}}{{CompatNo}}8{{CompatChrome("46")}}
Operação spread em chamadas de função{{CompatNo}}{{CompatChrome("46")}}{{ CompatGeckoMobile("27") }}{{CompatNo}}{{CompatNo}}8{{CompatChrome("46")}}
Operação spread em desestruturação{{CompatNo}}{{CompatNo}}{{ CompatGeckoDesktop("34") }}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatNo}}
+
+ +

Veja também

+ + -- cgit v1.2.3-54-g00ecf