JSON básico

Ben Smith

Novatec

Original English language edition published by Apress, Copyright © 2015 by Apress, Inc.. Portugueselanguage edition for Brazil copyright © 2015 by Novatec Editora. All rights reserved.

Edição original em Inglês publicada pela Apress, Copyright © 2015 by Apress, Inc. Edição em Português para o Brasil copyright © 2015 pela Novatec Editora. Todos os direitos reservados. © Novatec Editora Ltda. 2015.

Todos os direitos reservados e protegidos pela Lei 9.610 de 19/02/1998. É proibida a reprodução desta obra, mesmo parcial, por qualquer processo, sem prévia autorização, por escrito, do autor e da Editora.

Editor: Rubens Prates Tradução: Lúcia A. Kinoshita Assistente editorial: Priscila A. Yoshimatsu Revisão gramatical: Mari Kumagai Editoração eletrônica: Carolina Kuwabata ISBN: 978-85-7522-436-6 Histórico de impressões: Junho/2015

Primeira edição

Novatec Editora Ltda.

Rua Luís Antônio dos Santos 110 02460-000 – São Paulo, SP – Brasil Tel.: +55 11 2959-6529 Email: novatec@novatec.com.br Site: www.novatec.com.br Twitter: twitter.com/novateceditora Facebook: facebook.com/novatec LinkedIn: linkedin.com/in/novatec

capítulo 1

Básico sobre o JavaScript

O JavaScript é uma linguagem de scripting conhecida como uma fera caprichosa.

Muitos desenvolvedores famosos forjaram seus nomes nos anais da comunidade de desenvolvimento web após terem descoberto técnicas especiais e joias ocultas para domar essa suposta fera. O assunto deste livro – o JSON – é uma dessas joias. Você saberá mais sobre o JSON no capítulo 4.

O JSON é simplesmente um formato para troca de dados e, sendo assim, não exige diretamente um conhecimento imediato da linguagem JavaScript. Entretanto este livro não discute apenas a composição do JSON. Discutimos também o modo de incorporá-lo em uma aplicação. Por esse motivo, este livro emprega o JavaScript intensivamente a fim de mostrar as diversas maneiras de trabalhar com o JSON. Há uma infinidade de ótimos livros que revelam os prós e os contras da linguagem JavaScript. Este capítulo serve somente como uma introdução para os próximos capítulos.

A história do JavaScript O ano era 1995, e o Netscape procurava proporcionar um comportamento dinâmico, assim como acrescentar a capacidade de automatizar partes de uma página web em seu navegador. Foi nesse instante que Brendan Eich foi contratado para incorporar a linguagem funcional de scripting Scheme no navegador Netscape Navigator.1 No entanto, o Netscape também estava conduzindo discussões com outras empresas de software/hardware. Em uma arrancada alucinante em direção à linha de chegada, Eich criou o protótipo da linguagem de scripting que logo se transformaria no que atualmente é conhecido como JavaScript.

A incorporação desse novo comportamento dinâmico no navegador mudou as regras do jogo. Esse fato teve um impacto direto no modo como os desenvolvedores programavam para a web. Além do mais, essa incorporação, como inovação, 1 Wikipedia, “JavaScript”, http://en.wikipedia.org/wiki/JavaScript, modificado em janeiro de 2015.

17

18

JSON Básico

estimulou os usuários da Internet a adotar o Navigator como seu navegador preferido. Para competir com a nova dinâmica e com a guerra entre navegadores em ascensão, a Microsoft agiu rapidamente de modo a incorporar uma linguagem de scripting própria ao Internet Explorer.

O dialeto de scripting da Microsoft foi desenvolvido para que fosse compatível com a linguagem de scripting do Netscape. No entanto, para garantir que a linguagem permanecesse uniforme, o Netscape submeteu seu dialeto ao Ecma International para padronização. Esse foi o início da especificação ECMA-262. O ECMA-262 é o nome da especificação dessa linguagem de scripting. O nome EcmaScript é a união de Ecma International e JavaScript. Referenciar o ECMAScript é referenciar a especificação, e não a linguagem em si.

Essencial sobre o JavaScript Em seu núcleo, o JavaScript é uma linguagem de scripting baseada em texto, em que sequências de caracteres Unicode são concatenadas. Apesar do que foi dito, o que faz o JavaScript ser mais que uma sequência de caracteres é sua aderência às regras que governam a maneira como a engine JavaScript interpreta a sequência mencionada em uma aplicação em particular. O conjunto de regras que define a sequência válida de caracteres é conhecido como Sintaxe. A listagem 1.1 mostra uma aplicação JavaScript sintaticamente correta, embora seja simples.

