path: root/files/pt-br/web/javascript/reference/lexical_grammar/index.html

---
title: Gramática léxica
slug: Web/JavaScript/Reference/Lexical_grammar
tags:
  - Gramática léxica
  - JavaScript
  - Literais
  - Palavras-chave
translation_of: Web/JavaScript/Reference/Lexical_grammar
---
<div>{{JsSidebar("More")}}</div>

<p>Esta página descreve a gramática léxica da linguagem JavaScript. O código fonte de um script ECMAScript é lido da esquerda para direita e traduzido em uma sequência de elementos de entrada, como símbolos, caracteres de controle, finalizadores de linha, comentários ou espaços em branco. ECMAScript também define certas palavras-chave e literais e possui regras para inserção automática de ponto e vírgula ao final de declarações.</p>

<h2 id="Caracteres_de_controle">Caracteres de controle</h2>

<p> Caracteres de controle não possuem representação visual, mas são usados para controlar a interpretação do código.</p>

<table class="standard-table">
 <caption>Caracteres de controle Unicode</caption>
 <tbody>
  <tr>
   <th>Código</th>
   <th>Nome</th>
   <th>Abreviação</th>
   <th>Descrição</th>
  </tr>
  <tr>
   <td><code>U+200C</code></td>
   <td>
    <p>Zero width non-joiner</p>
   </td>
   <td>&lt;ZWNJ&gt;</td>
   <td>Colocado entre caracteres para evitar  que sejam visualmente ligados (fundidos) em algumas linguagens (<a href="http://en.wikipedia.org/wiki/Zero-width_non-joiner">Wikipedia</a>).</td>
  </tr>
  <tr>
   <td><code>U+200D</code></td>
   <td>
    <p>Zero width joiner</p>
   </td>
   <td>&lt;ZWJ&gt;</td>
   <td>Colocado entre caracteres que podem não estar normalmente conectados, para que estes caracteres sejam renderizados com suas devidas ligações em certas linguagens (<a href="http://en.wikipedia.org/wiki/Zero-width_joiner">Wikipedia</a>).</td>
  </tr>
  <tr>
   <td><code>U+FEFF</code></td>
   <td>Byte order mark</td>
   <td>&lt;BOM&gt;</td>
   <td>Usado no início do script para marcá-lo como Unicode e especificar a ordem de bytes do código (<a href="http://en.wikipedia.org/wiki/Byte_order_mark">Wikipedia</a>).</td>
  </tr>
 </tbody>
</table>

<h2 id="Espaço_em_branco">Espaço em branco</h2>

<p>Espaços em branco ajudam na legibilidade do código e separam os símbolos um do outro.  Estes caracteres normalmente não são funcionais no código. <a href="https://en.wikipedia.org/wiki/Minification_%28programming%29">Ferramentas de minificação</a> podem ser usadas para remover espaços em branco do código reduzindo, assim, a quantidade de dados que precisam ser transferidos.</p>

<table class="standard-table">
 <caption>Caracteres de espaço em branco</caption>
 <tbody>
  <tr>
   <th>Código</th>
   <th>Nome</th>
   <th>Abreviação</th>
   <th>Descrição</th>
   <th>Sequência de escape</th>
  </tr>
  <tr>
   <td>U+0009</td>
   <td>
    <p>Character tabulation</p>
   </td>
   <td>&lt;HT&gt;</td>
   <td>Tabulação horizontal</td>
   <td>\t</td>
  </tr>
  <tr>
   <td>U+000B</td>
   <td>
    <p>Line tabulation</p>
   </td>
   <td>&lt;VT&gt;</td>
   <td>Tabulação vertical</td>
   <td>\v</td>
  </tr>
  <tr>
   <td>U+000C</td>
   <td>Form feed</td>
   <td>&lt;FF&gt;</td>
   <td>Pular para próxima página (<a href="http://en.wikipedia.org/wiki/Page_break#Form_feed">Wikipedia</a>).</td>
   <td>\f</td>
  </tr>
  <tr>
   <td>U+0020</td>
   <td>Space</td>
   <td>&lt;SP&gt;</td>
   <td>Espaço normal</td>
   <td></td>
  </tr>
  <tr>
   <td>U+00A0</td>
   <td>No-break space</td>
   <td>&lt;NBSP&gt;</td>
   <td>Espaço normal, sem marcar quebra de linha</td>
   <td></td>
  </tr>
  <tr>
   <td>Others</td>
   <td>Other Unicode space characters</td>
   <td>&lt;USP&gt;</td>
   <td><a href="https://en.wikipedia.org/wiki/Space_%28punctuation%29#Spaces_in_Unicode">Outros tipos de espaço. Veja na Wikipedia</a></td>
   <td></td>
  </tr>
 </tbody>
