Get real-time assistance with your coding queries. Try AI Help now!

References Guides Plus Curriculum NEW Blog Play AI Help BETA Theme Log in Sign up for free
Tecnologia Web para desenvolvedores JavaScript Referência JavaScript Gramática léxica Português (do Brasil)

This page was translated from English by the community. Learn more and join the MDN Web Docs community.

Filter
Intermediário
Avançado Gramática léxica In this article
Caracteres de controle
Referências Esta página descreve a gramática léxica da linguagem JavaScript. O código fonte de um script Espaço em branco
Objetos pré-definidos ECMAScript é lido da esquerda para direita e traduzido em uma sequência de elementos de entrada, Finalizadores de linha
como símbolos, caracteres de controle, finalizadores de linha, comentários ou espaços em branco.
Expressões e operadores ECMAScript também define certas palavras-chave e literais e possui regras para inserção automática Comentários
Afirmações e declarações de ponto e vírgula ao final de declarações. Palavras-chave
Funções
Classes
Caracteres de controle Literais
Inserção automática de ponto
Caracteres de controle não possuem representação visual, mas são usados para controlar a e vírgula
Expressões Regulares interpretação do código. Especificações
Erros Compatibilidade com
Mais conteúdo Código Nome Abreviação Descrição navegadores
Visão geral das Tecnologias JavaScript Zero Colocado entre caracteres para evitar que sejam
Firefox-notas específicas
width <ZWNJ> visualmente ligados (fundidos) em algumas linguagens Veja também
Gramática léxica U+200C
non-
joiner (Wikipedia ).
Protocolos de iteração
Strict mode - Modo estrito Zero Colocado entre caracteres que podem não estar
Template literals width <ZWJ> normalmente conectados, para que estes caracteres
U+200D

joiner sejam renderizados com suas devidas ligações em certas

Trailing commas linguagens (Wikipedia ).
Funcionalidades depreciadas Byte
order <BOM> Usado no início do script para marcá-lo como Unicode e
U+FEFF

mark especificar a ordem de bytes do código (Wikipedia ).

Espaço em branco
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. Ferramentas de minificação podem ser
usadas para remover espaços em branco do código reduzindo, assim, a quantidade de dados que
precisam ser transferidos.

Código Nome Abreviação Descrição Sequência de

escape
U+0009 Character tabulation <HT> Tabulação horizontal \t
U+000B Line tabulation <VT> Tabulação vertical \v
U+000C Form feed <FF> Pular para próxima página \f
(Wikipedia ).
U+0020 Space <SP> Espaço normal
U+00A0 No-break space <NBSP> Espaço normal, sem
marcar quebra de linha
Others Other Unicode space <USP> Outros tipos de espaço.
characters Veja na Wikipedia

Finalizadores de linha
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 processo automático de inserção de ponto e vírgula. Em expressões regulares os
finalizadores de linha podem ser indicados com a classe \s.
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).

Código Nome Abreviação Descrião Sequência de

escape
U+000A Line Feed <LF> Caractere de nova linha em \n
sistemas UNIX.
Carriage Caractere de nova linha nos
U+000D Return <CR> sistemas Commodore e nos \r
primeiros Mac's.
Line
U+2028 Separator <LS> Wikipedia
Paragraph
U+2029 Separator <PS> Wikipedia

Comentários
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.
JavaScript possui duas formas de inserir comentário no código.
O primeiro é com o uso de duas barras // ; isso faz com que qualquer coisa escrita a seguir, e na
mesma linha, se torne comentário. Por exemplo:
JS

function comment() {
// Isto é um comentário de uma linha em JavaScript
[Link]("Hello world!");
}
comment();

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

Por exemplo, você pode usá-lo em uma única linha:
JS

function comment() {
/* Isto é um comentário de uma linha em JavaScript */
[Link]("Hello world!");
}
comment();

Ou pode fazer um comentário de várias linhas, desta forma:

JS

function comment() {
/* Este é um comentário de várias linhas. Observe que
não precisamos encerrar o comentário até terminar. */
[Link]("Hello world!");
}
comment();

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:
JS

function comment(x) {
[Link]("Hello " + x /* insira o valor de x */ + " !");
}
comment("world");

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:
JS

function comment() {
/* [Link]('Hello world!'); */
}
comment();

Neste caso, a função [Link]() nunca será invocada, pois está comentada. Qualquer quantidade
de linhas de código podem ser desabilitadas desta forma.

Palavras-chave
Palavras-chave reservadas do ECMAScript 2015
break