Listagem 1.1 – Um programa JavaScript válido 1 var welcomeMessage = "Hello World"; 2 //Linhas com '//' são usadas para comentários 3 console.log( welcomeMessage ); //exibe Hello World no console 4 console.log("A"); //exibe o caractere A 5 console.log( 2+5 ); //exibe o número 7 6 7 console.log("goodbye" + " " + "all"); //exibe goodbye all

A listagem 1.1 mostra sete linhas, compostas de uma sequência de caracteres codificados em Unicode. Entretanto, como os caracteres da listagem 1.1 são aderentes à especificação ECMAScript, o que a listagem 1.1 mostra, tecnicamente, é uma aplicação JavaScript.

Capítulo 1 ■ Básico sobre o JavaScript

19

Valores Como muitas linguagens influenciaram intensamente o JavaScript, os valores usados por essa linguagem poderão parecer familiares. Embora haja muitos valores usados pela linguagem JavaScript, há duas categorias de acordo com as quais esses valores são diferenciados. Essas duas categorias são: tipos primitivos e tipos não primitivos. Os tipos não primitivos também são conhecidos como Objects (Objetos) e serão o assunto do capítulo 2.

Tipos primitivos Um tipo primitivo representa o conjunto de todos os blocos básicos de construção com que os dados podem ser representados. Esses tipos são chamados de primitivos por serem rudimentares. Isso, é claro, em oposição aos tipos não primitivos.

Há cinco tipos primitivos no JavaScript, conforme representados na figura 1.1. Esses cinco tipos são: números (number), string, booleano (Boolean), undefined e null.

Tipo primitivo

Tipo numérico

Tipo string

Tipo booleano

Tipo undefined

Tipo null

Figura 1.1 – Os cinco tipos primitivos em JavaScript.

Tipo numérico O tipo numérico representa o conjunto de todos os possíveis valores numéricos reconhecidos pela linguagem JavaScript. Essas representações estão sendo mostradas na figura 1.2. Os valores numéricos possíveis incluem frações bem como números inteiros, e cada valor pode ser positivo ou negativo. Além disso, as frações podem ser escritas por meio de notação científica. A listagem 1.2 mostra uma variedade de valores numéricos válidos em JavaScript.

Tipo numérico Frações

Números inteiros

Infinito

Exponenciais

Figura 1.2 – Representações válidas de tipos numéricos.

20

JSON Básico

Listagem 1.2 – Valores numéricos válidos 4 16 3.402823669209385e+38 -1

Tipo string O tipo string representa o conjunto de todos os valores possíveis de string, em que um valor do tipo string corresponde a uma representação finita que inclui zero ou mais caracteres Unicode. Conforme mostrado na figura 1.3, embora a codificação de caracteres seja estritamente considerada como Unicode, os valores de strings também podem ser representativos da codificação de caracteres ASCII. Isso ocorre porque o ASCII é um subconjunto do conjunto de caracteres Unicode.

Exemplos de valores possíveis para string podem ser encontrados na listagem 1.3.

Tipo string ASCII

UNICODE

Figura 1.3 – Codificações válidas para o tipo string.

Listagem 1.3 – Valores válidos para string "this is a string value"; "string"; "s"; ""; //Uma string vazia

Pelo fato de um programa ser composto de texto, um valor do tipo string é diferenciado de nosso programa ao ser delimitado com aspas. Na listagem 1.3, coloquei aspas duplas ao redor de cada valor de string. Entretanto utilizar aspas simples também é totalmente válido.

Como as aspas marcam o início e o fim de um valor do tipo string, será mandatório que sua string não empregue as mesmas aspas usadas externamente para aninhá-las, como no exemplo a seguir: “Mike said and I quote, “let me tell you a secret”” (“Mike disse e vou citá-lo, “deixe-me contar um segredo a você””). Aninhar aspas com os mesmos caracteres usados para indicar uma string confundirá a engine,

Capítulo 1 ■ Básico sobre o JavaScript

21

resultando em um provável erro. Como a engine lê da esquerda para a direita e de cima para baixo, o primeiro caractere encontrado para aninhar aspas será interpretado como o caractere final de aspas. Isso significa que o que esperávamos ser uma citação de Mike, na verdade será tratado como uma instrução inválida.

Aspas aninhadas em valores do tipo string são perfeitamente aceitáveis, desde que elas não façam a engine acreditar que a string terminou prematuramente, como no exemplo anterior. Há duas maneiras possíveis de fazer isso.