</table>

<h2 id="Finalizadores_de_linha">Finalizadores de linha</h2>

<p>Além dos caracteres de espaço em branco, caracteres finalizadores de linha são usados  para melhorar a legibilidade do código. Contudo, em alguns casos, finalizadores de linha podem influenciar a execução do código JavaScript, por isso você não poderá usá-los em alguns casos. Eles também afetam o <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Lexical_grammar$edit#Automatic_semicolon_insertion">processo automático de inserção de ponto e vírgula</a>. Em <a href="/en-US/docs/Web/JavaScript/Guide/Regular_Expressions">expressões regulares</a> os finalizadores de linha podem ser indicados com a classe <strong>\s</strong>.</p>

<p>Apenas os seguintes códigos Unicode são tratados como finalizadores de linha no ECMAScript, outros caracteres de quebra de linha são tratados apenas como espaço em branco (por exemplo, Next Line, NEL, U+0085 são considerados espaço em branco).</p>

<table class="standard-table">
 <caption>Caracteres de finalização de linha</caption>
 <tbody>
  <tr>
   <th>Código</th>
   <th>Nome</th>
   <th>Abreviação</th>
   <th>Descrião</th>
   <th>Sequência de escape</th>
  </tr>
  <tr>
   <td>U+000A</td>
   <td>Line Feed</td>
   <td>&lt;LF&gt;</td>
   <td>Caractere de nova linha em sistemas UNIX.</td>
   <td>\n</td>
  </tr>
  <tr>
   <td>U+000D</td>
   <td>Carriage Return</td>
   <td>&lt;CR&gt;</td>
   <td>Caractere de nova linha nos sistemas Commodore e nos primeiros Mac's.</td>
   <td>\r</td>
  </tr>
  <tr>
   <td>U+2028</td>
   <td>Line Separator</td>
   <td>&lt;LS&gt;</td>
   <td><a href="http://en.wikipedia.org/wiki/Newline">Wikipedia</a></td>
   <td></td>
  </tr>
  <tr>
   <td>U+2029</td>
   <td>Paragraph Separator</td>
   <td>&lt;PS&gt;</td>
   <td><a href="http://en.wikipedia.org/wiki/Newline">Wikipedia</a></td>
   <td></td>
  </tr>
 </tbody>
</table>

<h2 id="Comentários">Comentários</h2>

<p>Comentários são usados para inserir dicas, notas, sugestões ou alertas no código JavaScript. Isto pode tornar mais fácil ler ou entender o que o código faz. Também pode ser usado para desabilitar código, evitando sua execução; isto pode ser uma valiosa ferramenta na hora de debugar seu código.</p>

<p>JavaScript possui duas formas de inserir comentário no código.</p>

<p>O primeiro é com o uso de duas barras <code>//</code>; isso faz com que qualquer coisa escrita a seguir, e na mesma linha, se torne comentário. Por exemplo:</p>

<pre class="brush: js">function comment() {
  // Isto é um comentário de uma linha em JavaScript
  console.log('Hello world!');
}
comment();
</pre>

<p>A segunda forma é com o uso de <code>/* */</code>, que é muito mais flexível.</p>