case

catch

class

const

continue

debugger

default (inglês)
delete (inglês)
do

else

export

extends

finally

for

function

if

import

in

instanceof

new

return

super

switch

this

throw

try

typeof

var

void

while

with

yield

Palavras-chave reservadas para uso futuro

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.
Estes sempre são reservados:
enum

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

interface

let

package

private

protected

public

static

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

await

Palavras-chave reservadas para uso futuro em versões antigas

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

boolean

byte

char

double

final

float

goto

int

long

native

short

synchronized

throws

transient

volatile

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

Uso de palavras-chave reservadas

Palavras reservadas atualmente só não podem ser usadas como identificadores . Como descrito em
[Link]/#A.1 , não há problema em usar palavras reservadas desta forma.
JS

[Link]
a['import']
a = { import: 'test' }.

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

function import() {} // Proibido.

Literais
Null
Veja também null para mais informações.
JS

null;

Booleanos
Veja também Boolean para mais informações.
JS

true;
false;

Números
Decimal
JS

1234567890;
42;

// Cuidado com o uso precedido de zero:

0888; // 888 convertido como decimal
0777; // Convertido como octal, 511 em decimal

Veja que números decimais podem começar com zero ( 0 ) 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 Erro do Firefox 957513 . Veja também esta
página sobre conversão de tipo parseInt() .
Binário
Números binários em JavaScript são iniciados em zero seguido da letra "B" em maiúsculo ou
minúsculo ( 0b ou 0B ). Esta sintaxe é nova no ECMAScript 2015, por isso verifique a compatibilidade
do navegador. Se o dígito seguinte ao 0b não for 0 ou 1, o seguinte erro de sintaxe(inglês) é disparado:
"Missing binary digits after 0b".
JS

var FLT_SIGNBIT = 0b10000000000000000000000000000000; // 2147483648

var FLT_EXPONENT = 0b01111111100000000000000000000000; // 2139095040
var FLT_MANTISSA = 0b00000000011111111111111111111111; // 8388607

Octal
Números octais em JavaScript são escritos com zero inicial seguido da letra "O" em maiúsculo ou
minúsculo ( 0o ou 0O) . Esta sintaxe é nova no ECMAScript 2015, por isso verifique a compatibilidade
do navegador. Se os dígitos após o 0o não forem octais válidos (01234567), o seguinte erro de
sintaxe(inglês) será disparado: "Missing octal digits after 0o".
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;

Hexadecimal
Números hexadecimais em JavaScript são iniciados com zero seguido da letra "X" em maiúsculo ou
minúsculo ( 0x ou 0X) . Se os dígitos após o 0x não forem hexadecimais válidos
(0123456789ABCDEF), o seguinte erro de sintaxe(inglês) será disparado: "Identifier starts immediately
after numeric literal".
JS

0xfffffffffffffffff; // 295147905179352830000
0x123456789abcdef; // 81985529216486900
0xa; // 10

Objetos
Veja também Object e Object initializer para mais informações.
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 };

Arrays
Veja também Array para mais informações.
JS

[1954, 1974, 1990, 2014];

Strings
JS

'foo';
"bar";

Caracteres de escape em hexadecimal

JS

"\xA9"; // "©"

Caracteres de escape em Unicode

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

JS

"\u00A9"; // "©"

Codificação de caracteres Unicode

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é 0x10FFFF . Usando apenas Unicode, muitas vezes pode ser
necessário utilizar mais de uma sequência para conseguir o mesmo resultado.
Veja também [Link]() ou [Link]() .
JS

"\u{2F804}";

// O mesmo usando apenas Unicode

"\uD87E\uDC04";

Expressões regulares
Veja também RegExp para mais informações.
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:
/(?:)/

Templates
Veja também template strings para mais informações .
JS

`texto`;

`linha de texto 1
linha de texto 2`;

`texto ${expressão} texto`;

tag`texto ${expressão} texto`;

Inserção automática de ponto e vírgula

Algumas declarações 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):
Declaração vazia
let , const , declaração de variável

import , export , declaração module

Expressões
debugger

continue , break , throw

return

A especificação ECMAScript menciona três regras para inserção de ponto e vírgula .

1. Um ponto e vírgula é inserido antes, quando um finalizador de linha ou um "}" é encontrado em
local não permitido pela sintaxe.
JS

{ 1 2 } 3

// É transformado pelo ASI em

{ 1 2 ;} 3;

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.
Aqui o ++ não é interpretado como operador de incremento aplicado à variável b por que há um
finalizador de linha entre o b e ++ .