Aspas alternadas

Como podemos alternar entre aspas simples e aspas duplas, se você usar uma delas para delimitar um valor do tipo string, a variante alternativa poderá ser usada para deixar sua string gramaticalmente correta. A listagem 1.4 retoma o exemplo anterior usando aspas alternadas.

Listagem 1.4 – Uso alternado de aspas 'Mike said and I quote, "let me tell you a secret".'; //' é usada para delimitar uma string "Mike said and I quote, 'let me tell you a secret'."; //" é usada para delimitar uma string

Como podemos ver na listagem 1.4, é possível usar um par de aspas para indicar uma string e uma forma alternativa para estabelecer uma sintaxe gramatical adequada dentro da string. A engine interpretará isso como uma string dentro de uma string e prosseguirá.

Aspas com escape

O segundo método de incorporar aspas em uma string é garantir que a engine não tratará nossas aspas internas como delimitadores de string. Para isso, devemos usar escape em nossas aspas internas.

O caractere de escape instrui a engine a interpretar o caractere subsequente de modo diferente de como ele seria encarado. Esse modo contrapõe-se a interpretar esse caractere como um delimitador, usado para marcar o final ou o início de um valor do tipo string. O uso de escape em um caractere é facilmente implementado prefixando o caractere que desejamos escapar com uma barra invertida (\).

O uso de aspas com escape permite que nossas strings empreguem aspas indiscriminadamente. Podemos ver exemplos na listagem 1.5.

22

JSON Básico

Listagem 1.5 – Aspas aninhadas com escape "Mike said and I quote, \"let me tell you a secret\"."; 'Mike said and I quote, \'let me tell you a secret\'.';

Nota O caractere de escape diz à engine para interpretar um caractere de modo diferente.

Tipo booleano Um tipo booleano (Boolean) representa um valor lógico, constituído somente de dois valores possíveis. Esses valores, conforme mostrado na figura 1.4, são true ou false. Embora esses sejam os dois valores possíveis a serem atribuídos, um tipo booleano é comumente retornado como a avaliação de uma condição. Uma avaliação desse tipo pode ser uma comparação entre dois números, como podemos ver na listagem 1.6.

Tipo booleano True

False

Figura 1.4 – Valores válidos para o tipo booleano.

Listagem 1.6 – Expressões booleanas var bol = false; //atribui um valor false a bol (10<9); //é avaliado como false; (10>9); //é avaliado como true;

Valores booleanos são ótimos para incluir tomadas de decisão em sua aplicação.

Determinar se uma expressão é avaliada como true ou false permite a uma aplicação reagir de acordo com esse valor. Retomaremos esse assunto quando discutirmos instruções condicionais.

Tipo undefined O tipo undefined é o valor usado para representar o caso em que um identificador ainda não tem nenhum valor atribuído. Quando uma referência a uma variável for avaliada, se um valor ainda não tiver sido atribuído a ela, o valor undefined será retornado.

Capítulo 1 ■ Básico sobre o JavaScript

23

A listagem 1.7 mostra duas linhas de código. A primeira linha é usada para declarar uma variável chamada name (linha 1). A declaração de nossa variável diz à engine JavaScript para alocar uma porção de memória que nossa aplicação poderá usar para armazenar dados. O identificador da variável – name – proporciona um meio textual de referenciarmos a alocação mencionada. Como ainda não atribuímos nenhum dado à nossa variável, a linha subsequente retorna o valor undefined (linha 2).

Listagem 1.7 – Uma variável cujo valor é undefined 1 var name; 2 console.log(name)

//retorna undefined;

Tipo null O tipo null representa a ausência intencional de um valor. É o oposto do valor undefined, que indica que nenhum valor foi definido. O tipo null é um valor usado explicitamente para representar uma referência vazia ou inexistente.

Na listagem 1.8, o valor null é atribuído ao identificador name para indicar explicitamente a ausência intencional de um valor.

Listagem 1.8 – Atribuição de null var name = null; console.log(name)

//retorna null;

Expressões Definida de modo simples pelo Mozilla Developer Network, “uma expressão é qualquer unidade de código válida resolvida como um valor”2.3 O valor para o qual uma expressão é resolvida é o valor de um tipo primitivo ou de um objeto.

Duas formas possíveis de expressão podem ser vistas na listagem 1.9.

Listagem 1.9 – Expressões contrastantes 1 var name = "ben"; 2 2+5; 2 N.T.: Tradução da citação original em inglês: “An expression is any valid unit of code that resolves to a value.”

