Apply your JS skills to key Mozilla projects as an MDN Fellow! http://mzl.la/MDNFellowship

mozilla
Os seus resultados da pesquisa

    Valores, variáveis e literais

    Esta tradução está incompleta. Ajude atraduzir este artigo.

    Esse capítulo trata sobre os valores reconhecidos pelo JavaScript e descreve os componentes principais de expressões em JavaScript: variáveis, constantes e literais.

    Valores

    O JavaScript reconhece os cinco tipos de valores primitivos abaixo:

    Tipo Exemplos de valores digitados / Notas
    Números 42, 3.14159
    Lógico (Booleano) verdadeiro / falso
    Strings "Olá"
    null Uma palavra-chave especial que denota um valor nulo; null é também um valor primitivo. Como JavaScript diferencia letras minúsculas de maiúsculas, null é diferente de Null, NULL, ou qualquer outra variação.
    undefined Uma propriedade de alto nível cujo valor é indefinido; undefined também é um valor primitivo.

    Apesar de serem relativamente poucos, esse conjunto de tipos de dados possibilitam a execução de funções muito úteis dentro de suas aplicações.

    Objetos e funções são outros elementos fundamentais nessa linguagem. Você pode imaginar os objetos como recipientes com nomes e valores, e funções sãos os procedimentos que a sua aplicação pode executar.

    Conversão de tipos de dados

    JavaScript é uma linguagem dinamicamente tipada. Isso significa que você não precisa especificar o tipo de dado de uma variável ao declará-la, e os tipos de dados são automaticamente convertidos conforme necessário durante a execução do script. Então, por exemplo, podemos definir uma variável da seguinte forma:

    var resposta = 42;
    

    Depois disso, você pode atribuir um valor do tipo string a essa mesma variável, por exemplo:

    resposta = "Obrigado pelo peixe...";
    

    Como JavaScript é uma linguagem dinamicamente tipada, essa atribuição não causa um erro.

    Em expressões que envolvem valores numéricos e strings usando o operador +, o JavaScript converte valores numéricos em strings. Por exemplo, considere o código abaixo:

    x = "A resposta é " + 42 // retorna "A resposta é 42"
    y = 42 + " é a resposta" // retorna "42 é a resposta"
    

    Em declarações usando outros operadores, o JavaScript não converte valores numéricos em strings. Por exemplo:

    "37" - 7 // retorna 30
    "37" + 7 // retorna "377"
    

    Convertendo strings em números

    No caso em que um valor que representa um número estiver em memória como uma string, existem alguns métodos para fazer a conversão.

    parseInt() e parseFloat()

    Veja também as páginas sobre: parseInt() e parseFloat().

    parseInt retornará somente números inteiros, não sendo útil para lidar com decimais. Além disso, uma boa prática para usar parseInt é sempre incluir o parâmetro radix. O parãmetro radix é usado para especificar qual sistema numérico será utilizado.

    Operador de adição

    Um método alternativo para se obter um número a partir de uma string é através do operador +.

    "1.1" + "1.1" = "1.11.1"
    (+"1.1") + (+"1.1") = 2.2   // Nota: os parênteses foram adicionados para tornar o código mais claro, não são obrigatórios.

    Variáveis

    Você utiliza variáveis como nomes simbólicos para valores em sua aplicação. Nomes de variáveis, chamados de identificadores, devem seguir algumas regras.

    Em JavaScript, um identificador deve começar com uma letra, um underscore (_) ou um cifrão ($); os caracteres seguintes podem também ser dígitos (0-9). Como JavaScript é uma linguagem que diferencia maiúsculas e minúsculas, as letras incluem os caracteres de "A" a "Z" (maíusculos) bem como os caracteres de "a" a "z" (minúsculos).

    A partir do JavaScript 1.5, você pode usar letras ISO 8859-1 ou Unicode como å e ü nos identificadores. Você também pode usar \uXXXX Sequências de escape Unicode como caracteres nos identificadores.

    Alguns exemplos de nomes permitidos são Numero_acertos, temp99, e _nome.

    Declarando variáveis

    Você pode declarar variáveis de duas maneiras:

    • Com a palavra-chave var. Por exemplo: var x = 42. Esta sintaxe pode ser usada para definir variáveis locais e globais.
    • Simplesmente atribuindo um valor a ela. Por exemplo: x = 42. Isso define uma variável global que não pode ser alterada em nível local. Isto gera um aviso strict do JavaScript e você não deve utilizar esta variante.

    Avaliando variáveis

    Uma variável declarada usando var sem receber um valor inicial tem o valor undefined.

    Uma tentativa de acessar uma variável não declarada resultará em um erro de referência (ReferenceError):

    var a;
    console.log("O valor de a é " + a); // exibe "O valor de a é undefined"
    console.log("O valor de b é " + b); // resulta em um ReferenceError
    

    Você pode usar o undefined para determinar se uma variável possui um valor ou não. No código abaixo, a variável entrada não recebe um valor e a declaração if é avaliada como true.

    var entrada;
    if(entrada === undefined){
      facaIsto();
    } else {
      facaAquilo();
    }
    

    O valor undefined comporta-se como false quando usado de forma booleana. Por exemplo, o código abaixo executa a função minhaFuncao porque o elemento de minhaMatriz não foi definido:

    var minhaMatriz = new Array();
    if (!minhaMatriz[0]) minhaFuncao(); 
    

    O valor undefined é convertido em NaN quando usado em um contexto numérico.

    var a;
    a + 2 = NaN

    Quando você avalia uma variável nula, o valor nulo tem comportamento de 0 em um contexto numérico e de falso em um contexto booleano. Por exemplo:

    var n = null;
    console.log(n * 32); // exibe 0
    

    Escopo de variáveis

    Quando você declara uma variável fora de qualquer função, ela é chamada de variável global, pois ela fica disponível para qualquer outro código no documento atual. Quando você declara uma variável dentro de uma função, ela é chamada de variável local, pois ela só fica disponível dentro da função.

    JavaScript não possui escopo de declaração de bloco. Em vez disso, o escopo será local ao código onde o bloco está contido. O seguinte código, por exemplo, irá imprimir 5 no console porque o escopo de x é a função (ou contexto global) na qual x é declarado e não o bloco que, neste caso, é uma declaração if.

    if (true) {
      var x = 5;
    }
    console.log(x);
    

    Outra coisa atípica sobre variáveis em JavaScript é que você pode fazer referência a uma variável declarada mais tarde sem disparar uma exceção. Este conceito é conhecido como içamento: variáveis em JavaScript são em certo sentido "içadas" ou elevadas ao topo da função ou declaração. Entretanto, variáveis que ainda não estiverem inicializadas irão retornar um valor undefined.

    /**
     * Exemplo 1
     */
    console.log(x === undefined); // imprime "true"
    var x = 3;
    
    
    /**
     * Exemplo 2
     */
    // irá retornar undefined
    var minhavariavel = "meu valor";
    
    (function() {
      console.log(minhavariavel); // undefined
      var minhavariavel = "valor local";
    })();
    

    O Exemplo 2 acima é interpretado da mesma forma que:

    var minhavariavel = "meu valor";
    
    (function() {
      var minhavariavel;
      console.log(minhavariavel); // undefined
      minhavariavel = "valor local";
    })();

    Por causa do içamento, todas as declarações var em uma função devem ser colocadas o mais próximo possível do topo da função. Esta boa prática aumenta a clareza do código.

    Variáveis globais

    Variáveis globais são na verdade propriedades do objeto global. Em páginas web o objeto global é o objeto window, de forma que você pode acessar variáveis globais utilizando a sintaxe window.variavel.

    Consequentemente, você pode acessar variáveis globais declaradas em uma janela ou frame a partir de outra janela ou frame especificando seu nome. Por exemplo, se uma variável chamada numeroTelefone é declarada em um documento FRAMESET, você pode fazer referência a esta variável a partir de um frame filho na forma parent.numeroTelefone.

    Constantes

    Você pode criar uma constante nomeada e somente de leitura com a palavra-chave const. A sintaxe de um identificador de constante é a mesma de um identificador de variável: deve começar com uma letra ou underscore e pode conter caracteres alfabéticos, numéricos ou underscores.

    const prefixo = '212';
    

    Uma constante não pode ter seu valor alterado através de atribuição nem pode ser redeclarada enquanto o script esteja em execução.

    As regras de escopo para constantes são as mesmas daquelas para variáveis, exceto pelo fato de que a palavra-chave const é sempre obrigatória, mesmo para constantes globais. Se a palavra-chave é omitida, assume-se que o identificador representa uma variável.

    Você não pode declarar uma constante com o mesmo nome de uma função ou variável no mesmo escopo. Por exemplo:

    // ISTO CAUSARÁ UM ERRO
    function f() {};
    const f = 5;
    
    // ISTO TAMBÉM CAUSARÁ UM ERRO
    function f() {
      const g = 5;
      var g;
    
      //declarações
    }
    

    Literais

    Você utiliza literais para representar valores em JavaScript. Estes valores são fixos, não variáveis, informados literalmente em seu script. Esta seção descreve os seguintes tipos de literais:

    Literais de matriz

    Uma matriz literal é uma lista de zero ou mais expressões onde cada uma representa um elemento de matriz, circundado por colchetes ([]). Quando você cria uma matriz de forma literal ela é inicializada com os valores especificados como elementos e seu comprimento é definido como o número de argumentos especificados.

    O exemplo a seguir cria a matriz cafes com três elementos e comprimento três:

    var cafes = ["Tostado Fracês", "Colombiano", "Kona"];
    

    Nota Um literal de matriz é um tipo de inicializador de objeto. Veja Utilizando inicializadores de objeto.

    Se uma matriz é criada utilizando um literal em um script de alto nível, o JavaScript interpreta a matriz cada vez que avalia a expressão contendo o literal. Além disso, um literal utilizado em uma função é criado cada vez que a função é chamada.

    Literais de matriz são também objetos Array. Veja Objeto Array para mais detalhes.

    Vírgulas extras em literais de matriz

    Você não precisa especificar todos os elementos em um literal de matriz. Se você coloca duas vírgular em uma linha, a matriz é criada com valor undefined para os elementos não especificados. O exemplo a seguir cria a matriz peixe:

    var peixe = ["Leão", , "Anjo"];
    

    Esta matriz possui dois elementos com valor e um elemento vazio (peixe[0] é "Leão", peixe[1] é undefined e peixe[2] é "Anjo").

    Se você inclui uma vírgula extra no final da lista de elementos, a vírgula é ignorada. No exemplo a seguir, o comprimento da matriz é três; não existe elemento minhaLista[3]. Todas as outras vírgulas na lista indicam um novo elemento. (Nota vírgulas extras podem criar erros em versões antigas de navegadores e é uma boa prática removê-las)

    var minhaLista = ['casa', , 'escola', ];
    

    No exemplo a seguir, o comprimento da matriz é quatro, e minhaLista[0] e minhaLista[2] estão faltando.

    var minhaLista = [ , 'casa', , 'escola'];
    

    No exemplo seguinte, o comprimento da matriz é quatro e minhaLista[1] e minhaLista[3] estão faltando. Somente a última vírgula é ignorada.

    var minhaLista = ['casa', , 'escola', , ];
    

    Entender o comportamento de vírgulas extras é importante para entender o JavaScript como linguagem. Entretanto, ao escrever seu próprio código, declarar os elementos faltantes explicitamente como undefined aumentará a clareza e a manutenibilidade do seu código.

    Literais de booleano

    O tipo booleano possui dois valores literais: true e false.

    Não confunda os valores primitivos true e false com os valores verdadeiro e falso do objeto Boolean. O objeto Boolean é um invólucro do tipo de dado booleano primitivo. Veja Objeto Boolean para mais informações.

    Inteiros

    Inteiros podem ser expressos em decimal (base 10), hexadecimal (base 16) e octal (base 8).

    • O literal de inteiro decimal consiste em uma sequência de dígitos sem o prefixo 0 (zero).
    • O prefixo 0 (zero) em um literal de inteiro indica que ele está em octal. Inteiros octais podem conter somente os dígitos 0-7.
    • O prefixo 0x (ou 0X) indica hexadecimal. Inteiros hexadecimais podem conter dígitos (0-9) e as letras a-f e A-F.

    Literais de inteiro octal estão obsoletos e foram removidos do padrão ECMA-262 Edição 3 (no modo estrito). O JavaScript 1.5 ainda os suporta por retrocompatibilidade.

    Alguns exemplos de literais de inteiro são:

    0, 117 e -345 (decimal, base 10)
    015, 0001 e -077 (octal, base 8) 
    0x1123, 0x00111 e -0xF1A7 (hexadecimal, "hex" ou base 16)
    

    Literais de ponto flutuante

    Um literal de ponto flutuante pode ter as seguintes partes:

    • Um inteiro decimal que pode ter sinal (precedido por "+" ou "-"),
    • Um ponto decimal ("."),
    • Uma fração (outro número decimal),
    • Um expoente.

    A parte de expoente é um "e" ou um "E" seguido de um inteiro, que pode ter sinal (precedido por "+" ou "-"). Um literal de ponto flutuante deve possuir ao menos um dígito e ou um ponto decimal ou "e" (ou "E").

    Alguns exemplos de literais de ponto flutuante são 3.1415, -3.1E12, .1e12 e 2E-12.

    De forma mais sucinta, a sintaxe é:

    [digitos][.digitos][(E|e)[(+|-)]digitos]
    

    Por exemplo:

    3.14
    2345.789
    .3333333333333333333
    

    Literias de objeto

    Um literal de objeto é uma lista de zero ou mais pares de nomes de propriedades de um objeto e valores associados, circundados por chaves ({}). Você não deve utilizar um literal de objeto no começo de uma declaração. Isto fará com que um erro seja criado ou que o comportamento não seja o que você espera, já que a chave de abertura ({) será interpretada como começo de um bloco.

    A seguir um exemplo de um literal de objeto. O primeiro elemento do objeto carro define uma propriedade, meuCarro; o segundo elemento, a propriedade getCarro, invoca a função (TiposCarro("Honda")); o terceiro elemento, a propriedade especial, utiliza uma variável existente (Vendas).

    var Vendas = "Toyota";
    
    function TiposCarro(nome) {
      return (nome == "Honda") ?
        nome :
        "Desculpe, não vendemos " + nome + "." ;
    }
    
    var carro = { meuCarro: "Saturn", getCarro: TiposCarro("Honda"), especial: Vendas };
    
    console.log(carro.meuCarro); // Saturn
    console.log(carro.getCarro); // Honda
    console.log(carro.especial); // Toyota 
    

    Additionally, you can use a numeric or string literal for the name of a property or nest an object inside another. The following example uses these options.

    var carro = { variosCarros: {a: "Saab", "b": "Jeep"}, 7: "Mazda" };
    
    console.log(carro.variosCarros.b); // Jeep
    console.log(carro[7]); // Mazda
    

    Repare:

    var foo = {a: "alfa", 2: "dois"};
    console.log(foo.a);    // alfa
    console.log(foo[2]);   // dois
    //console.log(foo.2);  // Erro: falta ) depois da lista de argumentos
    //console.log(foo[a]); // Erro: a não está definido
    console.log(foo["a"]); // alfa
    console.log(foo["2"]); // dois
    

    String literals

    Um literal de string é um conjunto de zero ou mais caracteres circundados por aspas duplas (") ou simples ('). Um string deve ser delimitada por aspas do mesmo tipo, isto é, sejam ambas aspas duplas ou ambas aspas simples. A seguir exemplos de literais de string:

    • "foo"
    • 'bar'
    • "1234"
    • "uma linha \n outra linha"
    • "caixa d'água"

    Você pode chamar quaisquer métodos do objeto String em um valor literal de string que o JavaScript converte automaticamente a string literal em um objeto String temporário, chama o método e então descarta o objeto. Você pode também utilizar a propriedade String.length com uma string literal:

    "caixa d'água".length
    

    Você deve utilizar literais de string a menos que precise utilizar especificamente um objeto String. Veja Objeto String para mais detalhes sobre objetos String.

    Utilizando caracteres especiais em strings

    Além de caracteres comuns, você pode também incluir caracteres especiais em strings como as mostradas no exemplo a seguir.

    "uma linha \n outra linha"
    

    A tabela a seguir lista os caracteres especiais que você pode utilizar em strings JavaScript.

    Table 2.1 Caracteres especiais em JavaScript
    Character Meaning
    \b Backspace
    \f Quebra de formulário
    \n Nova linha
    \r Retorno de carro
    \t Tabulação
    \v Tabulação vertical
    \' Apóstrofo ou aspa simples
    \" Aspas duplas
    \\ Contrabarra (\)
    \XXX Caractere com a codificação Latin-1 especificada por até três dígitos octais XXX entre 0 e 377. Por exemplo, \251 é a sequência octal do símbolo de copyright.
    \xXX Caractere com a codificação Latin-1 especificada pelos dois dígitos hexadecimais XX entre 00 e FF. Por exemplo, \xA9 é a sequência hexadecimal do símbolo de copyright.
    \uXXXX Caractere Unicode especificado pelos quatro dígitos decimais XXXX. Por exemplo, \u00A9 é a sequência Unicode do símbolo de copyright. Veja Sequências de escapamento Unicode.

    Escapando caracteres

    Para caracteres não listados na Tabela 2.1 uma contrabarra inicial é ignorada, mas este uso está obsoleto e deve ser evitado.

    Você pode inserir uma aspa dentro de uma string utilizando uma contrabarra antes. Isto é chamado de escapar a aspa. Por exemplo:

    var citacao = "Ele leu \"A cremação de Sam McGee\" de R.W. Service.";
    console.log(citacao);
    

    O resultado disto seria:

    Ele leu "A cremação de Sam McGee" de R.W. Service.
    

    Para incluir uma contrabarra literal dentro de uma string você deve escapar o caractere de contrabarra. Por exemplo, para atribuir o caminho de arquivo c:\temp a uma string, utilize o seguinte:

    var inicio = "c:\\temp";
    

    Você pode também escapar quebras de linha colocando uma contrabarra antes. Tanto a contrabarra quanto a quebra de linha são removidas do valor da string.

    var str = "esta string \
    está quebrada \
    em várias \
    linhas."
    console.log(str);   // esta string está quebrada em várias linhas.
    

    Although JavaScript does not have "heredoc" syntax, you can get close by adding a linebreak escape and an escaped linebreak at the end of each line:

    var poema = 
    "Rosas são vermelhas,\n\
    Violetas são azuis.\n\
    Eu sou esquizofrênico,\n\
    E também eu o sou."
    

    Unicode

    Unicode é um padrão de codificação de caráter universal para o intercâmbio e exibição das principais línguas escritas. Abrange as línguas das Américas, Europa, Oriente Médio, África, Índia, Ásia e Pacifica, bem como os scripts históricos e símbolos técnicos. Unicode permite o intercâmbio, processamento e exibição de textos em vários idiomas, bem como o uso de símbolos matemáticos e técnicos comuns. Ele espera resolver problemas de internacionalização da computação multilingue, como diferentes padrões de caráter nacional. Nem todos os scripts modernos ou arcaicas, no entanto, são suportadas atualmente.

    The Unicode character set can be used for all known encoding. Unicode is modeled after the ASCII (American Standard Code for Information Interchange) character set. It uses a numerical value and name for each character. The character encoding specifies the identity of the character and its numeric value (code position), as well as the representation of this value in bits. The 16-bit numeric value (code value) is defined by a hexadecimal number and a prefix U, for example, U+0041 represents A. The unique name for this value is LATIN CAPITAL LETTER A.

    Unicode is not supported in versions of JavaScript prior to 1.3.

    Unicode compatibility with ASCII and ISO

    Unicode is fully compatible with the International Standard ISO/IEC 10646-1; 1993, which is a subset of ISO 10646.

    Several encoding standards (including UTF-8, UTF-16 and ISO UCS-2) are used to physically represent Unicode as actual bits.

    The UTF-8 encoding of Unicode is compatible with ASCII characters and is supported by many programs. The first 128 Unicode characters correspond to the ASCII characters and have the same byte value. The Unicode characters U+0020 through U+007E are equivalent to the ASCII characters 0x20 through 0x7E. Unlike ASCII, which supports the Latin alphabet and uses a 7-bit character set, UTF-8 uses between one and four octets for each character ("octet" meaning a byte, or 8 bits.) This allows for several million characters. An alternative encoding standard, UTF-16, uses two octets to represent Unicode characters. An escape sequence allows UTF-16 to represent the whole Unicode range by using four octets. The ISO UCS-2 (Universal Character Set) uses two octets.

    JavaScript and Navigator support for UTF-8/Unicode means you can use non-Latin, international, and localized characters, plus special technical symbols in JavaScript programs. Unicode provides a standard way to encode multilingual text. Since the UTF-8 encoding of Unicode is compatible with ASCII, programs can use ASCII characters. You can use non-ASCII Unicode characters in the comments, string literals, identifiers, and regular expressions of JavaScript.

    Unicode escape sequences

    You can use the Unicode escape sequence in string literals, regular expressions, and identifiers. The escape sequence consists of six ASCII characters: \u and a four-digit hexadecimal number. For example, \u00A9 represents the copyright symbol. Every Unicode escape sequence in JavaScript is interpreted as one character.

    The following code returns the copyright symbol and the string "Netscape Communications".

    var x = "\u00A9 Netscape Communications";

    The following table lists frequently used special characters and their Unicode value.

    Table 2.2 Unicode values for special characters
    Category Unicode value Name Format name
    White space values \u0009 Tab <TAB>
    \u000B Vertical Tab <VT>
    \u000C Form Feed <FF>
    \u0020 Space <SP>
    Line terminator values \u000A Line Feed <LF>
    \u000D Carriage Return <CR>
    Additional Unicode escape sequence values \u0008 Backspace <BS>
    \u0009 Horizontal Tab <HT>
    \u0022 Double Quote "
    \u0027 Single Quote '
    \u005C Backslash \

    The JavaScript use of the Unicode escape sequence is different from Java. In JavaScript, the escape sequence is never interpreted as a special character first. For example, a line terminator escape sequence inside a string does not terminate the string before it is interpreted by the function. JavaScript ignores any escape sequence if it is used in comments. In Java, if an escape sequence is used in a single comment line, it is interpreted as an Unicode character. For a string literal, the Java compiler interprets the escape sequences first. For example, if a line terminator escape character (e.g., \u000A) is used in Java, it terminates the string literal. In Java, this leads to an error, because line terminators are not allowed in string literals. You must use \n for a line feed in a string literal. In JavaScript, the escape sequence works the same way as \n.

    Unicode characters in JavaScript files

    Earlier versions of Gecko assumed the Latin-1 character encoding for JavaScript files loaded from XUL. Starting with Gecko 1.8, the character encoding is inferred from the XUL file's encoding. Please see International characters in XUL JavaScript for more information.

    Displaying characters with Unicode

    You can use Unicode to display the characters in different languages or technical symbols. For characters to be displayed properly, a client such as Mozilla Firefox or Netscape needs to support Unicode. Moreover, an appropriate Unicode font must be available to the client, and the client platform must support Unicode. Often, Unicode fonts do not display all the Unicode characters. Some platforms, such as Windows 95, provide partial support for Unicode.

    To receive non-ASCII character input, the client needs to send the input as Unicode. Using a standard enhanced keyboard, the client cannot easily input the additional characters supported by Unicode. Sometimes, the only way to input Unicode characters is by using Unicode escape sequences.

    For more information on Unicode, see the Unicode Home Page and The Unicode Standard, Version 2.0, published by Addison-Wesley, 1996.

    Resources

    Etiquetas do documento e colaboradores

    Contribuíram para esta página: pkelbert, ewertonorg, arielserafini, teoli, felipe.uliana, raphaelfabeni
    Última atualização por: ewertonorg,