JS

a = b
++c

// É transformado pelo ASI em

a = b;
++c;

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:
Operadores de incremento ou decremento ( ++ and -- )
continue

break

return

yield , yield*
module

JS

return
a + b

// É transformado pelo ASI em

return;
a + b;

Especificações
Specification
ECMAScript Language Specification

Compatibilidade com navegadores

Report problems with this compatibility data on GitHub
diordnA rof xoferiF

tenretnI gnusmaS
diordnA weiVbeW
diordnA emorhC

diordnA arepO
SOi no irafaS
emorhC

[Link]
xoferiF
arepO
irafaS

oneD
egdE

Array literals ( [1, 2,

3] ) 1 12 1 4 1 18 4 10.1 1 1.0 4.4 1.0 0.10.0
Binary numeric literals
( 0b ) 41 12 25 28 9 41 25 28 9 4.0 41 1.0 4.0.0
Boolean literals
( true / false ) 1 12 1 3 1 18 4 10.1 1 1.0 4.4 1.0 0.10.0
Decimal numeric
literals ( 1234567890 ) 1 12 1 3 1 18 4 10.1 1 1.0 4.4 1.0 0.10.0
Hashbang ( #! )
comment syntax 74 79 67 62 13.1 74 67 53 13.4 11.0 74 1.0 0.10.0
Hexadecimal escape
sequences ( '\xA9' ) 1 12 1 4 1 18 4 10.1 1 1.0 4.4 1.0 0.10.0
Hexadecimal numeric
literals ( 0xAF ) 1 12 1 3 1 18 4 10.1 1 1.0 4.4 1.0 0.10.0

Null literal ( null )

1 12 1 3 1 18 4 10.1 1 1.0 4.4 1.0 0.10.0
Numeric separators
( 1_000_000_000_000 ) 75 79 70 62 13 75 79 No 13 11.0 75 1.2 12.5.0
Octal numeric literals
( 0o ) 41 12 25 28 9 41 25 28 9 4.0 41 1.0 4.0.0
Regular expression
literals ( /ab+c/g ) 1 12 1 5 1 18 4 10.1 1 1.0 4.4 1.0 0.10.0
Shorthand notation for
object literals 43 12 33 30 9 43 33 30 9 4.0 43 1.0 4.0.0
String literals ( 'Hello
world' ) 1 12 1 3 1 18 4 10.1 1 1.0 4.4 1.0 0.10.0

Template literals
41 12 34 28 9 41 34 28 9 4.0 41 1.0 4.0.0
Escape sequences
allowed in tagged
template literals 62 79 53 49 11 62 53 46 11 8.0 62 1.0 8.10.0

Trailing commas
1 12 1 9.5 1 18 4 10.1 1 1.0 4.4 1.0 0.10.0

Trailing comma in 91 91 No No 15 91 No No 15 16.0 91 1.17 17.5.0

dynamic import

Trailing comma in
function parameters 58 14 52 45 10 58 52 43 10 7.0 58 1.0 8.0.0
Trailing comma in
object literals 1 12 1 9.5 3 18 4 10.1 1 1.0 4.4 1.0 0.10.0
Unicode escape
sequences
( '\u00A9' ) 1 12 1 4 1 18 4 10.1 1 1.0 4.4 1.0 0.10.0
Unicode point
escapes ( \u{} ) 44 12 40 31 9 44 40 32 9 4.0 44 1.0 4.0.0
Tip: you can click/tap on a cell for more information.
Full support Partial support No support
Non-standard. Check cross-browser support before using. See implementation notes.
Has more compatibility info.

Firefox-notas específicas
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.

Veja também
Jeff Walden: Binary and octal numbers
Mathias Bynens: JavaScript character escape sequences
Boolean

Number

RegExp

String

Help improve MDN

Was this page helpful to you?
Yes No
Learn how to contribute.
This page was last modified on 15 de out. de 2023 by MDN contributors.
View this page on GitHub • Report a problem with this content

MDN Support Our communities Developers

Your blueprint for a better internet. About Product help MDN Community Web Technologies
Blog Report an issue MDN Forum Learn Web Development
Careers MDN Chat MDN Plus
Advertise with us Hacks Blog

Website Privacy Notice Cookies Legal Community Participation Guidelines

Visit Mozilla Corporation’s not-for-profit parent, the Mozilla Foundation.

Portions of this content are ©1998–2024 by individual [Link] contributors. Content available under a Creative Commons license.