3 MDN: Mozilla Developer Network, “Expressions and operators” (Expressões e operadores), https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators, última atualização em 27 de novembro de 2014.

24

JSON Básico

A listagem 1.9 mostra dois tipos diferentes de expressão. A primeira representa a atribuição de um valor literal a uma variável (linha 1), em que name representa o identificador ao qual a string literal ben está sendo atribuída. A segunda diz respeito à operação com dois operandos (linha 2).

Nota O operando é o dado sobre o qual a operação está sendo realizada.

Uma expressão retorna um valor, provoca um efeito colateral ou ambos. O fator determinante é o operador sendo empregado.

Operadores Há uma variedade de operadores na linguagem JavaScript que podem ser usados para compor uma expressão. O operador utilizado exerce impacto direto no resultado. Aproveitarei essa oportunidade para discutir os vários operadores usados neste livro.

Operador de atribuição O operador de atribuição é usado para definir o valor de um identificador com o valor de uma expressão. Para uma atribuição ser feita, a linguagem JavaScript conta com o uso do operador de igualdade (=). Na listagem 1.10, utilizamos o operador de atribuição para atribuir um valor primitivo a uma variável.

Listagem 1.10 – Atribuindo valores a variáveis 1 var bolValue = true; 2 var name = "ben";

Depois que um valor for atribuído, ele poderá ser obtido por meio de uma referência ao identificador apropriado. É importante observar que há distinção entre letras maiúsculas e minúsculas nos identificadores; isso quer dizer que, se você usar somente caracteres minúsculos para nomear uma variável, ela deverá ser sempre referenciada com letras minúsculas. Deixar de fazer isso provocará um erro.

Operadores aritméticos Os operadores aritméticos são operadores que dizem respeito a operações matemáticas. Os operadores que compõem essa categoria podem ser vistos na tabela 1.1.

Capítulo 1 ■ Básico sobre o JavaScript

25

Tabela 1.1 – Operadores aritméticos Operador aritmético

Operador

Operador de adição

+

Operador de subtração

-

Operador de divisão

/

Operador de multiplicação

*

Como você deve suspeitar, os operadores aritméticos são usados para realizar operações matemáticas em valores numéricos, como mostrado na listagem 1.11.

Listagem 1.11 – Operações aritméticas 4+9; 8-2; 3*7; 2/1;

//avaliado //avaliado //avaliado //avaliado

como como como como

13 6 21 2

No entanto, o que pode ser inesperado é o fato de o operador de adição ter duas finalidades. A primeira finalidade diz respeito à soma de números; a segunda serve para concatenar dois valores do tipo string. Desde que os dois operandos usados em conjunto com o operador de adição tenham valores numéricos, eles serão somados. Porém, se pelo menos um dos operandos tiver um valor do tipo string, ambos os operandos serão forçados a serem representações do tipo string e serão totalmente concatenados, como mostrado na listagem 1.12.

Listagem 1.12 – Concatenação de strings 1 2 3 4

'Hello' + 'World'; "" + 'Welcome'; true + ''; 3 + '3';

//avaliado //avaliado //avaliado //avaliado

como como como como

"Hello World" "Welcome" "true" "33"

A listagem 1.12 mostra a união de strings quando usadas com o operador de adição.

Embora as linhas 1 e 2 possam ser facilmente aceitas, as linhas 3 e 4 poderão não sê-lo. Como afirmamos anteriormente, o operador de adição poderá ser usado somente com números ou strings. Se ambos os operandos forem numéricos, será fácil para a engine saber qual operação deverá ser realizada. Entretanto, se pelo menos um dos operandos tiver um valor do tipo string, então, independentemente do tipo de dado do outro operando, ele sempre será convertido para uma string.

26

JSON Básico

A linha 3 procura somar um valor booleano com uma string vazia, o que resulta na coerção de true para uma string. Em seguida, como ambos os operandos são vistos como strings, eles serão concatenados e retornados como um valor único de string. De modo semelhante, a linha 4 procura somar o número 3 com a string '3', o que resulta no valor de string "33".

Operadores de comparação Os operadores de comparação são usados para comparar dois operandos (veja a tabela 1.2). O valor avaliado, que sempre será um valor booleano, é um reflexo direto de a comparação ser ou não igual a true. É importante destacar que poucos operadores de comparação comparam operandos sem que haja uma coerção de tipo implícita.

Tabela 1.2 – Operadores de comparação Operador de comparação

Operador

Menor que

<

Maior que

>

