diff options
| author | Florian Merz <me@fiji-flo.de> | 2021-02-11 14:49:58 +0100 |
|---|---|---|
| committer | Florian Merz <me@fiji-flo.de> | 2021-02-11 14:49:58 +0100 |
| commit | 68fc8e96a9629e73469ed457abd955e548ec670c (patch) | |
| tree | 8529ab9fe63d011f23c7f22ab5a4a1c5563fcaa4 /files/pt-br/web/javascript/reference/operators | |
| parent | 8260a606c143e6b55a467edf017a56bdcd6cba7e (diff) | |
| download | translated-content-68fc8e96a9629e73469ed457abd955e548ec670c.tar.gz translated-content-68fc8e96a9629e73469ed457abd955e548ec670c.tar.bz2 translated-content-68fc8e96a9629e73469ed457abd955e548ec670c.zip | |
unslug pt-br: move
Diffstat (limited to 'files/pt-br/web/javascript/reference/operators')
10 files changed, 0 insertions, 1683 deletions
diff --git a/files/pt-br/web/javascript/reference/operators/arithmetic_operators/index.html b/files/pt-br/web/javascript/reference/operators/arithmetic_operators/index.html deleted file mode 100644 index 4ca87eaddd..0000000000 --- a/files/pt-br/web/javascript/reference/operators/arithmetic_operators/index.html +++ /dev/null @@ -1,329 +0,0 @@ ---- -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 ---- -<div>{{jsSidebar("Operadores")}}</div> - -<p><strong>Operadores aritméticos</strong> 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 (/).</p> - -<h2 id="Adição_()"><a name="Addition">Adição (+)</a></h2> - -<p>O operador de adição produz a soma dos operadores numéricos ou a concatenação de strings.</p> - -<h3 id="Sintaxe">Sintaxe</h3> - -<pre class="syntaxbox"><strong>Operador:</strong> x + y -</pre> - -<h3 id="Exemplos">Exemplos</h3> - -<pre class="brush: js">// 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" -</pre> - -<h2 id="Subtração_(-)"><a name="Subtraction">Subtração (-)</a></h2> - -<p>O operador de subtração subtrai os dois operandos, produzindo sua diferença.</p> - -<h3 id="Sintaxe_2">Sintaxe</h3> - -<pre class="syntaxbox"><strong>Operador:</strong> x - y -</pre> - -<h3 id="Exemplos_2">Exemplos</h3> - -<pre class="brush: js">5 - 3 // 2 -3 - 5 // -2 -"foo" - 3 // NaN</pre> - -<h2 id="Divisão_()"><a name="Division">Divisão (/)</a></h2> - -<p>O operador de divisão produz o quociente de seus operandos onde o operando da esquerda é o dividendo e o da direita é o divisor.</p> - -<h3 id="Sintaxe_3">Sintaxe</h3> - -<pre class="syntaxbox"><strong>Operador:</strong> x / y -</pre> - -<h3 id="Exemplos_3">Exemplos</h3> - -<pre class="brush: js">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</pre> - -<h2 id="Multiplicação_(*)"><a name="Multiplication">Multiplicação (*)</a></h2> - -<p>O operador de multiplicação produz o produto dos operandos.</p> - -<h3 id="Sintaxe_4">Sintaxe</h3> - -<pre class="syntaxbox"><strong>Operador:</strong> x * y -</pre> - -<h3 id="Exemplos_4">Exemplos</h3> - -<pre class="brush: js">2 * 2 // 4 --2 * 2 // -4 -Infinity * 0 // NaN -Infinity * Infinity // Infinity -"foo" * 2 // NaN -</pre> - -<h2 id="Módulo_()"><a name="Remainder">Módulo (%)</a></h2> - -<p>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. <a href="http://wiki.ecmascript.org/doku.php?id=strawman:modulo_operator" title="http://wiki.ecmascript.org/doku.php?id=strawman:modulo_operator">Existe uma proposta de ter um operador real de módulo em uma versão futura do ECMAScript.</a></p> - -<h3 id="Sintaxe_5">Sintaxe</h3> - -<pre class="syntaxbox"><strong>Operador:</strong> var1 % var2 -</pre> - -<h3 id="Examples">Examples</h3> - -<pre class="brush: js">12 % 5 // 2 --1 % 2 // -1 -NaN % 2 // NaN -</pre> - -<h2 id="Exponenciação_(**)"><a id="Exponenciação" name="Exponenciação">Exponenciação (**)</a></h2> - -<p>O operador de exponenciação retorna o resultado do primeiro operando elevado ao segundo operando. É o mesmo que <code>var1</code><sup><code>var2</code></sup>, onde <code>var1</code> e <code>var2</code> são variáveis. O operador de exponenciação é associativo à direita, ou seja, <code>a ** b ** c</code> é igual a <code>a ** (b ** c)</code>.</p> - -<h3 id="Sintaxe_6">Sintaxe</h3> - -<pre><strong>Operador:</strong> var1 ** var2 -</pre> - -<h3 id="Notas">Notas</h3> - -<p>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 (<code>+/-/~/!/delete/void/typeof</code>) imediatamente antes do número base.</p> - -<pre>-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. -</pre> - -<h3 id="Exemplos_5">Exemplos</h3> - -<pre>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 -</pre> - -<p>Para inverter o sinal do resultado de uma expressão de exponenciação:</p> - -<pre>-(2 ** 2) // -4 -</pre> - -<p>Para forçar a base de uma expressão de exponenciação para ser um número negativo:</p> - -<pre>(-2) ** 2 // 4 -</pre> - -<div class="note"> -<p><strong>Nota:</strong> JavaScript também tem <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_XOR">um operador de lógica binária ^ (XOR)</a>. <code>**</code> e <code>^</code> são diferentes (por exemplo : <code>2 ** 3 === 8</code> enquanto <code>2 ^ 3 === 1</code>.)</p> -</div> - -<h2 id="Incremento_()"><a name="Increment">Incremento (++)</a></h2> - -<p>O operador de incremento incrementa (adiciona um a) seu operando e retorna um valor;</p> - -<ul> - <li>Se usado na forma posfixa, com o operador depois do operando (por exemplo, x++), então ele retorna o valor antes de incrementá-lo.</li> - <li>Se usado na forma prefixa, com o operador antes do operando (por exemplo, ++x), então ele retorna o valor depois de incrementá-lo.</li> -</ul> - -<h3 id="Sintaxe_7">Sintaxe</h3> - -<pre class="syntaxbox"><strong>Operador:</strong> x++ or ++x -</pre> - -<h3 id="Exemplos_6">Exemplos</h3> - -<pre class="brush: js">// Posfixo -var x = 3; -y = x++; // y = 3, x = 4 - -// Prefixo -var a = 2; -b = ++a; // a = 3, b = 3 -</pre> - -<h2 id="Decremento_(--)"><a name="Decrement">Decremento (--)</a></h2> - -<p>O operador de decremento decrementa (subtrai um de) seu operando e retorna um valor.</p> - -<ul> - <li>Se usado na forma posfixa (por exemplo, x--), então ele retorna o valor antes de decrementá-lo.</li> - <li>Se usado na forma prefixa (por exemplo, --x), então ele retorna o valor depois de decrementá-lo.</li> -</ul> - -<h3 id="Sintaxe_8">Sintaxe</h3> - -<pre class="syntaxbox"><strong>Operador:</strong> x-- or --x -</pre> - -<h3 id="Exemplos_7">Exemplos</h3> - -<pre class="brush: js">// Posfixo -var x = 3; -y = x--; // y = 3, x = 2 - -// Prefixo -var a = 2; -b = --a; // a = 1, b = 1 -</pre> - -<h2 id="Negação_Unária_(-)"><a name="Unary_negation">Negação Unária (-)</a></h2> - -<p>O operador de negação unária precede seu operando e o nega.</p> - -<h3 id="Sintaxe_9">Sintaxe</h3> - -<pre class="syntaxbox"><strong>Operador:</strong> -x -</pre> - -<h3 id="Exemplos_8">Exemplos</h3> - -<pre class="brush: js">var x = 3; -y = -x; // y = -3, x = 3 -</pre> - -<h2 id="Soma_Unária_()"><a name="Unary_plus">Soma Unária</a> (+)</h2> - -<p>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 <code>true</code>, <code>false</code>, e <code>null</code>. 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á <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN">NaN</a>.</p> - -<h3 id="Sintaxe_10">Sintaxe</h3> - -<pre class="syntaxbox"><strong>Operador:</strong> +x -</pre> - -<h3 id="Exemplos_9">Exemplos</h3> - -<pre class="brush: js">+3 // 3 -+"3" // 3 -+true // 1 -+false // 0 -+null // 0 -</pre> - -<h2 id="Especificações">Especificações</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Especificação</th> - <th scope="col">Status</th> - <th scope="col">Comentário</th> - </tr> - <tr> - <td>ECMAScript 1ª Edição.</td> - <td>Padrão</td> - <td>Definição inicial.</td> - </tr> - <tr> - <td>{{SpecName('ES5.1', '#sec-11.3')}}</td> - <td>{{Spec2('ES5.1')}}</td> - <td>Definido em várias seções da especificação: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.6">Operadores aditivos</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.5">Operadores Multiplicativos</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.3">Expressões Posfixas</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.4">Operadores Unários</a>.</td> - </tr> - <tr> - <td>{{SpecName('ES6', '#sec-postfix-expressions')}}</td> - <td>{{Spec2('ES6')}}</td> - <td>Definido em várias seções da especificação: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.6">Operadores aditivos</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.5">Operadores Multiplicativos</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.3">Expressões Posfixas</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.4">Operadores Unários</a>.</td> - </tr> - </tbody> -</table> - -<h2 id="Compatibilidade_com_Navegadores">Compatibilidade com Navegadores</h2> - -<p>{{CompatibilityTable}}</p> - -<div id="compat-desktop"> -<table class="compat-table"> - <tbody> - <tr> - <th>Feature</th> - <th>Chrome</th> - <th>Firefox (Gecko)</th> - <th>Internet Explorer</th> - <th>Opera</th> - <th>Safari</th> - </tr> - <tr> - <td>Basic support</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatVersionUnknown}}</td> - </tr> - </tbody> -</table> -</div> - -<div id="compat-mobile"> -<table class="compat-table"> - <tbody> - <tr> - <th>Feature</th> - <th>Android</th> - <th>Chrome for Android</th> - <th>Firefox Mobile (Gecko)</th> - <th>IE Mobile</th> - <th>Opera Mobile</th> - <th>Safari Mobile</th> - </tr> - <tr> - <td>Basic support</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatVersionUnknown}}</td> - </tr> - </tbody> -</table> -</div> - -<h2 id="Veja_também">Veja também</h2> - -<ul> - <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators">Operatores de atribuição</a></li> -</ul> diff --git a/files/pt-br/web/javascript/reference/operators/bitwise_operators/index.html b/files/pt-br/web/javascript/reference/operators/bitwise_operators/index.html deleted file mode 100644 index b8b2e654c4..0000000000 --- a/files/pt-br/web/javascript/reference/operators/bitwise_operators/index.html +++ /dev/null @@ -1,559 +0,0 @@ ---- -title: Bitwise operators -slug: Web/JavaScript/Reference/Operators/Bitwise_Operators -translation_of: Web/JavaScript/Reference/Operators -translation_of_original: Web/JavaScript/Reference/Operators/Bitwise_Operators ---- -<div>{{jsSidebar("Operators")}}</div> - -<div></div> - -<div>Operadores bit-a-bit são são operadores tratados como sequência de 32 bits ( zeros e uns ), preferencialmente como decimal, hexadecimal, ou números octais. Por exemplo, o número decimal 9 tinha como representação binária de 1001. Operadores bit-a-bit realizam as operações em tais representações binárias, mas retornam valores numéricos no padrão Javascript.</div> - -<div>{{EmbedInteractiveExample("pages/js/expressions-bitwiseoperators.html")}}</div> - -<p class="hidden">O código para este interactivo exemplo está armazenado em um repositório GitHub . Se você quiser contribuir para o projeto exemplo interativo, por favor clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e mande-nos um pull request.</p> - -<p>A seguinte tabela resume os Operadores bit-a-bit:</p> - -<table class="standard-table"> - <tbody> - <tr> - <th>Operador</th> - <th>Uso</th> - <th>Descrição</th> - </tr> - <tr> - <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#(Bitwise_AND)">Bitwise AND</a></td> - <td><code>a & b</code></td> - <td>Retorna <code>1</code> em cada posição de bit para à qual o bit correspondente de ambos eram <code>1</code>s.</td> - </tr> - <tr> - <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#(Bitwise_OR)">Bitwise OR</a></td> - <td><code>a | b</code></td> - <td> - <p>Retorna 1 para cada posição de bit para à qual o correspondente de um ou ambos eram <code>1</code>s.</p> - </td> - </tr> - <tr> - <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#(Bitwise_XOR)">Bitwise XOR</a></td> - <td><code>a ^ b</code></td> - <td>Retorna 1 para cada posição de bit para à qual o bit correspondente de um mas não ambos eram <code>1</code>s.</td> - </tr> - <tr> - <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#(Bitwise_NOT)">Bitwise NOT</a></td> - <td><code>~ a</code></td> - <td>Inverte os bits de seus operandos.</td> - </tr> - <tr> - <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#%3C%3C_(Left_shift)">Left shift</a></td> - <td><code>a << b</code></td> - <td>Jogam <code>a</code> em representação binária <code>b</code> (< 32) bits à esquerda, mudando de zeros à diretia.</td> - </tr> - <tr> - <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#%3E%3E_(Sign-propagating_right_shift)">Sign-propagating right shift</a></td> - <td><code>a >> b</code></td> - <td>Jogam <code>a</code> em representação binária <code>b</code> (< 32) bits à direita, descartando bits que foram tornados off.</td> - </tr> - <tr> - <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#%3E%3E%3E_(Zero-fill_right_shift)">Zero-fill right shift</a></td> - <td><code>a >>> b</code> </td> - <td>Jogam <code>a</code> em representação binária <code>b</code> (< 32) bits à direita, descartando bits que foram tornados off, e jogando <code>0</code>s para à esquerda.</td> - </tr> - </tbody> -</table> - -<h2 id="Inteiros_assinados_em_32-bit">Inteiros assinados em 32-bit</h2> - -<p>Os operandos de todos os operadores bit-a-bit são assinados como inteiros de 32-bit em duas formas complementares. Duas formas complementares significa que uma negativa contrapartida (e.g. 5 vs. -5) são todos os bits daqueles números invertidos (bit-a-bit NOT de um número, a.k.a. complementos de um número) mais um. Por example, os seguintes encodes inteiros são 314:</p> - -<pre class="brush: js">00000000000000000000000100111010 -</pre> - -<p>Os seguintes encodes <code>~314</code>, i.e. são os únicos complementos de <code>314</code>:</p> - -<pre class="brush: js">11111111111111111111111011000101 -</pre> - -<p>Finalmente, os seguintes encodes <code>-314,</code> i.e. são dois complementos de <code>314</code>:</p> - -<pre class="brush: js">11111111111111111111111011000110 -</pre> - -<p>As duas garantias complementares daquele bit mais à esquerda que é zero quando o número é positivo e 1 quando o número é negativo. Aliás, isto é chamado de <em>sign bit </em>ou <em>bit assinalado.</em></p> - -<p>O número 0 é o inteiro composto completamente de 0 bits.</p> - -<pre class="brush: js">0 (base 10) = 00000000000000000000000000000000 (base 2) -</pre> - -<p>O número <code>-1</code> é o inteiro que é composto completamente de 1 bits.</p> - -<pre class="brush: js">-1 (base 10) = 11111111111111111111111111111111 (base 2) -</pre> - -<p>O número <code>-2147483648</code> (representação hexadecimal: <code>-0x80000000</code>) é o inteiro completamente composto de 0 bits exceto o primeiro (left-most) único.</p> - -<pre class="brush: js">-2147483648 (base 10) = 10000000000000000000000000000000 (base 2) -</pre> - -<p>O número <code>2147483647</code> (representação hexadecimal: <code>0x7fffffff</code>) é o inteiro composto completamente por bits 1, exceto pelo primeiro (o mais à esquerda).</p> - -<pre class="brush: js">2147483647 (base 10) = 01111111111111111111111111111111 (base 2) -</pre> - -<p>Os números <code>-2147483648</code> e <code>2147483647</code> são, respectivamente, o minimo e o máximo inteiro representáveis atráves de um número de 32 bits assinados.</p> - -<h2 id="Operadores_lógico_bit-abit">Operadores lógico bit-abit</h2> - -<p>Conceitualmente, os operadores lógicos bit-abit funcionam da seguinte forma:</p> - -<ul> - <li>Os operandos são convertidos para inteiros de 32 bits e expressados em uma série de bits (zeros e ums). Números com mais de 32 bits têm seus bits mais significativos descartados. Por exemplo, o inteiro com mais de 32 bits a seguir será convertido para um inteiro de 32 bits: - <pre class="brush: js">Before: 11100110111110100000000000000110000000000001 -After: 10100000000000000110000000000001</pre> - </li> - <li>Cada bit no primeiro operando é pareado com o bit correspondente no segundo operando: primeiro bit para o primeiro bit, segundo bit para o segundo bit e assim por diante.</li> - <li>O operador é aplicado para cada par de bits e o resultado é construído bit a bit.</li> -</ul> - -<h3 id="(Bitwise_AND)"><a name="Bitwise_AND">& (Bitwise AND)</a></h3> - -<p>Performa a operação AND em cada par de bits. <code>a</code> AND <code>b</code> retorna 1, apenas quando <code>a</code> e <code>b</code> são <code>1</code>. A tabela verdade para a operação AND é:</p> - -<table class="standard-table"> - <tbody> - <tr> - <td class="header">a</td> - <td class="header">b</td> - <td class="header">a AND b</td> - </tr> - <tr> - <td>0</td> - <td>0</td> - <td>0</td> - </tr> - <tr> - <td>0</td> - <td>1</td> - <td>0</td> - </tr> - <tr> - <td>1</td> - <td>0</td> - <td>0</td> - </tr> - <tr> - <td>1</td> - <td>1</td> - <td>1</td> - </tr> - </tbody> -</table> - -<pre class="brush: js">. 9 (base 10) = 00000000000000000000000000001001 (base 2) - 14 (base 10) = 00000000000000000000000000001110 (base 2) - -------------------------------- -14 & 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10) -</pre> - -<p>Performar a operação AND bit-a-bit de qualquer número <code>x</code> com <code>0</code> retornará <code>0</code>. Performar a operação AND bit-a-bit de qualquer número <code>x</code> com <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">-1</span></font> retornará <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">x</span></font>.</p> - -<h3 id="(Bitwise_OR)"><a name="Bitwise_OR">| (Bitwise OR)</a></h3> - -<p>Performa a operação OR em cada par de bits. <code>a</code> OR <code>b</code> retorna 1 se pelo menos <code>a</code> ou pelo menos <code>b</code> é <code>1</code>. As tabela versão para a operação <code>OR</code> é:</p> - -<table class="standard-table"> - <tbody> - <tr> - <td class="header">a</td> - <td class="header">b</td> - <td class="header">a OR b</td> - </tr> - <tr> - <td>0</td> - <td>0</td> - <td>0</td> - </tr> - <tr> - <td>0</td> - <td>1</td> - <td>1</td> - </tr> - <tr> - <td>1</td> - <td>0</td> - <td>1</td> - </tr> - <tr> - <td>1</td> - <td>1</td> - <td>1</td> - </tr> - </tbody> -</table> - -<pre class="brush: js">. 9 (base 10) = 00000000000000000000000000001001 (base 2) - 14 (base 10) = 00000000000000000000000000001110 (base 2) - -------------------------------- -14 | 9 (base 10) = 00000000000000000000000000001111 (base 2) = 15 (base 10) -</pre> - -<p>Performar a operação <code>OR</code> de qulalquer número <code>x</code> com <code>0</code> retornará <code>0</code>. Performar a operação <code>OR</code> de qualquer número <code>X</code> com <code>-1</code> retornará <code>-1</code>.</p> - -<h3 id="(Bitwise_XOR)"><a name="Bitwise_XOR">^ (Bitwise XOR)</a></h3> - -<p>Performs the XOR operation on each pair of bits. <code>a</code> XOR <code>b</code> yields 1 if <code>a</code> and <code>b</code> are different. The truth table for the <code>XOR</code> operation is:</p> - -<table class="standard-table"> - <tbody> - <tr> - <td class="header">a</td> - <td class="header">b</td> - <td class="header">a XOR b</td> - </tr> - <tr> - <td>0</td> - <td>0</td> - <td>0</td> - </tr> - <tr> - <td>0</td> - <td>1</td> - <td>1</td> - </tr> - <tr> - <td>1</td> - <td>0</td> - <td>1</td> - </tr> - <tr> - <td>1</td> - <td>1</td> - <td>0</td> - </tr> - </tbody> -</table> - -<pre class="brush: js">. 9 (base 10) = 00000000000000000000000000001001 (base 2) - 14 (base 10) = 00000000000000000000000000001110 (base 2) - -------------------------------- -14 ^ 9 (base 10) = 00000000000000000000000000000111 (base 2) = 7 (base 10) -</pre> - -<p>Bitwise XORing any number <code>x</code> with <code>0</code> yields x. Bitwise XORing any number <code>x</code> with <code>-1</code> yields <code>~x</code>.</p> - -<h3 id="(Bitwise_NOT)"><a name="Bitwise_NOT">~ (Bitwise NOT)</a></h3> - -<p>Performs the NOT operator on each bit. NOT <code>a</code> yields the inverted value (a.k.a. one's complement) of <code>a</code>. The truth table for the <code>NOT</code> operation is:</p> - -<table class="standard-table"> - <tbody> - <tr> - <td class="header">a</td> - <td class="header">NOT a</td> - </tr> - <tr> - <td>0</td> - <td>1</td> - </tr> - <tr> - <td>1</td> - <td>0</td> - </tr> - </tbody> -</table> - -<pre class="brush: js"> 9 (base 10) = 00000000000000000000000000001001 (base 2) - -------------------------------- -~9 (base 10) = 11111111111111111111111111110110 (base 2) = -10 (base 10) -</pre> - -<p>Bitwise NOTing any number <code>x</code> yields <code>-(x + 1)</code>. For example, <code>~-5</code> yields <code>4</code>.</p> - -<p>Note that due to using 32-bit representation for numbers both <code>~-1</code> and <code>~4294967295</code> (2<sup>32</sup>-1) results in <code>0</code>.</p> - -<h2 id="Operadores_de_deslocamento_bit_a_bit">Operadores de deslocamento bit a bit</h2> - -<p>The bitwise shift operators take two operands: the first is a quantity to be shifted, and the second specifies the number of bit positions by which the first operand is to be shifted. The direction of the shift operation is controlled by the operator used.</p> - -<p>Shift operators convert their operands to 32-bit integers in big-endian order and return a result of the same type as the left operand. The right operand should be less than 32, but if not only the low five bits will be used.</p> - -<h3 id="<<_(Left_shift)"><a name="Left_shift"><< (Left shift)</a></h3> - -<p>This operator shifts the first operand the specified number of bits to the left. Excess bits shifted off to the left are discarded. Zero bits are shifted in from the right.</p> - -<p>For example, <code>9 << 2</code> yields 36:</p> - -<pre class="brush: js">. 9 (base 10): 00000000000000000000000000001001 (base 2) - -------------------------------- -9 << 2 (base 10): 00000000000000000000000000100100 (base 2) = 36 (base 10) -</pre> - -<p>Bitwise shifting any number <code>x</code> to the left by <code>y</code> bits yields <code>x * 2 ** y</code>.</p> - -<h3 id=">>_(Sign-propagating_right_shift)"><a name="Right_shift">>> (Sign-propagating right shift)</a></h3> - -<p>This operator shifts the first operand the specified number of bits to the right. Excess bits shifted off to the right are discarded. Copies of the leftmost bit are shifted in from the left. Since the new leftmost bit has the same value as the previous leftmost bit, the sign bit (the leftmost bit) does not change. Hence the name "sign-propagating".</p> - -<p>For example, <code>9 >> 2</code> yields 2:</p> - -<pre class="brush: js">. 9 (base 10): 00000000000000000000000000001001 (base 2) - -------------------------------- -9 >> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10) -</pre> - -<p>Likewise, <code>-9 >> 2</code> yields <code>-3</code>, because the sign is preserved:</p> - -<pre class="brush: js">. -9 (base 10): 11111111111111111111111111110111 (base 2) - -------------------------------- --9 >> 2 (base 10): 11111111111111111111111111111101 (base 2) = -3 (base 10) -</pre> - -<h3 id=">>>_(Zero-fill_right_shift)"><a name="Unsigned_right_shift">>>> (Zero-fill right shift)</a></h3> - -<p>This operator shifts the first operand the specified number of bits to the right. Excess bits shifted off to the right are discarded. Zero bits are shifted in from the left. The sign bit becomes 0, so the result is always non-negative.</p> - -<p>For non-negative numbers, zero-fill right shift and sign-propagating right shift yield the same result. For example, <code>9 >>> 2</code> yields 2, the same as <code>9 >> 2</code>:</p> - -<pre class="brush: js">. 9 (base 10): 00000000000000000000000000001001 (base 2) - -------------------------------- -9 >>> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10) -</pre> - -<p>However, this is not the case for negative numbers. For example, <code>-9 >>> 2</code> yields 1073741821, which is different than <code>-9 >> 2</code> (which yields <code>-3</code>):</p> - -<pre class="brush: js">. -9 (base 10): 11111111111111111111111111110111 (base 2) - -------------------------------- --9 >>> 2 (base 10): 00111111111111111111111111111101 (base 2) = 1073741821 (base 10) -</pre> - -<h2 id="Examples">Examples</h2> - -<h3 id="Flags_and_bitmasks">Flags and bitmasks</h3> - -<p>The bitwise logical operators are often used to create, manipulate, and read sequences of <em>flags</em>, which are like binary variables. Variables could be used instead of these sequences, but binary flags take much less memory (by a factor of 32).</p> - -<p>Suppose there are 4 flags:</p> - -<ul> - <li>flag A: we have an ant problem</li> - <li>flag B: we own a bat</li> - <li>flag C: we own a cat</li> - <li>flag D: we own a duck</li> -</ul> - -<p>These flags are represented by a sequence of bits: DCBA. When a flag is <em>set</em>, it has a value of 1. When a flag is <em>cleared</em>, it has a value of 0. Suppose a variable <code>flags</code> has the binary value 0101:</p> - -<pre class="brush: js">var flags = 5; // binary 0101 -</pre> - -<p>This value indicates:</p> - -<ul> - <li>flag A is true (we have an ant problem);</li> - <li>flag B is false (we don't own a bat);</li> - <li>flag C is true (we own a cat);</li> - <li>flag D is false (we don't own a duck);</li> -</ul> - -<p>Since bitwise operators are 32-bit, 0101 is actually 00000000000000000000000000000101, but the preceding zeroes can be neglected since they contain no meaningful information.</p> - -<p>A <em>bitmask</em> is a sequence of bits that can manipulate and/or read flags. Typically, a "primitive" bitmask for each flag is defined:</p> - -<pre class="brush: js">var FLAG_A = 1; // 0001 -var FLAG_B = 2; // 0010 -var FLAG_C = 4; // 0100 -var FLAG_D = 8; // 1000 -</pre> - -<p>New bitmasks can be created by using the bitwise logical operators on these primitive bitmasks. For example, the bitmask 1011 can be created by ORing FLAG_A, FLAG_B, and FLAG_D:</p> - -<pre class="brush: js">var mask = FLAG_A | FLAG_B | FLAG_D; // 0001 | 0010 | 1000 => 1011 -</pre> - -<p>Individual flag values can be extracted by ANDing them with a bitmask, where each bit with the value of one will "extract" the corresponding flag. The bitmask <em>masks</em> out the non-relevant flags by ANDing with zeroes (hence the term "bitmask"). For example, the bitmask 0100 can be used to see if flag C is set:</p> - -<pre class="brush: js">// if we own a cat -if (flags & FLAG_C) { // 0101 & 0100 => 0100 => true - // do stuff -} -</pre> - -<p>A bitmask with multiple set flags acts like an "either/or". For example, the following two are equivalent:</p> - -<pre class="brush: js">// if we own a bat or we own a cat -// (0101 & 0010) || (0101 & 0100) => 0000 || 0100 => true -if ((flags & FLAG_B) || (flags & FLAG_C)) { - // do stuff -} -</pre> - -<pre class="brush: js">// if we own a bat or cat -var mask = FLAG_B | FLAG_C; // 0010 | 0100 => 0110 -if (flags & mask) { // 0101 & 0110 => 0100 => true - // do stuff -} -</pre> - -<p>Flags can be set by ORing them with a bitmask, where each bit with the value one will set the corresponding flag, if that flag isn't already set. For example, the bitmask 1100 can be used to set flags C and D:</p> - -<pre class="brush: js">// yes, we own a cat and a duck -var mask = FLAG_C | FLAG_D; // 0100 | 1000 => 1100 -flags |= mask; // 0101 | 1100 => 1101 -</pre> - -<p>Flags can be cleared by ANDing them with a bitmask, where each bit with the value zero will clear the corresponding flag, if it isn't already cleared. This bitmask can be created by NOTing primitive bitmasks. For example, the bitmask 1010 can be used to clear flags A and C:</p> - -<pre class="brush: js">// no, we don't have an ant problem or own a cat -var mask = ~(FLAG_A | FLAG_C); // ~0101 => 1010 -flags &= mask; // 1101 & 1010 => 1000 -</pre> - -<p>The mask could also have been created with <code>~FLAG_A & ~FLAG_C</code> (De Morgan's law):</p> - -<pre class="brush: js">// no, we don't have an ant problem, and we don't own a cat -var mask = ~FLAG_A & ~FLAG_C; -flags &= mask; // 1101 & 1010 => 1000 -</pre> - -<p>Flags can be toggled by XORing them with a bitmask, where each bit with the value one will toggle the corresponding flag. For example, the bitmask 0110 can be used to toggle flags B and C:</p> - -<pre class="brush: js">// if we didn't have a bat, we have one now, -// and if we did have one, bye-bye bat -// same thing for cats -var mask = FLAG_B | FLAG_C; -flags = flags ^ mask; // 1100 ^ 0110 => 1010 -</pre> - -<p>Finally, the flags can all be flipped with the NOT operator:</p> - -<pre class="brush: js">// entering parallel universe... -flags = ~flags; // ~1010 => 0101 -</pre> - -<h3 id="Conversion_snippets">Conversion snippets</h3> - -<p>Convert a binary <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String" title="/en-US/docs/JavaScript/Reference/Global_Objects/String">String</a></code> to a decimal <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number">Number</a></code>:</p> - -<pre class="brush: js">var sBinString = '1011'; -var nMyNumber = parseInt(sBinString, 2); -alert(nMyNumber); // prints 11, i.e. 1011 -</pre> - -<p>Convert a decimal <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number">Number</a></code> to a binary <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String" title="/en-US/docs/JavaScript/Reference/Global_Objects/String">String</a></code>:</p> - -<pre class="brush: js">var nMyNumber = 11; -var sBinString = nMyNumber.toString(2); -alert(sBinString); // prints 1011, i.e. 11 -</pre> - -<h3 id="Automate_Mask_Creation">Automate Mask Creation</h3> - -<p>You can create multiple masks from a set of <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean" title="/en-US/docs/JavaScript/Reference/Global_Objects/Boolean">Boolean</a></code> values, like this:</p> - -<pre class="brush: js">function createMask() { - var nMask = 0, nFlag = 0, nLen = arguments.length > 32 ? 32 : arguments.length; - for (nFlag; nFlag < nLen; nMask |= arguments[nFlag] << nFlag++); - return nMask; -} -var mask1 = createMask(true, true, false, true); // 11, i.e.: 1011 -var mask2 = createMask(false, false, true); // 4, i.e.: 0100 -var mask3 = createMask(true); // 1, i.e.: 0001 -// etc. - -alert(mask1); // prints 11, i.e.: 1011 -</pre> - -<h3 id="Reverse_algorithm_an_array_of_booleans_from_a_mask">Reverse algorithm: an array of booleans from a mask</h3> - -<p>If you want to create an <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" title="/en-US/docs/JavaScript/Reference/Global_Objects/Array">Array</a></code> of <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean" title="/en-US/docs/JavaScript/Reference/Global_Objects/Boolean">Booleans</a></code> from a mask you can use this code:</p> - -<pre class="brush: js">function arrayFromMask(nMask) { - // nMask must be between -2147483648 and 2147483647 - if (nMask > 0x7fffffff || nMask < -0x80000000) { - throw new TypeError('arrayFromMask - out of range'); - } - for (var nShifted = nMask, aFromMask = []; nShifted; - aFromMask.push(Boolean(nShifted & 1)), nShifted >>>= 1); - return aFromMask; -} - -var array1 = arrayFromMask(11); -var array2 = arrayFromMask(4); -var array3 = arrayFromMask(1); - -alert('[' + array1.join(', ') + ']'); -// prints "[true, true, false, true]", i.e.: 11, i.e.: 1011 -</pre> - -<p>You can test both algorithms at the same time…</p> - -<pre class="brush: js">var nTest = 19; // our custom mask -var nResult = createMask.apply(this, arrayFromMask(nTest)); - -alert(nResult); // 19 -</pre> - -<p>For the didactic purpose only (since there is the <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toString" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number/toString">Number.toString(2)</a></code> method), we show how it is possible to modify the <code>arrayFromMask</code> algorithm in order to create a <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String" title="/en-US/docs/JavaScript/Reference/Global_Objects/String">String</a></code> containing the binary representation of a <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number">Number</a></code>, rather than an <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" title="/en-US/docs/JavaScript/Reference/Global_Objects/Array">Array</a></code> of <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean" title="/en-US/docs/JavaScript/Reference/Global_Objects/Boolean">Booleans</a></code>:</p> - -<pre class="brush: js">function createBinaryString(nMask) { - // nMask must be between -2147483648 and 2147483647 - for (var nFlag = 0, nShifted = nMask, sMask = ''; nFlag < 32; - nFlag++, sMask += String(nShifted >>> 31), nShifted <<= 1); - return sMask; -} - -var string1 = createBinaryString(11); -var string2 = createBinaryString(4); -var string3 = createBinaryString(1); - -alert(string1); -// prints 00000000000000000000000000001011, i.e. 11 -</pre> - -<h2 id="Specifications">Specifications</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Specification</th> - <th scope="col">Status</th> - <th scope="col">Comment</th> - </tr> - <tr> - <td>{{SpecName('ES1')}}</td> - <td>{{Spec2('ES1')}}</td> - <td>Initial definition.</td> - </tr> - <tr> - <td>{{SpecName('ES5.1', '#sec-11.7')}}</td> - <td>{{Spec2('ES5.1')}}</td> - <td>Defined in several sections of the specification: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.4.8">Bitwise NOT operator</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.7">Bitwise shift operators</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.10">Binary bitwise operators</a></td> - </tr> - <tr> - <td>{{SpecName('ES6', '#sec-bitwise-shift-operators')}}</td> - <td>{{Spec2('ES6')}}</td> - <td>Defined in several sections of the specification: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-bitwise-not-operator">Bitwise NOT operator</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-bitwise-shift-operators">Bitwise shift operators</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-binary-bitwise-operators">Binary bitwise operators</a></td> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-bitwise-shift-operators')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td>Defined in several sections of the specification: <a href="http://tc39.github.io/ecma262/#sec-bitwise-not-operator">Bitwise NOT operator</a>, <a href="http://tc39.github.io/ecma262/#sec-bitwise-shift-operators">Bitwise shift operators</a>, <a href="http://tc39.github.io/ecma262/#sec-binary-bitwise-operators">Binary bitwise operators</a></td> - </tr> - </tbody> -</table> - -<h2 id="Browser_compatibility">Browser compatibility</h2> - -<div class="hidden"> -<p>The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> -</div> - -<p>{{Compat("javascript.operators.bitwise")}}</p> - -<h2 id="See_also">See also</h2> - -<ul> - <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators">Logical operators</a></li> -</ul> diff --git a/files/pt-br/web/javascript/reference/operators/operador_virgula/index.html b/files/pt-br/web/javascript/reference/operators/comma_operator/index.html index be374104d0..be374104d0 100644 --- a/files/pt-br/web/javascript/reference/operators/operador_virgula/index.html +++ b/files/pt-br/web/javascript/reference/operators/comma_operator/index.html diff --git a/files/pt-br/web/javascript/reference/operators/operador_condicional/index.html b/files/pt-br/web/javascript/reference/operators/conditional_operator/index.html index 9b36afca80..9b36afca80 100644 --- a/files/pt-br/web/javascript/reference/operators/operador_condicional/index.html +++ b/files/pt-br/web/javascript/reference/operators/conditional_operator/index.html diff --git a/files/pt-br/web/javascript/reference/operators/atribuicao_via_desestruturacao/index.html b/files/pt-br/web/javascript/reference/operators/destructuring_assignment/index.html index 6b1a100b4b..6b1a100b4b 100644 --- a/files/pt-br/web/javascript/reference/operators/atribuicao_via_desestruturacao/index.html +++ b/files/pt-br/web/javascript/reference/operators/destructuring_assignment/index.html diff --git a/files/pt-br/web/javascript/reference/operators/operador_de_coalescencia_nula/index.html b/files/pt-br/web/javascript/reference/operators/nullish_coalescing_operator/index.html index 609bfa29fd..609bfa29fd 100644 --- a/files/pt-br/web/javascript/reference/operators/operador_de_coalescencia_nula/index.html +++ b/files/pt-br/web/javascript/reference/operators/nullish_coalescing_operator/index.html diff --git a/files/pt-br/web/javascript/reference/operators/inicializador_objeto/index.html b/files/pt-br/web/javascript/reference/operators/object_initializer/index.html index ac59b4e7f8..ac59b4e7f8 100644 --- a/files/pt-br/web/javascript/reference/operators/inicializador_objeto/index.html +++ b/files/pt-br/web/javascript/reference/operators/object_initializer/index.html diff --git a/files/pt-br/web/javascript/reference/operators/operadores_de_comparação/index.html b/files/pt-br/web/javascript/reference/operators/operadores_de_comparação/index.html deleted file mode 100644 index d5e946a438..0000000000 --- a/files/pt-br/web/javascript/reference/operators/operadores_de_comparação/index.html +++ /dev/null @@ -1,251 +0,0 @@ ---- -title: Operadores de comparação -slug: Web/JavaScript/Reference/Operators/Operadores_de_comparação -tags: - - Comparando String - - Comparação - - Igualdade - - Operadores - - Relacionais -translation_of: Web/JavaScript/Reference/Operators -translation_of_original: Web/JavaScript/Reference/Operators/Comparison_Operators ---- -<div>{{jsSidebar("Operators")}}</div> - -<p>O JavaScript possui comparações estritas e conversão de tipos. Uma comparação estrita (e.g., <code>===</code>) somente é verdade se os operandos forem do mesmo tipo e de conteúdo correspondente. A comparação abstrata mais comumente utilizada (e.g. <code>==</code>) converte os operandos no mesmo tipo antes da comparação. Para comparações abstratas relacionais (e.g., <code><=</code>), os operandos são primeiro convertidos em primitivos, depois para o mesmo tipo, depois comparados.</p> - -<p>Strings são comparadas baseadas na ordenação lexicografica padrão, usando valores Unicode.</p> - -<div>{{EmbedInteractiveExample("pages/js/expressions-comparisonoperators.html")}}</div> - -<p class="hidden">Os fontes para este exemplo interativo estão em um repositório no GitHub. Se você gostaria de contribuir com projetos de exemplos interativos, por favor clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e envie para nós um pull request.</p> - -<p>Características de comparação:</p> - -<ul> - <li>Duas strings são estritamente iguals quando elas possuem a mesma sequência de caracteres, o mesmo tamanho, Duas string são estritamente iguals quando elas possuem a mesma sequência de caracteres, o mesmo tamanho, e os mesmos caracteres em posições correspondentes.</li> - <li>Dois números são estritamente iguais quando eles são numericamente iguais (tem o mesmo valor numérico). <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN" title="NaN">NaN</a> não é igual a nada, incluindo NaN. Zeros positivos e negativos são iguals entre si.</li> - <li>Dois operadores Boleanos são estritamente iguais se ambos são <code>true</code> ou ambos são <code>false</code>.</li> - <li>Dois objetos distintos nunca são iguais para comparações estritas ou abstratas.</li> - <li>Uma expressão comparando Objetos somente é verdadeira se os operandos referenciarem o mesmo Objeto.</li> - <li>Os tipo Null e Undefined são estritamente iguais entre eles mesmos e abstratamente iguais entre si.</li> -</ul> - -<h2 id="Operadores_de_Igualdade">Operadores de Igualdade </h2> - -<h3 id="Igualdade"><a name="Equality">Igualdade (==)</a></h3> - -<p>O operador de igualdade converte o operando se ele <strong>não for do mesmo tipo</strong>, então aplica a comparação estrita. Se <strong>ambos os operandos são objetos</strong>, então o JavaScript compara referencias internas que são iguais quando os operandos se referem ao mesmo objeto em memória.</p> - -<h4 id="Sintaxe">Sintaxe</h4> - -<pre class="syntaxbox notranslate">x == y -</pre> - -<h4 id="Exemplos">Exemplos</h4> - -<pre class="brush: js notranslate">1 == 1 // verdade -'1' == 1 // verdade -1 == '1' // verdade -0 == false // verdade -0 == null // falso -var object1 = {'key': 'value'}, object2 = {'key': 'value'}; -object1 == object2 // falso -0 == undefined // falso -null == undefined // verdade -</pre> - -<h3 id="Desigualdade_!"><a name="Inequality">Desigualdade (!=)</a></h3> - -<p>O operador de desigualdade retorna true (verdade) se os operandos não são iguais. Se os dois operandos <strong>não são do mesmo tipo</strong>, o JavaScript tenta converter os operandos para o tipo apropriado para a comparação. Se <strong>ambos os operandos são objetos</strong>, então o JavaScript compara referências internas que não são iguais quando os operandos se referem a objetos diferentes na memória.</p> - -<h4 id="Sintaxe_2">Sintaxe</h4> - -<pre class="syntaxbox notranslate">x != y</pre> - -<h4 id="Exemplos_2">Exemplos</h4> - -<pre class="brush: js notranslate">1 != 2 // verdade -1 != '1' // falso -1 != "1" // falso -1 != true // falso -0 != false // falso -</pre> - -<h3 id="Identidade_igualdade_estrita"><a name="Identity">Identidade / igualdade estrita (===)</a></h3> - -<p>O operador de identidade retorna true (verdade) se os operandos são estritamente iguais (veja acima) <strong>sem conversão de tipo</strong>. </p> - -<h4 id="Sintaxe_3">Sintaxe</h4> - -<pre class="syntaxbox notranslate">x === y</pre> - -<h4 id="Exemplos_3">Exemplos</h4> - -<pre class="brush: js notranslate">3 === 3 // verdade -3 === '3' // falso -var object1 = {'key': 'value'}, object2 = {'key': 'value'}; -object1 === object2 //f also</pre> - -<h3 id="Non-identity_desigualdade_estrita_!"><a name="Nonidentity">Non-identity / desigualdade estrita (!==)</a></h3> - -<p>O operador desigualdade estrita (Non-identity) retorna verdadeiro se os operandos <strong>não são iguais e / ou não são do mesmo tipo</strong>.</p> - -<h4 id="Sintaxe_4">Sintaxe</h4> - -<pre class="syntaxbox notranslate">x !== y</pre> - -<h4 id="Exemplos_4">Exemplos</h4> - -<pre class="brush: js notranslate">3 !== '3' // verdade -4 !== 3 // verdade -</pre> - -<h2 id="Operadores_relacionais">Operadores relacionais</h2> - -<p>Cada um desses operadores chamará a função valueOf () em cada operando antes que uma comparação seja feita.</p> - -<h3 id="Operador_Maior_>"><a name="Greater_than_operator">Operador Maior (>)</a></h3> - -<p>O operador de Maior retorna true se o operando da esquerda for maior que o operando da direita.</p> - -<h4 id="Sintaxe_5">Sintaxe</h4> - -<pre class="syntaxbox notranslate">x > y</pre> - -<h4 id="Exemplos_5">Exemplos</h4> - -<pre class="brush: js notranslate">4 > 3 // verdade -</pre> - -<h3 id="Operador_maior_ou_igual_>"><a name="Greater_than_or_equal_operator">Operador maior ou igual (>=)</a></h3> - -<p>O operador maior ou igual retorna true se o operando da esquerda for maior ou igual ao operando da direita.</p> - -<h4 id="Sintaxe_6">Sintaxe</h4> - -<pre class="syntaxbox notranslate"> x >= y</pre> - -<h4 id="Exemplos_6">Exemplos</h4> - -<pre class="brush: js notranslate">4 >= 3 // verdade -3 >= 3 // verdade -</pre> - -<h3 id="Operador_Menor_<"><a name="Less_than_operator">Operador Menor (<)</a></h3> - -<p>O operador menor retorna true (verdadeiro) se o operando da esquerda for menor que o operando da direita.</p> - -<h4 id="Sintaxe_7">Sintaxe</h4> - -<pre class="syntaxbox notranslate"> x < y</pre> - -<h4 id="Exemplos_7">Exemplos</h4> - -<pre class="brush: js notranslate">3 < 4 // verdade -</pre> - -<h3 id="Operador_menor_ou_igual_<"><a id="Less_than_or_equal_operator" name="Less_than_or_equal_operator">Operador menor ou igual (<=)</a></h3> - -<p>O operador menor ou igual retorna true (verdadeiro) se o operando da esquerda for menor ou igual ao operando da direita.</p> - -<h4 id="Sintaxe_8">Sintaxe</h4> - -<pre class="syntaxbox notranslate"> x <= y</pre> - -<h4 id="Exemplos_8">Exemplos</h4> - -<pre class="brush: js notranslate">3 <= 4 // verdade -</pre> - -<h2 id="Usando_Operadores_de_Igualdade">Usando Operadores de Igualdade</h2> - -<p>Os operadores de igualdade padrão (== e! =) Usam o <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3">Algoritmo de Comparação de Igualdade Abstrata</a> </p> - -<p>para comparar dois operandos. Se os operandos forem de tipos diferentes, ele tentará convertê-los para o mesmo tipo antes de fazer a comparação. Por exemplo, na expressão 5 == '5', a sequência à direita é convertida em {{jsxref ("Number" )}} antes da comparação ser feita.</p> - -<p>Os operadores de igualdade estrita (=== e! ==) usam o <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.6">Algoritmo de comparação estrita de igualdade</a> e se destinam a executar comparações de igualdade em operandos do mesmo tipo. Se os operandos são de tipos diferentes, o resultado é sempre falso, então 5! == '5'.<br> - <br> - Use operadores de igualdade estrita se os operandos precisarem ser de um tipo específico e também de valor ou se o tipo exato dos operandos for importante. Caso contrário, use os operadores de igualdade padrão, que permitem comparar a identidade de dois operandos, mesmo que não sejam do mesmo tipo.<br> - <br> - Quando a conversão de tipos está envolvida na comparação (por exemplo, comparação não estrita), o JavaScript converte os tipos {{jsxref ("String")}}, {{jsxref ("Number")}}, {{jsxref ("Booleano" )}} ou {{jsxref ("Object")}}) operandos da seguinte forma:</p> - -<ul> - <li>Ao comparar um número e uma string, a string é convertida em um valor numérico. JavaScript tenta converter o literal numérico de string em um valor de tipo Number. Primeiro, um valor matemático é derivado do literal numérico da string. Em seguida, esse valor é arredondado para o valor de tipo de número mais próximo.</li> - <li>Se um dos operandos for booleano, o operando booleano é convertido em 1 se for verdadeiro e +0 se for falso.</li> - <li>Se um objeto é comparado com um número ou string, o JavaScript tenta retornar o valor padrão para o objeto. Os operadores tentam converter o objeto em um valor primitivo, um valor String ou Number, usando os métodos valueOf e toString dos objetos. Se essa tentativa de converter o objeto falhar, será gerado um erro de tempo de execução.</li> - <li>Observe que um objeto é convertido em primitivo se, e somente se, seu comparando for um primitivo. Se os dois operandos forem objetos, eles serão comparados como objetos, e o teste de igualdade será verdadeiro apenas se ambos fizerem referência ao mesmo objeto.</li> -</ul> - -<div class="note"><strong>Nota:</strong> Os objetos String são do Tipo Objeto, não String! Os objetos de string raramente são usados, portanto, os seguintes resultados podem ser surpreendentes:</div> - -<pre class="brush:js notranslate">// true, pois ambos os operandos são do tipo String (ou seja, primitivos de string): -'foo' === 'foo' - -var a = new String('foo'); -var b = new String('foo'); - -// falso (false) pois a e b, embora do tipo "Objeto", são instâncias diferentes -a == b - -// falso (false) pois a e b, embora do tipo "Objeto", são instâncias diferentes -a === b - -// verdadeiro (true) pois o objeto a e 'foo' (String) são de tipos diferentes e, o Objeto (a) -// é convertido para String ('foo') antes da comparação -a == 'foo'</pre> - -<h2 id="Especificações">Especificações</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Especificação</th> - <th scope="col">Status</th> - <th scope="col">Comentário</th> - </tr> - <tr> - <td>{{SpecName('ES1')}}</td> - <td>{{Spec2('ES1')}}</td> - <td>Definição Inicial. Implementado em JavaScript 1.0</td> - </tr> - <tr> - <td>{{SpecName('ES3')}}</td> - <td>{{Spec2('ES3')}}</td> - <td>Adicionandos os operadores <code>===</code> e <code>!==</code> . Implementado em JavaScript 1.3</td> - </tr> - <tr> - <td>{{SpecName('ES5.1', '#sec-11.8')}}</td> - <td>{{Spec2('ES5.1')}}</td> - <td>Definidos em várias seções das especificações: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.8">Operadores Relacionais </a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9">Operadores de Igualdade</a></td> - </tr> - <tr> - <td>{{SpecName('ES6', '#sec-relational-operators')}}</td> - <td>{{Spec2('ES6')}}</td> - <td>Definidos em várias seções das especificações: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.8">Operadores Relacionais </a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9">Operadores de Igualdade</a></td> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-relational-operators')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td>Definidos em várias seções das especificações: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.8">Operadores Relacionais </a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9">Operadores de Igualdade</a></td> - </tr> - </tbody> -</table> - -<h2 id="Compatilidade_entre_navegadores">Compatilidade entre navegadores</h2> - -<div class="hidden">A tabela de compatibilidade desta página é gerada a partir de dados estruturados. Se você deseja contribuir com os dados, confira <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e envie-nos uma solicitação de recebimento.</div> - -<p>{{Compat("javascript.operators.comparison")}}</p> - -<h2 id="Consulte_também">Consulte também</h2> - -<ul> - <li>{{jsxref("Object.is()")}}</li> - <li>{{jsxref("Math.sign()")}}</li> - <li><a href="/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness">Comparações de igualdade e similaridades</a></li> -</ul> - -<div id="gtx-trans" style="position: absolute; left: 32px; top: 2185.4px;"> -<div class="gtx-trans-icon"></div> -</div> diff --git a/files/pt-br/web/javascript/reference/operators/operadores_logicos/index.html b/files/pt-br/web/javascript/reference/operators/operadores_logicos/index.html deleted file mode 100644 index e3a3ee6e8c..0000000000 --- a/files/pt-br/web/javascript/reference/operators/operadores_logicos/index.html +++ /dev/null @@ -1,343 +0,0 @@ ---- -title: Operadores Lógicos -slug: Web/JavaScript/Reference/Operators/Operadores_Logicos -tags: - - Operador - - Operadores lógicos - - Referencia - - e - - não - - ou -translation_of: Web/JavaScript/Reference/Operators -translation_of_original: Web/JavaScript/Reference/Operators/Logical_Operators ---- -<div>{{jsSidebar("Operators")}}</div> - -<h2 id="Summary" name="Summary">Resumo</h2> - -<p>Operadores lógicos são tipicamente usados com valores <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean">Booleanos</a></code> (lógicos). Quando eles o são, retornam um valor booleano. Porém, os operadores <code>&&</code> e <code>||</code> de fato retornam o valor de um dos operandos especificos, então se esses operadores são usados com valores não booleanos, eles podem retornar um valor não booleano.</p> - -<h2 id="Descrição">Descrição</h2> - -<p>Os operadores lógicos são descritos na tabela abaixo:</p> - -<table class="fullwidth-table"> - <tbody> - <tr> - <th>Operador</th> - <th>Utilização</th> - <th>Descrição</th> - </tr> - <tr> - <td>Logical AND (<code>&&</code>)</td> - <td><code><em>expr1</em> && <em>expr2</em></code></td> - <td>Retorna <code>expr1</code> se essa pode ser convertido para <code>falso</code>; senão, retorna <code>expr2</code>. Dessa forma, quando usado para valores Booleanos, <code>&&</code> retorna <code>verdadeiro</code> se ambos os operandos forem <code>verdadeiro</code> ; senão, retorna <code>falso</code>.</td> - </tr> - <tr> - <td>Logical OR (<code>||</code>)</td> - <td><code><em>expr1</em> || <em>expr2</em></code></td> - <td>Retorna <code>expr1</code> se essa pode ser convertido para <code>verdadeiro</code>; senão, retorna <code>expr2</code>. Dessa forma, quando usado para valores Booleanos, <code>||</code> retorna <code>verdadeiro</code> se qualquer dos operandos for <code>verdadeiro</code>; se ambos são <code>falso</code>, retorna <code>falso</code>.</td> - </tr> - <tr> - <td>Logical NOT (<code>!</code>)</td> - <td><code>!<em>expr</em></code></td> - <td> - <p>Retorna <code>falso</code>se o seu operando pode ser convertido para verdadeiro; senão, retorna <code>verdadeiro</code>.</p> - </td> - </tr> - </tbody> -</table> - -<p>Se um valor pode ser convertido para <code>verdadeiro</code>, este valor é chamado de {{Glossary("truthy")}}. Se um valor pode ser convertido para <code>falso</code>, este valor é chamado de {{Glossary("falsy")}}.</p> - -<p>Exemplos de expressões que podem ser convertidas para falso são:</p> - -<ul> - <li><code>null</code>;</li> - <li><code>NaN;</code></li> - <li><code>0</code>;</li> - <li>string vazia (<code>""</code>); </li> - <li><code>undefined</code>.</li> -</ul> - -<p>Mesmo que os operadores <code>&&</code> and <code>||</code> possam ser utilizados com operandos que não são valores Booleanos, eles ainda podem ser considerados como operadores booleanos visto que seus valores de saída sempre podem ser convertidos em valores booleanos.</p> - -<h3 id="Short-Circuit_Evaluation" name="Short-Circuit_Evaluation">Avaliação de Curto-Circuito (Short-Circuit) </h3> - -<p>Como as expressões lógicas são avaliadas da esquerda pra direita, elas são testadas para possível avaliação de "curto-circuito" ("short-circuit") utilizando as seguintes regras:</p> - -<ul> - <li><code>falso && (<em>qualquer coisa)</em></code><em> </em>é avaliado como falso através de curto-circuito.</li> - <li><code>true || (<em>qualquer coisa)</em></code><em> </em>é avaliado como verdadeiro através de curto-circuito.</li> -</ul> - -<p>As regras de lógica garantem que essas avaliações estejam sempre corretas. Repare que a porção <em>qualquer coisa</em> das expressões acima não é avaliada, logo qualquer problema oriundo de tê-lo feito não é consumado. Note também que a parte<em> qualquer coisa</em> das expressões acima pode ser qualquer expressão lógica unitária (conforme é indicado pelos <span style="line-height: 1.5;">parênteses</span>).</p> - -<p>Por exemplo, as duas funções a seguir são equivalentes.</p> - -<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">function</span> <span class="function token">shortCircuitEvaluation</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> - <span class="comment token">// logical OR (||)</span> - <span class="function token">doSomething</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="operator token">||</span> <span class="function token">doSomethingElse</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> - - <span class="comment token">// logical AND (&&)</span> - <span class="function token">doSomething</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="operator token">&&</span> <span class="function token">doSomethingElse</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> -<span class="punctuation token">}</span> - -<span class="keyword token">function</span> <span class="function token">equivalentEvaluation</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> - - <span class="comment token">// logical OR (||)</span> - <span class="keyword token">var</span> orFlag <span class="operator token">=</span> <span class="function token">doSomething</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> - <span class="keyword token">if</span> <span class="punctuation token">(</span><span class="operator token">!</span>orFlag<span class="punctuation token">)</span> <span class="punctuation token">{</span> - <span class="function token">doSomethingElse</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> - <span class="punctuation token">}</span> - - - <span class="comment token">// logical AND (&&)</span> - <span class="keyword token">var</span> andFlag <span class="operator token">=</span> <span class="function token">doSomething</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> - <span class="keyword token">if</span> <span class="punctuation token">(</span>andFlag<span class="punctuation token">)</span> <span class="punctuation token">{</span> - <span class="function token">doSomethingElse</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> - <span class="punctuation token">}</span> -<span class="punctuation token">}</span></code></pre> - -<p>Contudo, as expressões a seguir não são equivalentes, devido <span style="line-height: 1.5;">a <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">precedência do operador</a>, e reforçam a importância de que o operador do lado direito (right hand) seja uma única expressão (agrupada com o uso de parênteses, caso seja necessário)</span><span style="line-height: 1.5;">.</span></p> - -<pre class="brush: js"> false && true || true // retorna true - false && (true || true) // retorna falso</pre> - -<h3 id="Logical_AND_.28.29" name="Logical_AND_.28&&.29"><a name="Logical_AND">AND Lógico (<code>&&</code>)</a></h3> - -<p>O código a seguir demonstra exemplos do operador <code>&&</code> (AND lógico). </p> - -<pre class="brush: js">a1 = true && true // t && t retorna true -a2 = true && false // t && f retorna false -a3 = false && true // f && t retorna false -a4 = false && (3 == 4) // f && f retorna false -a5 = 'Cat' && 'Dog' // t && t retorna "Dog" -a6 = false && 'Cat' // f && t retorna false -a7 = 'Cat' && false // t && f retorna false -a8 = '' && false // f && f retorna "" -a9 = false && '' // f && t retorna false -</pre> - -<h3 id="OR_Lógico_()"><a name="Logical_OR">OR Lógico (<code>||</code>)</a></h3> - -<p>O código a seguir demonstra exemplos do operador <code>||</code> (OR lógico).</p> - -<pre class="brush: js line-numbers language-js"><code class="language-js">o1 <span class="operator token">=</span> <span class="keyword token">true</span> <span class="operator token">||</span> <span class="keyword token">true</span> <span class="comment token">// t || t retorna true</span> -o2 <span class="operator token">=</span> <span class="keyword token">false</span> <span class="operator token">||</span> <span class="keyword token">true</span> <span class="comment token">// f || t retorna true</span> -o3 <span class="operator token">=</span> <span class="keyword token">true</span> <span class="operator token">||</span> <span class="keyword token">false</span> <span class="comment token">// t || f retorna true</span> -o4 <span class="operator token">=</span> <span class="keyword token">false</span> <span class="operator token">||</span> <span class="punctuation token">(</span><span class="number token">3</span> <span class="operator token">==</span> <span class="number token">4</span><span class="punctuation token">)</span> <span class="comment token">// f || f retorna false</span> -o5 <span class="operator token">=</span> <span class="string token">'Cat'</span> <span class="operator token">||</span> <span class="string token">'Dog'</span> <span class="comment token">// t || t retorna "Cat"</span> -o6 <span class="operator token">=</span> <span class="keyword token">false</span> <span class="operator token">||</span> <span class="string token">'Cat'</span> <span class="comment token">// f || t retorna "Cat"</span> -o7 <span class="operator token">=</span> <span class="string token">'Cat'</span> <span class="operator token">||</span> <span class="keyword token">false</span> <span class="comment token">// t || f retorna "Cat"</span> -o8 <span class="operator token">=</span> <span class="string token">''</span> <span class="operator token">||</span> <span class="keyword token">false</span> <span class="comment token">// f || f retorna false</span> -o9 <span class="operator token">=</span> <span class="keyword token">false</span> <span class="operator token">||</span> <span class="string token">''</span> <span class="comment token">// f || f retorna ""</span></code></pre> - -<h3 id="Logical_NOT_.28.21.29" name="Logical_NOT_.28.21.29"><a name="Logical_NOT">NOT Logico (<code>!</code>)</a></h3> - -<p>O código a seguir demonstra exemplos do operador <code>!</code> (NOT lógico) .</p> - -<pre class="brush: js line-numbers language-js"><code class="language-js">n1 <span class="operator token">=</span> <span class="operator token">!</span><span class="keyword token">true</span> <span class="comment token">// !t returns false</span> -n2 <span class="operator token">=</span> <span class="operator token">!</span><span class="keyword token">false</span> <span class="comment token">// !f returns true</span> -n3 <span class="operator token">=</span> <span class="operator token">!</span><span class="string token">'Cat'</span> <span class="comment token">// !t returns false</span></code></pre> - -<h3 id="Regras_de_conversão">Regras de conversão</h3> - -<h4 id="Convertendo_AND_para_OR">Convertendo AND para OR</h4> - -<p>A operação a seguir, envolvendo Booleanos:</p> - -<pre class="brush: js">bCondition1 && bCondition2</pre> - -<p>é sempre igual a:</p> - -<pre class="brush: js">!(!bCondition1 || !bCondition2)</pre> - -<h4 id="Convertendo_OR_to_AND">Convertendo OR to AND</h4> - -<p>A operação a seguir, envolvendo Booleanos:</p> - -<pre class="brush: js">bCondition1 || bCondition2</pre> - -<p>é sempre igual a:</p> - -<pre class="brush: js">!(!bCondition1 && !bCondition2)</pre> - -<h4 id="Convertendo_entre_dois_NOT">Convertendo entre dois NOT</h4> - -<p>A seguinte operação envolvendo Booleanos:</p> - -<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="operator token">!</span><span class="operator token">!</span>bCondition</code></pre> - -<p>é sempre igual a:</p> - -<pre class="brush: js line-numbers language-js"><code class="language-js">bCondition</code></pre> - -<h3 id="Removendo_parenteses_aninhados">Removendo parenteses aninhados</h3> - -<p>Como as expressões lógicas são avaliadas da esquerda pra direita, é sempre possível remover os parênteses de uma expressão complexa seguindo algumas regras:</p> - -<h4 id="Removendo_AND_aninhado">Removendo AND aninhado</h4> - -<p>A seguinte operação composta envolvendo Booleanos:</p> - -<pre class="brush: js">bCondition1 || (bCondition2 && bCondition3)</pre> - -<p>é igual a :</p> - -<pre class="brush: js">bCondition1 || bCondition2 && bCondition3</pre> - -<h4 id="Removendo_OR_aninhado">Removendo OR aninhado</h4> - -<p>A operação composta a seguir, envolvendo Booleanos:</p> - -<pre class="brush: js">bCondition1 && (bCondition2 || bCondition3)</pre> - -<p>é sempre igual a:</p> - -<pre class="brush: js">!(!bCondition1 || !bCondition2 && !bCondition3)</pre> - -<h2 id="Especificações">Especificações</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Especificação</th> - <th scope="col">Estatus</th> - <th scope="col">Comentário</th> - </tr> - <tr> - <td>ECMAScript 1st Edition.</td> - <td>Standard</td> - <td>Initial definition.</td> - </tr> - <tr> - <td>{{SpecName('ES5.1', '#sec-11.4.9', 'Logical NOT Operator')}}<br> - {{SpecName('ES5.1', '#sec-11.11', 'Binary Logical Operators')}}</td> - <td>{{Spec2('ES5.1')}}</td> - <td></td> - </tr> - <tr> - <td>{{SpecName('ES6', '#sec-logical-not-operator', 'Logical NOT operator')}}<br> - {{SpecName('ES6', '#sec-binary-logical-operators', 'Binary Logical Operators')}}</td> - <td>{{Spec2('ES6')}}</td> - <td></td> - </tr> - </tbody> -</table> - -<h2 id="Compatibilidade_com_o_Navegador">Compatibilidade com o Navegador</h2> - -<p>{{ CompatibilityTable() }}</p> - -<div id="compat-desktop"> -<table class="compat-table"> - <tbody> - <tr> - <th>Recurso</th> - <th>Chrome</th> - <th>Firefox (Gecko)</th> - <th>Internet Explorer</th> - <th>Opera</th> - <th>Safari</th> - </tr> - <tr> - <td><a href="#Logical_AND">Logical AND (<code>&&</code>)</a></td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - </tr> - <tr> - <td><a href="#Logical_OR">Logical OR (<code>||</code>)</a></td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - </tr> - <tr> - <td><a href="#Logical_NOT">Logical NOT (<code>!</code>)</a></td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - </tr> - </tbody> -</table> -</div> - -<div id="compat-mobile"> -<table class="compat-table"> - <tbody> - <tr> - <th>Feature</th> - <th>Android</th> - <th>Chrome para Android</th> - <th>Firefox Mobile (Gecko)</th> - <th>IE Mobile</th> - <th>Opera Mobile</th> - <th>Safari Mobile</th> - </tr> - <tr> - <td><a href="#Logical_AND">Logical AND (<code>&&</code>)</a></td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - </tr> - <tr> - <td><a href="#Logical_OR">Logical OR (<code>||</code>)</a></td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - </tr> - <tr> - <td><a href="#Logical_NOT">Logical NOT (<code>!</code>)</a></td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - <td>{{ CompatVersionUnknown() }}</td> - </tr> - </tbody> -</table> -</div> - -<h3 id="JavaScript_1.0_and_1.1" name="JavaScript_1.0_and_1.1">Retrocompatibilidade: Comportamento no JavaScript 1.0 e1.1</h3> - -<p>Os operadores && and <code>|| se comportam da seguinte maneira:</code></p> - -<table class="fullwidth-table"> - <tbody> - <tr> - <th>Operador</th> - <th>Utilização</th> - <th>Comportamento</th> - </tr> - <tr> - <td><code>&&</code></td> - <td><code><em>expr1</em> && <em>expr2</em></code></td> - <td>Se o primeiro operando (<code>expr1</code>) pode ser convertido para falso, o operador <code>&& </code> retorna false ao invés do valor do <code>expr1</code>.</td> - </tr> - <tr> - <td><code>||</code></td> - <td><code><em>expr1</em> || <em>expr2</em></code></td> - <td>If the first operand (<code>expr1</code>) can be converted to true, the <code>||</code> operator retorna true rather than the value of <code>expr1</code>.</td> - </tr> - </tbody> -</table> - -<h2 id="See_also" name="See_also">Veja Também</h2> - -<ul> - <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators">Bitwise operators</a></li> -</ul> diff --git a/files/pt-br/web/javascript/reference/operators/spread_operator/index.html b/files/pt-br/web/javascript/reference/operators/spread_operator/index.html deleted file mode 100644 index a877d131bc..0000000000 --- a/files/pt-br/web/javascript/reference/operators/spread_operator/index.html +++ /dev/null @@ -1,201 +0,0 @@ ---- -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 ---- -<div>{{jsSidebar("Operators")}}</div> - -<p>A sintaxe de propagação (<strong>Spread</strong>) 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.</p> - -<h2 id="Sintaxe">Sintaxe</h2> - -<p>Para chamadas de função:</p> - -<pre class="brush: js">minhaFuncao(...objIteravel); -</pre> - -<p>Para array literais:</p> - -<pre class="brush: js">[...objIteravel, 4, 5, 6]</pre> - -<p>Desestruturação:</p> - -<pre class="brush: js">[a, b, ...objIteravel] = [1, 2, 3, 4, 5];</pre> - -<h2 id="Exemplos">Exemplos</h2> - -<h3 id="Uma_melhor_aplicação">Uma melhor aplicação</h3> - -<p><strong>Exemplo:</strong> é comum usar {{jsxref( "Function.prototype.apply")}} em casos onde você quer usar um array como argumentos em uma função.</p> - -<pre class="brush: js">function minhaFuncao(x, y, z) { } -var args = [0, 1, 2]; -minhaFuncao.apply(null, args);</pre> - -<p>Com o spread do ES2015 você pode agora escrever isso acima como:</p> - -<pre class="brush: js">function minhaFuncao(x, y, z) { } -var args = [0, 1, 2]; -minhaFuncao(...args);</pre> - -<p>Qualquer argumento na lista de argumento pode usar a sintaxe spread e pode ser usado várias vezes.</p> - -<pre class="brush: js">function minhaFuncao(v, w, x, y, z) { } -var args = [0, 1]; -minhaFuncao(-1, ...args, 2, ...[3]);</pre> - -<h3 id="Um_literal_array_mais_poderoso">Um literal array mais poderoso</h3> - -<p><strong>Exemplo:</strong> 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 <code>push</code>, <code>splice</code>, <code>concat</code>, etc. Com a sintaxe spread isso se torna muito mais sucinto:</p> - -<pre class="brush: js">var partes = ['ombros', 'joelhos']; -var letra = ['cabeca', ...partes, 'e', 'dedos']; // <span class="objectBox objectBox-array"><a class="objectLink "><span class="arrayLeftBracket">[</span></a><span class="objectBox objectBox-string">"</span></span>cabeca<span class="objectBox objectBox-array"><span class="objectBox objectBox-string">"</span><span class="arrayComma">, </span><span class="objectBox objectBox-string">"</span></span>ombros<span class="objectBox objectBox-array"><span class="objectBox objectBox-string">"</span><span class="arrayComma">, </span><span class="objectBox objectBox-string">"</span></span>joelhos<span class="objectBox objectBox-array"><span class="objectBox objectBox-string">"</span><span class="arrayComma">, </span><span class="objectBox objectBox-string">"e"</span><span class="arrayComma">, </span><span class="objectBox objectBox-string">"dedos"</span></span>] -</pre> - -<p>Assim como em spread para listas de argumentos <code>...</code> pode ser usado em qualquer lugar no literal do array e pode ser usado várias vezes.</p> - -<h3 id="Apply_para_new">Apply para new</h3> - -<p><strong>Exemplo:</strong> No ES5 não é possível usar <code>new</code> com <code>apply.</code> (Em ES5 termos, <code>apply</code> faz uma <code>[[Call]]</code> e nao um <code>[[Construct]].</code>) Em ES2015 a sintaxe spread naturalmente suporta isso:</p> - -<pre class="brush: js">var camposData = lerCamposData(bancoDeDados); -var d = new Date(...camposData);</pre> - -<h3 id="Um_push_melhor">Um push melhor</h3> - -<p><strong>Exemplo:</strong> {{jsxref("Global_Objects/Array/push", "push")}} é frequentemente usado para adicionar um array no final de um array existente. No ES5 isso é geralmente feito assim:</p> - -<pre class="brush: js">var arr1 = [0, 1, 2]; -var arr2 = [3, 4, 5]; -// Acrescenta todos itens do arr2 ao arr1 -Array.prototype.push.apply(arr1, arr2);</pre> - -<p>No ES2015 com spread isso se torna:</p> - -<pre class="brush: js">var arr1 = [0, 1, 2]; -var arr2 = [3, 4, 5]; -arr1.push(...arr2);</pre> - -<h2 id="Especificações">Especificações</h2> - -<table class="standard-table"> - <thead> - <tr> - <th scope="col">Especificação</th> - <th scope="col">Status</th> - <th scope="col">Comentário</th> - </tr> - </thead> - <tbody> - <tr> - <td>{{SpecName('ES2015', '#sec-array-initializer')}}</td> - <td>{{Spec2('ES2015')}}</td> - <td>Definido em várias seções da especificação: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-array-initializer">Inicializador do array</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-argument-lists">Listas de argumento</a></td> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-array-initializer')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td> </td> - </tr> - </tbody> -</table> - -<h2 id="Compatibilidade_com_browser">Compatibilidade com browser</h2> - -<p>{{CompatibilityTable}}</p> - -<div id="compat-desktop"> -<table class="compat-table"> - <tbody> - <tr> - <th>Feature</th> - <th>Chrome</th> - <th>Firefox (Gecko)</th> - <th>Internet Explorer</th> - <th>Opera</th> - <th>Safari (WebKit)</th> - </tr> - <tr> - <td>Operação spread em array literais</td> - <td>{{CompatChrome("46")}}</td> - <td>{{ CompatGeckoDesktop("16") }}</td> - <td>{{CompatNo}}</td> - <td>{{CompatNo}}</td> - <td>7.1</td> - </tr> - <tr> - <td>Operação spread em chamadas de função</td> - <td>{{CompatChrome("46")}}</td> - <td>{{ CompatGeckoDesktop("27") }}</td> - <td>{{CompatNo}}</td> - <td>{{CompatNo}}</td> - <td>7.1</td> - </tr> - <tr> - <td>Operação spread em desestruturação</td> - <td>{{CompatNo}}</td> - <td>{{ CompatGeckoDesktop("34") }}</td> - <td>{{CompatUnknown}}</td> - <td>{{CompatUnknown}}</td> - <td>{{CompatUnknown}}</td> - </tr> - </tbody> -</table> -</div> - -<div id="compat-mobile"> -<table class="compat-table"> - <tbody> - <tr> - <th>Feature</th> - <th>Android</th> - <th>Android Webview</th> - <th>Firefox Mobile (Gecko)</th> - <th>IE Mobile</th> - <th>Opera Mobile</th> - <th>Safari Mobile</th> - <th>Chrome for Android</th> - </tr> - <tr> - <td>Operação spread em array literais</td> - <td>{{CompatNo}}</td> - <td>{{CompatChrome("46")}}</td> - <td>{{ CompatGeckoMobile("16") }}</td> - <td>{{CompatNo}}</td> - <td>{{CompatNo}}</td> - <td>8</td> - <td>{{CompatChrome("46")}}</td> - </tr> - <tr> - <td>Operação spread em chamadas de função</td> - <td>{{CompatNo}}</td> - <td>{{CompatChrome("46")}}</td> - <td>{{ CompatGeckoMobile("27") }}</td> - <td>{{CompatNo}}</td> - <td>{{CompatNo}}</td> - <td>8</td> - <td>{{CompatChrome("46")}}</td> - </tr> - <tr> - <td>Operação spread em desestruturação</td> - <td>{{CompatNo}}</td> - <td>{{CompatNo}}</td> - <td>{{ CompatGeckoDesktop("34") }}</td> - <td>{{CompatUnknown}}</td> - <td>{{CompatUnknown}}</td> - <td>{{CompatUnknown}}</td> - <td>{{CompatNo}}</td> - </tr> - </tbody> -</table> -</div> - -<h2 id="Veja_também">Veja também</h2> - -<ul> - <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/rest_parameters">Parâmetros rest</a></li> -</ul> |