<p>Por exemplo, você pode usá-lo em uma única linha:</p>

<pre class="brush: js">function comment() {
  /* Isto é um comentário de uma linha em JavaScript */
  console.log('Hello world!');
}
comment();</pre>

<p>Ou pode fazer um comentário de várias linhas, desta forma:</p>

<pre class="brush: js">function comment() {
  /* Este é um comentário de várias linhas. Observe que
 não precisamos encerrar o comentário até terminar. */
  console.log('Hello world!');
}
comment();</pre>

<p>Você também pode usá-lo no meio de uma linha, se quiser, porém isto pode tornar seu código mais difícil de ler, portanto use com cautela:</p>

<pre class="brush: js">function comment(x) {
  console.log('Hello ' + x /* insira o valor de x */ + ' !');
}
comment('world');</pre>



<p>Além disso, você pode usá-lo para desativar algum código para evitar que seja executado, envolvendo o código em um comentário, assim:</p>

<pre class="brush: js">function comment() {
  /* console.log('Hello world!'); */
}
comment();</pre>

<p>Neste caso, a função <code>console.log()</code> nunca será invocada, pois está comentada. Qualquer quantidade de linhas de código podem ser desabilitadas desta forma.</p>

<h2 id="Palavras-chave">Palavras-chave</h2>

<h3 id="Palavras-chave_reservadas_do_ECMAScript_2015">Palavras-chave reservadas do ECMAScript 2015</h3>

<ul class="threecolumns">
 <li>{{jsxref("Statements/break", "break")}}</li>
 <li>{{jsxref("Statements/switch", "case")}}</li>
 <li>{{jsxref("Statements/try...catch", "catch")}}</li>
 <li>{{jsxref("Statements/class", "class")}}</li>
 <li>{{jsxref("Statements/const", "const")}}</li>
 <li>{{jsxref("Statements/continue", "continue")}}</li>
 <li>{{jsxref("Statements/debugger", "debugger")}}</li>
 <li>{{jsxref("Statements/default", "default")}}</li>
 <li>{{jsxref("Operators/delete", "delete")}}</li>
 <li>{{jsxref("Statements/do...while", "do")}}</li>
 <li>{{jsxref("Statements/if...else", "else")}}</li>
 <li>{{jsxref("Statements/export", "export")}}</li>
 <li>{{jsxref("Statements/class", "extends")}}</li>
 <li>{{jsxref("Statements/try...catch", "finally")}}</li>
 <li>{{jsxref("Statements/for", "for")}}</li>
 <li>{{jsxref("Statements/function", "function")}}</li>
 <li>{{jsxref("Statements/if...else", "if")}}</li>
 <li>{{jsxref("Statements/import", "import")}}</li>
 <li>{{jsxref("Operators/in", "in")}}</li>
 <li>{{jsxref("Operators/instanceof", "instanceof")}}</li>
 <li>{{jsxref("Operators/new", "new")}}</li>
 <li>{{jsxref("Statements/return", "return")}}</li>
 <li>{{jsxref("Operators/super", "super")}}</li>
 <li>{{jsxref("Statements/switch", "switch")}}</li>
 <li>{{jsxref("Operators/this", "this")}}</li>
 <li>{{jsxref("Statements/throw", "throw")}}</li>
 <li>{{jsxref("Statements/try...catch", "try")}}</li>
 <li>{{jsxref("Operators/typeof", "typeof")}}</li>
 <li>{{jsxref("Statements/var", "var")}}</li>
 <li>{{jsxref("Operators/void", "void")}}</li>
 <li>{{jsxref("Statements/while", "while")}}</li>
 <li>{{jsxref("Statements/with", "with")}}</li>
 <li>{{jsxref("Operators/yield", "yield")}}</li>
</ul>

<h3 id="Palavras-chave_reservadas_para_uso_futuro">Palavras-chave reservadas para uso futuro</h3>