Menor ou igual a

<=

Maior ou igual a

>=

Igual

==

Diferente de

!=

Estritamente igual

===

Estritamente diferente

!==

Descrição

Usado para determinar se o operando da esquerda é menor que o operando da direita.

Usado para determinar se o operando da esquerda é maior que o operando da direita.

Usado para determinar se o operando da esquerda é menor ou igual ao operando da direita.

Usado para determinar se o operando da esquerda é maior ou igual ao operando da direita.

Usado para determinar se o operando da esquerda é igual ao operando da direita.

Usado para determinar se o operando da esquerda é diferente do operando da direita.

Verifica se os dois operandos são iguais sem permitir que haja qualquer coerção de tipo.

Verifica se os dois operandos são diferentes sem permitir que haja qualquer coerção de tipo.

A listagem 1.13 mostra a avaliação entre dois operandos. Como mostrado na listagem 1.13, os operadores de comparação têm dois modos: um modo corresponde à comparação estrita entre dois operandos; o outro é uma comparação menos rigorosa.

Listagem 1.13 – Comparação entre operandos 3<=3; //avaliado como true: após a coerção de tipo, 3 é menor ou igual a 3 3=='3'; //avaliado como true: após a coerção de tipo, '3' e '3' são considerados iguais

Capítulo 1 ■ Básico sobre o JavaScript 3==3; 3===3; 3==='3'; 3!='3'; 3!=='3';

//avaliado //avaliado //avaliado //avaliado //avaliado

como como como como como

true: true: false: false: true:

27

após a coerção de tipo, 3 e 3 são considerados iguais 3 e 3 são iguais 3 não é igual a '3' 3 e '3' são iguais 3 não é igual a '3'

Quando a comparação não é rigorosa, os dois operandos sofrem coerção internamente para o mesmo tipo. Independentemente do fato de o operando ser uma string ou um número, ambos sofrerão coerção para o mesmo tipo de dado antes de serem comparados.

Entretanto o uso de um operador de comparação estrita garante que ambos os operandos sejam comparados sem que haja conversão de tipo. Isso é essencial para determinar se dois operandos são semelhantes no que diz respeito tanto ao valor quanto ao tipo.

Operador typeof O operador typeof avalia o tipo de qualquer dado. O valor retornado reflete um dos seis tipos de dados (veja a listagem 1.14) usados pela linguagem JavaScript.

Listagem 1.14 – Determinando os tipos de dados 1 2 3 4 5 6

typeof 3; typeof "hello world"; typeof true; typeof (new Object()); var emptyVariable; typeof emptyVariable;

//exibe //exibe //exibe //exibe

number string boolean object

//exibe undefined

A listagem 1.14 mostra como o operador typeof pode ser usado para identificar qual é o tipo de dado associado a um determinado valor.

Operador instanceof Enquanto o operador typeof é usado para determinar o tipo de algum valor, o instanceof é utilizado para testar se uma instância é uma subclasse de um determinado tipo de objeto. O operador instanceof retorna um valor booleano, indicando se a instância é descendente, diretamente ou não, de um objeto em particular. O uso do operador instanceof está sendo mostrado na listagem 1.15.

28

JSON Básico

Listagem 1.15 – Classificando instâncias 1 2 3 4 5 6 7 8 9

var array = new Array(); var xhr = new XMLHttpRequest(); console.log( console.log( console.log( console.log( console.log( console.log(

xhr instanceof Array); array instanceof XMLHttpRequest); array instanceof Array); xhr instanceof XMLHttpRequest); xhr instanceof Object); array instanceof Object);

//exibe //exibe //exibe //exibe //exibe //exibe

false false true true true true

A listagem 1.15 emprega o operador instanceof para determinar se duas instâncias, array e xhr, são avaliadas como membros do tipo de objeto, um do outro. Como xhr é uma instância do tipo Object XMLHttpRequest e array é uma instância do tipo Object Array, ambas exibem false quando comparadas com o tipo de objeto, um do outro.

A partir daí, cada instância é comparada em relação ao seu próprio tipo de objeto e a avaliação resulta em true. Isso ocorre porque nosso array é uma instância do tipo Object Array, enquanto xhr realmente é um membro do tipo Object XMLHttpRequest.

Um último aspecto a ser destacado é que ambas as instâncias, xhr e array, com efeito, são membros do tipo Object. Isso ocorre porque tanto os Objects Array quanto XMLHttpRequest são descendentes diretos do próprio Object. Esse assunto será discutido com mais detalhes no capítulo 2.

Operador !

O operador NOT, representado pelo token de exclamação (!), é usado para inverter um valor booleano, como podemos ver na listagem 1.16.

Listagem 1.16 – Invertendo um valor booleano console.log( !true ); var someVal = !false;

//exibe false //atribui o valor true;

Instruções Enquanto as expressões dizem respeito à avaliação de valores, as instruções se relacionam às ações executadas por uma aplicação. Uma instrução pode ser tão

Capítulo 1 ■ Básico sobre o JavaScript

29

simples quanto exibir a soma de dois números ou tão complexa quanto gerar o histograma de uma fotografia.

Uma instrução pode existir em uma linha própria ou pode ser composta de várias instruções. Como regra geral, cada nova linha de código representa uma instrução. Entretanto o que realmente distingue uma instrução é o uso explícito de marcadores de fim de linha.

Nota Embora as expressões e as instruções sejam duas categorias distintas na sintaxe do JavaScript, na verdade, ambas, com frequência, estarão entrelaçadas.

Em outras palavras, as duas nem sempre ocorrerão de forma independente.

Marcadores de fim de linha O uso de ponto e vírgula (;) indica explicitamente o fim de uma instrução. Isso garante que, se houver várias instruções em uma única linha, elas serão interpretadas como instruções totalmente separadas. Se um ponto e vírgula não for encontrado no final de uma instrução válida, a engine interpretará os retornos de carro (carriage returns) e as quebras de linha (line breaks) como finalizadores de instrução. Quando esses finalizadores de linha implícitos forem encontrados, a engine inserirá pontos e vírgulas internamente para estar em conformidade com a sintaxe.

A listagem 1.7 mostra quatro linhas de código. As duas primeiras linhas representam duas instruções separadas. Embora não terminem explicitamente com ponto e vírgula, elas empregam quebras de linha, que são vistas pela engine como marcadores de fim de linha. Quando o interpretador JavaScript ler essas duas linhas, ele adicionará um ponto e vírgula automaticamente no final de ambas as linhas, 1 e 2, transformando-as em instruções válidas.

Listagem 1.17 – Instruções exigem finalizadores de linha 1 2 3 4

console.log('a') //instrução válida console.log('b') //instrução válida console.log('a'); console.log('b'); //2 instruções válidas em 1 linha console.log('a') console.log('b'); //1 instrução inválida

A linha 3, por outro lado, é uma maneira condensada de escrever as duas instruções anteriores. Em vez de ocupar duas linhas de código, o uso explícito de ponto e vírgula após cada instrução informa o interpretador de que há várias instruções na mesma linha.

30

JSON Básico

A linha 4, por outro lado, contém duas instruções sem o uso explícito do delimitador ;. Isso resulta na execução de uma instrução inválida pela engine, levando a um erro de sintaxe.

Dica É melhor identificar claramente suas instruções finalizando-as com ;.

Instruções de controle As instruções de controle são usadas para acrescentar tomadas de decisão em uma aplicação. De acordo com a avaliação de uma expressão, uma aplicação pode determinar se deve ou não executar uma instrução em particular. A tabela 1.3 mostra duas palavras-chave usadas neste livro para representar instruções de controle.

Tabela 1.3 – Instruções de controle Instrução de controle if else

Descrição

Executa uma instrução se uma condição lógica for verdadeira (true).

Uma cláusula opcional para executar uma instrução se uma condição lógica for falsa (false).

A instrução if é usada para executar uma instrução se e quando uma expressão for avaliada como verdadeira (true). Por outro lado, se a expressão for avaliada como falsa (false), a instrução indicada será ignorada, como vemos na listagem 1.18.

Listagem 1.18 – Controlando o fluxo com if 1 var bol = false; 2 if( bol ) console.log('condition is met');

A listagem 1.18 mostra um uso típico da instrução if. A listagem começa com a atribuição de false a uma variável chamada bol (linha 1). A linha subsequente representa o nosso controle, em que apresentamos a seguinte condição: se bol for avaliado como true, então execute a instrução subsequente (linha 2). Infelizmente, pelo fato de bol ser avaliado como false, a condição não é atendida e, sendo assim, a instrução não será executada.

Embora a instrução na listagem 1.18 não seja executada, a cláusula else poderá ser usada em conjunto com a instrução if. Como você deve ter adivinhado, a cláusula else executará uma instrução caso uma condição não seja atendida. A listagem 1.19 concatena a instrução else em nosso exemplo anterior.

Capítulo 1 ■ Básico sobre o JavaScript

31