<p>As seguintes palavras-chave estão reservadas para uso futuro na especificação ECMAScript. Atualmente elas não tem funcionalidade, mas poderão ter no futuro, portanto elas também não podem ser usadas como identificadores.</p>

<p>Estes sempre são reservados:</p>

<ul>
 <li><code>enum</code></li>
</ul>

<p>Os seguintes são reservados apenas quando o código está em modo estrito (<em>strict mode</em>):</p>

<ul class="threecolumns">
 <li><code>implements</code></li>
 <li><code>interface</code></li>
 <li>{{jsxref("Statements/let", "let")}}</li>
 <li><code>package</code></li>
 <li><code>private</code></li>
 <li><code>protected</code></li>
 <li><code>public</code></li>
 <li><code>static</code></li>
</ul>

<p>Os seguintes são reservados apenas quando são encontrados no código do módulo:</p>

<ul>
 <li><code>await</code></li>
</ul>

<h4 id="Palavras-chave_reservadas_para_uso_futuro_em_versões_antigas">Palavras-chave reservadas para uso futuro em versões antigas</h4>

<p>As seguintes palavras-chave foram reservadas para uso futuro em especificações antigas do ECMAScript (ECMAScript 1 até 3).</p>

<ul class="threecolumns">
 <li><code>abstract</code></li>
 <li><code>boolean</code></li>
 <li><code>byte</code></li>
 <li><code>char</code></li>
 <li><code>double</code></li>
 <li><code>final</code></li>
 <li><code>float</code></li>
 <li><code>goto</code></li>
 <li><code>int</code></li>
 <li><code>long</code></li>
 <li><code>native</code></li>
 <li><code>short</code></li>
 <li><code>synchronized</code></li>
 <li><code>throws</code></li>
 <li><code>transient</code></li>
 <li><code>volatile</code></li>
</ul>

<p>Além disso, os literais <code>null</code>, <code>true</code>, e <code>false</code> não podem ser usados como identificadores em ECMAScript.</p>

<h3 id="Uso_de_palavras-chave_reservadas">Uso de palavras-chave reservadas</h3>

<p>Palavras reservadas atualmente só não podem ser usadas como identificadores . Como descrito em <a href="http://es5.github.com/#A.1">es5.github.com/#A.1</a>, não há problema em usar <font face="consolas, Liberation Mono, courier, monospace">palavras reservadas desta forma</font>.</p>

<pre class="brush: js">a.import
a['import']
a = { import: 'test' }.
</pre>

<p>Por outro lado, o seguinte é ilegal por quê a palavra reservada "<em>import</em>" está sendo usada como identificador. Identificadores podem ser usados em declaração de expressões e funções.</p>

<pre class="brush: js">function import() {} // Proibido.</pre>

<h2 id="Literais">Literais</h2>

<h3 id="Null">Null</h3>

<p>Veja também <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/null"><code>null</code></a> para mais informações.</p>

<pre class="brush: js">null</pre>

<h3 id="Booleanos">Booleanos</h3>

<p>Veja também <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean"><code>Boolean</code></a> para mais informações.</p>

<pre class="brush: js">true
false</pre>

<h3 id="Números">Números</h3>

<h4 id="Decimal">Decimal</h4>

<pre class="brush: js">1234567890
42

// Cuidado com o uso precedido de zero:
0888 // 888 convertido como decimal
0777 // Convertido como octal, 511 em decimal
</pre>

<p>Veja que números decimais podem começar com zero (<code>0</code>) seguido de outro dígito decimal, porém se todos dígitos após o zero inicial forem menores que 8, o número é interpretado como um número octal. Isso não vai disparar um erro em JavaScript, veja {{bug(957513)}}. Veja também esta página sobre conversão de tipo <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseInt#Octal_interpretations_with_no_radix"><code>parseInt()</code></a>.</p>

<h4 id="Binário">Binário</h4>

<p>Números binários em JavaScript são iniciados em zero seguido da letra "B" em maiúsculo ou minúsculo (<code>0b</code> ou <code>0B</code>). Esta sintaxe é nova no ECMAScript 2015, por isso verifique a compatibilidade do navegador. Se o dígito seguinte ao <code>0b</code> não for 0 ou 1, o seguinte <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError">erro de sintaxe</a> é disparado: "Missing binary digits after 0b".</p>

<pre class="brush: js">var FLT_SIGNBIT  = 0b10000000000000000000000000000000; // 2147483648
var FLT_EXPONENT = 0b01111111100000000000000000000000; // 2139095040
var FLT_MANTISSA = 0B00000000011111111111111111111111; // 8388607</pre>

<h4 id="Octal">Octal</h4>

<p>Números octais em JavaScript são escritos com zero inicial seguido da letra "O" em maiúsculo ou minúsculo (<code>0o</code> ou <code>0O)</code>. Esta sintaxe é nova no ECMAScript 2015, por isso verifique a compatibilidade do navegador. Se os dígitos após o <code>0o não forem octais válidos</code> (01234567), o seguinte <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError">erro de sintaxe</a> será disparado:  "Missing octal digits after 0o".</p>

<pre class="brush: js">var n = 0O755; // 493
var m = 0o644; // 420

// Também é possível com apenas um zero no início (veja sobre decimais acima)
0755
0644
</pre>

<h4 id="Hexadecimal">Hexadecimal</h4>

<p>Números hexadecimais em JavaScript são iniciados com zero seguido da letra "X" em maiúsculo ou minúsculo (<code>0x</code> ou <code>0X)</code>. Se os dígitos após o 0x não forem hexadecimais válidos (0123456789ABCDEF),  o seguinte <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError">erro de sintaxe</a> será disparado: "Identifier starts immediately after numeric literal".</p>

<pre class="brush: js">0xFFFFFFFFFFFFFFFFF // 295147905179352830000
0x123456789ABCDEF   // 81985529216486900
0XA                 // 10
</pre>

<h3 id="Objetos">Objetos</h3>

<p>Veja também {{jsxref("Object")}} e <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">Object initializer</a> para mais informações.</p>

<pre class="brush: js">var o = { a: 'foo', b: 'bar', c: 42 };

// Notação curta. Novidade no ES2015
var a = 'foo', b = 'bar', c = 42;
var o = {a, b, c};

// instead of
var o = { a: a, b: b, c: c };
</pre>

<h3 id="Arrays">Arrays</h3>

<p>Veja também {{jsxref("Array")}} para mais informações.</p>

<pre class="brush: js">[1954, 1974, 1990, 2014]</pre>

<h3 id="Strings">Strings</h3>

<pre class="brush: js">'foo'
"bar"</pre>

<h4 id="Caracteres_de_escape_em_hexadecimal">Caracteres de escape em hexadecimal</h4>

<pre class="brush: js">'\xA9' // "©"
</pre>

<h4 id="Caracteres_de_escape_em_Unicode">Caracteres de escape em Unicode</h4>

<p>A representação de caracteres de escape em Unicode requer ao menos quatro caracteres após o  <code>\u</code>.</p>

<pre class="brush: js">'\u00A9' // "©"</pre>

<h4 id="Codificação_de_caracteres_Unicode">Codificação de caracteres Unicode </h4>

<p>Novidade no ECMAScript 2015. Com a codificação de caracteres Unicode qualquer caractere pode ser representado usando sequência hexadecimal, desta forma podemos representar caracteres Unicode com sequência hexadecimal até <code>0x10FFFF</code>. Usando apenas Unicode, muitas vezes pode ser necessário utilizar mais de uma sequência para conseguir o mesmo resultado.</p>

<p>Veja também {{jsxref("String.fromCodePoint()")}} ou {{jsxref("String.prototype.codePointAt()")}}.</p>

<pre class="brush: js">'\u{2F804}'

// O mesmo usando apenas Unicode
'\uD87E\uDC04'</pre>