Listagem 1.19 – Controlando o fluxo com if/else 1 var bol=false; 2 if( bol ) console.log('condition is met'); 3 else console.log('condition is not met'); //condição não foi atendida

A execução da listagem 1.19 resulta na execução da linha 3.

Instruções em bloco Embora uma instrução possa ser constituída somente de uma tarefa, é bem possível agrupar uma série de instruções a ser executada. Um grupo de instruções é conhecido como instrução em bloco. Uma instrução em bloco é delimitada por um par de chaves, como podemos ver na listagem 1.20.

Listagem 1.20 – Agrupando instruções em um bloco { statement1; statement2; statement3; }

Como mostrado na listagem 1.20, um bloco de instruções pode conter qualquer quantidade de instruções. Você poderá perceber que, embora cada instrução contida no bloco seja finalizada com um ponto e vírgula, a instrução em bloco propriamente dita não exige esse marcador. O bloco de instruções é um aspecto extremamente importante da linguagem, pois ele pode ser inserido em qualquer lugar em que uma instrução seja considerada válida. A listagem 1.21 retoma nossas instruções de controle da listagem 1.19 e incorpora o uso de uma instrução em bloco.

Listagem 1.21 – Substituindo instruções por instruções em bloco 1 var bol=false; 2 if( bol ) { console.log('condition is met'); alert('condition is met'); } 3 else { console.log('condition is not met'); alert('condition is not met'); }

32

JSON Básico

Truthy/Falsy Qualquer valor JavaScript válido será avaliado como um valor booleano quando usado como uma expressão em uma instrução de controle. Embora a avaliação retorne true ou false, os valores avaliados como true ou false não são tão diretos assim. Os valores avaliados como true são chamados de valores truthy. Por outro lado, aqueles avaliados como false são chamados de valores falsy.

A maneira mais simples de contrastar valores truthy em relação aos valores falsy é reconhecer quais valores são falsy. A listagem 1.22 mostra os valores falsy na linguagem JavaScript.

Listagem 1.22 – Mostra todos os valores falsy if(''); //Uma string vazia if(0); //o número 0 if(null); //um valor null if(false) //um valor false if(undefined); //um valor undefined if(NaN); //um valor NaN

Qualquer valor que não tenha sido mostrado na listagem 1.22 representa um valor truthy.

Instruções de laço A linguagem JavaScript tem algumas instruções de laço que possibilitam a execução de uma instrução, desde que uma condição em particular seja atendida.

Laço for Um laço usado extensivamente neste livro é o laço for. O laço for é comumente usado para executar uma instrução enquanto uma condição permanecer verdadeira (true). A sintaxe do laço for pode ser vista na listagem 1.23.

Listagem 1.23 – A sintaxe de um laço for for( initialization ; condition ; operation ) statement;

Como mostrado na listagem 1.23, um laço for exige uma inicialização, uma condição e, por fim, uma operação que incremente ou decremente o valor inicializado.

Capítulo 1 ■ Básico sobre o JavaScript

33

Desde que a condição permaneça verdadeira (true), a instrução fornecida será executada. Entretanto, no momento em que a condição não for mais atendida, o laço será encerrado e a engine prosseguirá para a próxima instrução na aplicação.

A listagem 1.24 emprega um laço for para executar uma instrução enquanto a variável i for menor que 10.

Listagem 1.24 – Uma instrução iterativa pode referenciar o índice atual 1 for (var i=0; i<10 ; i++) console.log(i); //registra 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 no log

Laço for/in A segunda forma de laço a ser usada neste livro é o laço for/in. O laço for/in é usado para enumerar os membros da instância de um objeto (veja a listagem 1.25).

Listagem 1.25 – Fazendo uma iteração por todas as chaves enumeráveis de um objeto 1 var carA = new Object(); 2 carA.wheels=4; 3 carA.color="blue" 4 carA.make="Volvo"; 5 for( var member in carA ) console.log( member );

A listagem 1.25 contém uma variável chamada carA, que recebe um valor não primitivo. Para sermos mais específicos, carA recebe o valor de um objeto. Um objeto pode ser pensado como um contêiner usado para agrupar variáveis em comum.

Nesse caso, as variáveis em particular estão agrupadas para representar um veículo. Conforme mostrado na listagem 1.25, as variáveis utilizadas na coleção são as seguintes: wheels, color e make. Essas propriedades são usadas para acrescentar especificidades ao nosso veículo.

O laço for/in é usado para fazer uma iteração por todos os identificadores contidos na instância selecionada. A execução da listagem anterior gera o seguinte resultado: wheels color make