<h3 id="Expressões_regulares">Expressões regulares</h3>

<p>Veja também <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp"><code>RegExp</code></a> para mais informações.</p>

<pre class="brush: js">/ab+c/g

// Um "espaço vazio" em expressão regular
// Para evitar confusão com comentário de linha única
// faça o seguinte:
/(?:)/</pre>

<h3 id="Templates">Templates</h3>

<p>Veja também <a href="/en-US/docs/Web/JavaScript/Reference/template_strings">template strings</a> para mais informações .</p>

<pre class="brush: js">`texto`

`linha de texto 1
 linha de texto 2`

`texto ${expressão} texto`

tag `texto ${expressão} texto`</pre>

<h2 id="Inserção_automática_de_ponto_e_vírgula">Inserção automática de ponto e vírgula</h2>

<p> Algumas <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements">declarações</a> JavaScript precisam ser finalizadas com ponto e vírgula e, por isso, são afetadas pelo mecanismo automático de inserção de ponto evírgula (na silga ASI, em inglês):</p>

<ul>
 <li>Declaração vazia</li>
 <li><code>let</code>, <code>const</code>, declaração de variável</li>
 <li><code>import</code>, <code>export</code>, declaração module</li>
 <li>Expressões</li>
 <li><code>debugger</code></li>
 <li><code>continue</code>, <code>break</code>, <code>throw</code></li>
 <li><code>return</code></li>
</ul>

<p>A especificação ECMAScript menciona <a href="https://tc39.github.io/ecma262/#sec-rules-of-automatic-semicolon-insertion">três regras para inserção de ponto e vírgula</a>.</p>

<p>1.  Um ponto e vírgula é inserido antes, quando um <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Lexical_grammar$edit#Line_terminators">finalizador de linha</a> ou um "}" é encontrado em local não permitido pela sintaxe.</p>

<pre class="brush: js">{ 1 2 } 3

// É transformado pelo ASI em

{ 1 2 ;} 3;</pre>

<p>2.  Um ponto e vírgula é inserido ao final, quando o sinal de final de linha é detectado e o conversor não é capaz de unir a linha seguinte em um único comando.</p>

<p>Aqui o <code>++ não é interpretado como <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Increment">operador de incremento</a> aplicado à variável b por que há um finalizador de linha entre o b e ++</code> .</p>

<pre class="brush: js">a = b
++c

// É transformado pelo ASI em

a = b;
++c;
</pre>

<p>3.  Um ponto e vírgula é inserido ao final quando uma declaração com regra léxica restrita é encontrada seguida de um finalizador de linha. As declaraçõs sem regra específica de finalizador de linha são:</p>

<ul>
 <li>Operadores de incremento ou decremento (<code>++</code> and <code>--</code>)</li>
 <li><code>continue</code></li>
 <li><code>break</code></li>
 <li><code>return</code></li>
 <li><code>yield</code>, <code>yield*</code></li>
 <li><code>module</code></li>
</ul>

<pre class="brush: js">return
a + b

// É transformado pelo ASI em

return;
a + b;
</pre>

<h2 id="Especificações">Especificações</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>Definição inicial.</td>
  </tr>
  <tr>
   <td>{{SpecName('ES5.1', '#sec-7', 'Lexical Conventions')}}</td>
   <td>{{Spec2('ES5.1')}}</td>
   <td></td>
  </tr>
  <tr>
   <td>{{SpecName('ES6', '#sec-ecmascript-language-lexical-grammar', 'Lexical Grammar')}}</td>
   <td>{{Spec2('ES6')}}</td>
   <td>Adicionado: números Binarios e Octais, Unicode code point, Templates</td>
  </tr>
  <tr>
   <td>{{SpecName('ESDraft', '#sec-ecmascript-language-lexical-grammar', 'Lexical Grammar')}}</td>
   <td>{{Spec2('ESDraft')}}</td>
   <td></td>
  </tr>
 </tbody>
</table>