34

JSON Básico

Declarações As declarações em JavaScript são usadas para registrar identificadores textuais que possam ser referenciados em todo o programa.

Variáveis Para todos os propósitos e finalidades, as variáveis JavaScript podem ser pensadas como um ponteiro nomeado que representa um link simbólico para uma localização em particular da memória. O nome pelo qual o ponteiro é disponibilizado é conhecido como identificador. Um identificador é um rótulo que diferencia letras maiúsculas de minúsculas, usado como meio para referenciar seu local de armazenamento em particular. Somente pela declaração de uma variável um valor poderá ser atribuído, mantido e, posteriormente, referenciado.

Na linguagem JavaScript, as variáveis são declaradas por meio da palavra-chave var, como mostrado na listagem 1.26.

Listagem 1.26 – Declarando três variáveis 1 var name = "ben"; 2 var age = 36; 3 var sayName = function(){ return this.name }; //expressão de função

A listagem 1.26 declara três variáveis e provê um identificador conciso, embora significativo, a cada uma delas. Os identificadores devem refletir algo significativo e ser apropriados aos dados atribuídos a eles.

Funções Tecnicamente, as funções não são instruções, porém são usadas para executar ações específicas. As funções são uma forma especial de objeto; isso permite que elas sejam tratadas como valores. A listagem 1.27 mostra a sintaxe de uma função.

Listagem 1.27 – A sintaxe da declaração de função function Identifier ( FormalParameterListopt ) { //instruções; }

Como mostrado na listagem 1.27, uma função é definida pelo uso da palavra-chave function. O identificador, que se segue à declaração, registra a função com

Capítulo 1 ■ Básico sobre o JavaScript

35

o rótulo fornecido. Isso garante que uma aplicação poderá referenciar a função em qualquer momento, em toda a aplicação.

Após o identificador, há um par de parênteses usado para definir qualquer quantidade de identificadores opcionais, separados por uma vírgula. Esses identificadores são usados como rótulos para os parâmetros que você possa querer fornecer ao corpo de uma função.

O último componente da declaração da função é um bloco de instruções a ser executado quando a função for chamada. A listagem 1.28 declara uma função chamada sayName.

Listagem 1.28 – Chamando a função sayName com um parâmetro 1 function sayName (name){ 2 return "Hello " + name; 3 }; 4 console.log( sayName("Ben") ); //Hello Ben

A listagem 1.28 emprega uma declaração de função para definir uma função capaz de aceitar um valor arbitrário, cujo identificador é name. O identificador representa a identidade do valor parametrizado, fornecido por quem chama a função. O corpo da função pode referenciar esse valor e usá-lo em sua operação.

No caso de sayName, o corpo da função faz referência ao identificador name e usa o operador de adição para concatenar seu valor à palavra Hello. Utilizando a palavra-chave return, a avaliação é então fornecida de volta a quem chamou a função. Isso resulta na exibição de Hello Ben no console.

Resumo Este capítulo procurou oferecer uma visão geral dos vários capítulos que estão por vir, em que dependeremos extensivamente da linguagem JavaScript para empregar, explicar e representar o JSON. Embora boa parte deste capítulo tenha focado em instruções, operadores e tipos primitivos que serão usados neste livro, o próximo capítulo focará nos tipos não primitivos da linguagem, também conhecidos como objetos.

36

JSON Básico

Pontos principais deste capítulo • O JavaScript é uma linguagem baseada em texto, composta de caracteres Unicode e ASCII. • O ECMAScript refere-se à especificação da linguagem.

• O JavaScript apresenta duas categorias de tipos de dados: primitivos e não primitivos.

• Os valores primitivos podem ser números, strings, booleanos, undefined e null.

• undefined representa a falta de um valor.

• null é usado para indicar a ausência intencional de um valor.

• As expressões são resolvidas para um valor.

• Os operadores são usados para compor expressões.

• O operador de adição tem dois propósitos.

• Os operadores de comparação estrita evitam a ocorrência de coerção de tipo.

• Os operadores de comparação não estrita contam com a coerção de tipo antes de comparar dois operandos.

• O operador typeof é usado para determinar o tipo do dado.

• O operador instanceof é usado para determinar o tipo Object de uma instância.

• As instruções devem ser finalizadas explicitamente.

• Os blocos de instruções podem agrupar várias instruções.

• Os identificadores são rótulos baseados em texto, que diferenciam letras maiúsculas de minúsculas.

• As funções são blocos nomeados de código que podem receber parâmetros.