<h2 id="Browser_compatibility">Compatibilidade com navegadores</h2>

<p>{{CompatibilityTable}}</p>

<div id="compat-desktop">
<table class="compat-table">
 <tbody>
  <tr>
   <th>Recurso</th>
   <th>Chrome</th>
   <th>Edge</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>
   <td>{{CompatVersionUnknown}}</td>
  </tr>
  <tr>
   <td>Binary and octal numeric literals<br>
    (<code>0b</code> and <code>0o</code>)</td>
   <td>{{CompatChrome(41)}}</td>
   <td>12</td>
   <td>{{CompatGeckoDesktop(25)}}</td>
   <td>{{CompatUnknown}}</td>
   <td>{{CompatOpera(28)}}</td>
   <td>{{CompatSafari(9)}}</td>
  </tr>
  <tr>
   <td>Unicode code point escapes<br>
    (<code>\u{}</code>)</td>
   <td>{{CompatChrome(44)}}</td>
   <td>12</td>
   <td>{{CompatGeckoDesktop(40)}}</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatOpera(31)}}</td>
   <td>{{CompatSafari(9)}}</td>
  </tr>
  <tr>
   <td>Shorthand notation for object literals</td>
   <td>{{CompatChrome(43)}}</td>
   <td>12</td>
   <td>{{CompatGeckoDesktop(33)}}</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatChrome(30)}}</td>
   <td>{{CompatSafari(9)}}</td>
  </tr>
  <tr>
   <td>Template literals</td>
   <td>{{CompatChrome(41)}}</td>
   <td>12</td>
   <td>{{CompatGeckoDesktop(34)}}</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatOpera(28)}}</td>
   <td>{{CompatSafari(9)}}</td>
  </tr>
 </tbody>
</table>
</div>

<div id="compat-mobile">
<table class="compat-table">
 <tbody>
  <tr>
   <th>Recurso</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>
  <tr>
   <td>Binary and octal numeric literals (<code>0b</code> and <code>0o</code>)</td>
   <td>{{CompatUnknown}}</td>
   <td>41</td>
   <td>{{CompatGeckomobile(33)}}</td>
   <td>{{CompatUnknown}}</td>
   <td>{{CompatUnknown}}</td>
   <td>{{CompatUnknown}}</td>
  </tr>
  <tr>
   <td>Unicode code point escapes (<code>\u{}</code>)</td>
   <td>{{CompatUnknown}}</td>
   <td>{{CompatUnknown}}</td>
   <td>{{CompatGeckomobile(40)}}</td>
   <td>{{CompatUnknown}}</td>
   <td>{{CompatUnknown}}</td>
   <td>{{CompatUnknown}}</td>
  </tr>
  <tr>
   <td>Shorthand notation for object literals</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatGeckoMobile(33)}}</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatNo}}</td>
  </tr>
  <tr>
   <td>Template literals</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatGeckoMobile(34)}}</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatNo}}</td>
  </tr>
 </tbody>
</table>
</div>

<h2 id="Firefox-notas_específicas">Firefox-notas específicas</h2>

<ul>
 <li>Em versões anteriores ao Firefox 5 (JavaScript 1.8.6) palavras reservadas para uso futuro não pdem ser usadas em strict mode. Essa falha de ECMAScript foi corrigida no Firefox 5.</li>
</ul>

<h2 id="Veja_também">Veja também</h2>

<ul>
 <li><a href="http://whereswalden.com/2013/08/12/micro-feature-from-es6-now-in-firefox-aurora-and-nightly-binary-and-octal-numbers/">Jeff Walden: Binary and octal numbers</a></li>
 <li><a href="http://mathiasbynens.be/notes/javascript-escapes">Mathias Bynens: JavaScript character escape sequences</a></li>
 <li>{{jsxref("Boolean")}}</li>
 <li>{{jsxref("Number")}}</li>
 <li>{{jsxref("RegExp")}}</li>
 <li>{{jsxref("String")}}</li>
</ul>