Estrutura SWITCH

É a outra opção disponível em Javascript para tomar decisões em função de distintos estados das variáveis. Esta expressão se utiliza quando temos múltiplas possibilidades como resultado da avaliação de uma sentença.A estrutura SWITCH se incorporou a partir da versão 1.2 de Javascript (Netscape 4 e Internet Explorer 4). Sua sintaxe é a seguinte:switch (expressão) {
case valor1:
Sentenças a executar se a expressão tem como valor a valor1
break
case valor2:
Sentenças a executar se a expressão tem como valor a valor2
break
case valor3:
Sentenças a executar se a expressão tem como valor a valor3
break
default:
Sentenças a executar se o valor não é nenhum dos anteriores
}
A expressão se avalia, se vale valor1 se executam as sentenças relacionadas com esse caso. Se a expressão vale valor2 se executam as instruções relacionadas com esse valor e assim, sucessivamente, por tantas opções como desejarmos. Finalmente, para todos os casos não contemplados anteriormente se executa o caso por padrão.A palavra break é opcional, mas se não a colocamos a partir de que se encontre coincidência com um valor se executarão todas as sentenças relacionadas com este e todas as seguintes. Ou seja, se em nosso esquema anterior não tivesse nenhuma expressão que valesse valor1, se executariam sentenças relacionadas com valor1 e também as relacionadas com valor2, valor3 e default.Também é opcional a opção default ou opção por padrão.Vejamos um exemplo de uso desta estrutura. Suponhamos que queremos indicar que dia da semana é. Se o dia é 1 (segunda-feira) colocamos uma mensagem indicando, se o dia é 2 (terça) devemos colocar uma mensagem diferente e assim, sucessivamente para cada dia da semana, menos no 6 (sábado) e 7 (domingo) que queremos mostrar a mensagem "é fim de semana". Para dias maiores que 7 indicaremos que esse dia não existe:Switch (dia_da_semana) {
case 1:
document.write("É segunda-feira")
break
case 2:
document.write("É terça-feira")
break
case 3:
document.write("É quarta-feira")
break
case 4:
document.write("É quinta-feira")
break
case 5:
document.write("É sexta-feira ")
break
case 6:
case 7:
document.write("É fim de semana")
break
default:
document.write("Esse dia não existe")
}
O exemplo é relativamente simples, somente pode ter uma pequena dificuldade, consistente em interpretar o que passa no caso 6 e 7, que havíamos dito que tínhamos que mostrar a mesma mensagem. No caso 6 na verdade não indicamos nenhuma instrução, mas como tampouco colocamos um break se executará a sentença ou sentenças do caso seguinte, que correspondem com a sentença indicada no caso 7 que é a mensagem que informa que é fim de semana. Se o caso é 7 simplesmente se indica que é fim de semana, tal como se pretendia.

Estrutura IF - Parte 2

Sentenças IF aninhadas

Para fazer estruturas condicionais mais complexas podemos aninhar sentenças IF, ou seja, colocar estruturas IF dentro de outras estruturas IF. Com um só IF podemos avaliar e realizar uma ação ou outra segundo duas possibilidades, mas se temos mais possibilidades que avaliar devemos aninhar Ifs para criar o fluxo de código necessário para decidir corretamente.

Por exemplo, se desejo comprovar se um número é maior ou igual ao outro, tenho que avaliar três possibilidades distintas. Primeiro, posso comprovar se os dois números são iguais, se são, já está resolvido o problema, mas se não são iguais ainda terei que ver qual dos dois é o maior. Vejamos este exemplo em código Javascript:

var numero1=23
var numero2=63
if (numero1 == numero2){
  document.write("Os dois números são iguais")
else {
  if (numero1 > numero2) {
     document.write("O primeiro número é maior que o segundo")
  }else{
     document.write("O primeiro número é menor que o segundo")
  }
}

O fluxo do programa é como comentávamos antes, primeiro se avalia se os dois números são iguais. No caso positivo se mostra uma mensagem o informando. No caso contrário, já sabemos que são distintos, mas ainda devemos averiguar qual dos dois é maior. Para isso, faz-se outra comparação para saber se o primeiro é maior que o segundo. Se esta comparação dá resultados positivos mostramos uma mensagem dizendo que o primeiro é maior que o segundo, em caso contrário indicaremos que o primeiro é menor que o segundo.

Voltamos a ressaltar que as chaves neste caso são opcionais, pois só se executa uma sentença para cada caso. Ademais, as quebras de linhas e as margens são opcionais em todo caso e nos serve somente para ver o código de uma maneira mais ordenada. Manter o código bem estruturado e escrito de una maneira compreensível é muito importante, já que nos fará a vida mais agradável na hora de programar e mais adiante quando tenhamos que revisar os programas. Neste manual utilizarei uma anotação como a que pode ser vista nas linhas anteriores, e também será visto adiante, ademais manterei essa anotação em todo momento. Isto sem lugar á dúvidas fará com que os códigos com exemplos sejam compreensíveis mais rapidamente, se não fizéssemos assim, seria um verdadeiro sacrifício lê-los. Esta mesma receita é aplicável aos códigos que você irá criar e o principal beneficiado será você mesmo e os companheiros que cheguem a ler seu código.

Operador IF

Existe um operador que ainda não vimos e é uma forma mais esquemática de realizar alguns IF simples. Provém da onde se escrevem muitas poucas linhas de código que resulta muito elegante. Este operador é um claro exemplo de economia de linhas e caracteres ao escrever os scripts. Será visto rapidamente, pois a única razão pela qual o incluo é para que saiba que existe e se o encontra em alguma ocasião por aí, você saiba identificá-lo e como funciona.

Um exemplo de uso de operador IF pode ser visto a seguir:

Variável = (condição) ? valor1 : valor2

Este exemplo não só realiza uma comparação de valores, como também atribui um valor a uma variável. O que faz é avaliar a condição (colocada entre parênteses) e se é positiva atribui o valor1 à variável e no caso contrário lhe atribui o valor 2. Vejamos um exemplo:

momento = (hora_atual < 12) ? "Antes de meio-dia" : "Depois de meio-dia"

Este exemplo olha se a hora atual é maior que 12. Sendo assim, quer dizer que agora é antes de meio-dia, assim que atribui "Antes de meio-dia" à variável momento. Se a hora é maior ou igual a 12 é que é depois de meio-dia, com o que se atribui o texto "Depois de meio-dia" à variável momento.

Estrutura IF - Parte 1

IF é uma estrutura de controle utilizada para tomar decisões. É uma condicional que realiza umas ou outras operações em função de uma expressão. Funciona da seguinte maneira, primeiro se avalia uma expressão se o resultado dá positivo realizam-se as ações relacionadas com o caso positivo.

A sintaxe da estrutura IF é a seguinte:

if (expressão) {
  ações a realizar em caso positivo
  ...
}

Opcionalmente se podem indicar ações a realizar no caso de que a avaliação da sentença dê resultados negativos.

if (expressão) {
  ações a realizar em caso positivo
  ...
} else {
  ações a realizar em caso negativo
  ...
}

Observemos várias coisas: Para começar vemos como com umas chaves englobam as ações que queremos realizar no caso de que se cumpram ou não as expressões. Estas chaves devem ser colocadas sempre, exceto no caso de que somente haja uma instrução como ações a realizar, que são opcionais.

Outro detalhe que está descarado é a margem que colocamos em cada um dos blocos de instruções para executar nos casos positivos e negativos. Esta margem é totalmente opcional, somente fizemos assim para que a estrutura IF se compreenda de uma maneira mais visual. As quebras de linhas também não são necessárias e foram assim colocadas para que se veja melhor a estrutura. Poderíamos perfeitamente colocar toda a instrução IF na mesma linha de código, mas isso não ajudará que as coisas estejam claras. Nós, e qualquer programador, aconselhamos que utilizem as margens e as quebras de linhas necessárias para que as instruções possam ser entendidas melhor, hoje e dentro de um mês, quando já não será tão fácil lembrar o que foi feitos em seus scripts.

Vejamos um exemplo de condicionais IF:

if (dia == "Segunda-feira")
  document.write ("Que tenha um ótimo começo de semana")

Se for segunda-feira nos desejará uma ótima semana. Não fará nada em caso contrário. Como neste exemplo somente indicamos uma instrução para o caso positivo, não será preciso utilizar as chaves. Observe também no operador condicional que consta de dois signos "igual".

Vamos ver agora outro exemplo, um pouco mais comprido:

if (credito >= preço) {
  document.write("comprou o artigo " + novoArtigo) //mostro compra
  carrinho += novoArtigo //coloco o artigo no carrinho da compra
  credito -= preço //diminuo o crédito conforme o preço do artigo
} else {
  document.write("acabou o seu crédito") //informo que lhe falta dinhero
  window.location = "carrinhodacompra.html" //vou à página do carrinho
}

Este exemplo é um pouco mais complexo, e também um pouco fictício. O que faço é comprovar se tenho crédito para realizar uma suposta compra. Para isso, vejo se o crédito é maior ou igual que o preço do artigo, se é assim, informa da compra, coloco o artigo no carrinho e subtraio o preço ao crédito acumulado. Se o preço do artigo é superior ao dinheiro disponível, informo a situação e mando ao navegador à página onde se mostra seu carrinho da compra.

Expressões condicionais

A expressão a avaliar se coloca sempre entre parêntesis e está composta por variáveis que se combinam entre si mediante operadores condicionais. Lembramos que os operadores condicionais relacionavam duas variáveis e devolviam sempre um resultado boleano. Por exemplo, um operador condicional é o operador "é igual" (==), que devolve true no caso de que os operandos sejam iguais ou false no caso de que sejam distintos:

if (idade > 18)
  document.write("pode ver esta página para adultos")

Neste exemplo, utilizamos em operador condicional "é maior" (>). Neste caso, devolve true se a variável idade é maior que 18, com o que se executaria a linha seguinte que nos informa de que se pode ver o conteúdo para adultos.

As expressões condicionais podem ser combinadas com as expressões lógicas para criar expressões mais complexas. Lembramos que as expressões lógicas são as que têm como operandos aos boleanos e que devolvem outro valor boleano. São os operadores de negação, E lógico e O lógico:

if (bateria == 0 && redeEletrica = 0)
  document.write("seu laptop vai se apagar em segundos")

O que fazemos é comprovar se a bateria de nosso suposto computador está a zero (acabada) e também comprovamos se o computador não tem rede elétrica (se está fora da tomada). Logo, o operador lógico os relaciona com um E, de modo que se está sem bateria E sem rede elétrica, informo que o ordenador vai se apagar.

A lista de operadores que se podem utilizar com as estruturas IF, podem ser vistos no capítulo de operadores condicionais e operadores lógicos.

Estruturas de controle

Os scripts vistos até agora foram tremendamente simples e lineares: iam-se executando as sentenças simples uma atrás da outra desde o princípio até o fim. Entretanto, isto não tem porque ser sempre assim, nos programas geralmente necessitaremos fazer coisas distintas, dependendo do estado de nossas variáveis realizar um mesmo processo muitas vezes sem escrever a mesma linha de código uma e outra vez.

Para realizar coisas mais complexas em nossos scripts se utilizam as estruturas de controle. Utilizando-as podemos realizar tomadas de decisões e loops. Nos seguintes capítulos vamos conhecer as distintas estruturas de controle que existem em Javascript.

Tomada de decisões

Servem para realizar umas ações ou outras em função do estado das variáveis. Ou seja, tomar decisões para executar umas instruções ou outras dependendo do que esteja ocorrendo neste instante em nossos programas.

Por exemplo, dependendo se o usuário que entra em nossa página for maior de idade ou não, podemos lhe permitir ou não ver os conteúdos de nossa página:

Se idade é maior que 18 então:
Deixo-lhe ver o conteúdo para adultos
Se não
Mando-lhe fora da página


Em Javascript podemos tomar decisões utilizando dois enunciados distintos:

. IF;
. SWITCH.

Loops

Os loops se utilizam para realizar certas ações repetidamente. São muito utilizados em todos os níveis na programação. Com um loop podemos por exemplo, imprimir em uma página os números de 1 ao 100 sem a necessidade de escrever cem vezes a instrução a imprimir:

Desde o 1 até o 100
Imprimir o número atual


Em Javascript existem vários tipos de loops, cada um está indicado para um tipo de repetição distinto e são os seguintes:

. FOR;
. WHILE;
. DO WHILE.

Como já assinalamos as estruturas de controle são muito importantes em Javascript e em qualquer linguagem de programação. É por isso que nos seguintes capítulos veremos cada uma destas estruturas detalhadamente, descrevendo seu uso e oferecendo alguns exemplos.

Controle de tipos

Vimos para determinados operadores que é importante o tipo de dados que estão manejando, visto que se os dados são de um tipo irão realizar operações distintas que se são de outro.

Assim, quando utilizávamos o operador +, se se tratava de números, os somava, mas se se tratava de cadeias de caracteres, os conciliava. Vemos então, que o tipo dos dados que estamos utilizando sim que importa e que teremos que estar pendentes a este detalhe se quisermos que nossas operações se realizem tal como esperávamos.

Para comprovar o tipo de um dado se pode utilizar outro operador que está disponível a partir de javascript 1.1, o operador typeof, que devolve uma cadeia de texto que descreve o tipo do operador que estamos comprovando:

var boleano = true
var numerico = 22
var numerico_flutuante = 13.56
var texto = "meu texto"
var data = new Date()
document.write("
O tipo de boleano é: " + typeof boleano)
document.write("
O tipo de numerico é: " + typeof numerico)
document.write("
O tipo de numerico_flutuante é: " + typeof numerico_flutuante)
document.write("
O tipo de texto é: " + typeof texto)
document.write("
O tipo de data é: " + typeof data)

Este script dará como resultado o seguinte:

O tipo de boleano é: boolean
O tipo de numerico é: number
O tipo de numerico_flutuante é: number
O tipo de texto é: string
O tipo de data é: object

Neste exemplo podemos ver que se imprime na página os distintos tipos das variáveis. Estes podem ser os seguintes:

. boolean - para os dados boleanos (true ou false);
. number - para os numéricos;
. string - para as cadeias de caracteres;
. object - para os objetos.

Queremos destacar apenas mais dois detalhes:

1. Os números, já tendo ou não parte decimal, são sempre do tipo de dados numéricos;

2. Uma das variáveis é um pouco mais complexa, é a variável data que é um objeto da classe Date(), que se utiliza para o manejo de datas nos scripts. Mais adiante a veremos, assim como os objetos.

Operadores - Parte 3

Operadores a nível de bitEstes são muito pouco correntes e é possível que você nunca chegue a utilizá-los. Seu uso se realiza para efetuar operações com zeros e uns. Tudo o que maneja um computador são zeros e uns, a pesar de nós usarmos números e letras para nossas variáveis na verdade estes valores estão escritos internamente em forma de zeros e uns. Em alguns casos, poderemos necessitar realizar operações tratando as variáveis como zeros e uns, e para isso, utilizaremos estes operandos. Nesta manual se tornaria um pouco extenso demais se realizássemos uma discussão sobre este tipo de operadores, mas aqui você poderá ver estes operadores por acaso algum dia fizer falta:& Y de bits
^ Xor de bits
O de bits
<< >> >>> >>>= >>= <<= Várias classes de mudanças
Precedência dos operadoresA avaliação de uma sentença das que vimos nos exemplos anteriores é bastante simples e fácil de interpretar, mas quando em uma sentença entram em jogo uma infinidade de operadores diferentes pode haver uma confusão na hora de interpretá-la e avaliar quais operadores são os que se executam antes que outros. Para marcar umas pautas na avaliação das sentenças e que estas se executem sempre igual e com sentido comum existe a precedência de operadores, que não é mais que a ordem pela qual se irão executando as operações que eles representam. À princípio todos os operadores se avaliam da esquerda para a direita, mas existem umas normas adicionais, pelas quais determinados operadores se avaliam antes que outros. Muitas destas regras de precedência foram tiradas das matemáticas e são comuns a outras linguagens, podemos vê-las a seguir:
() [] . Parêntesis, colchetes e o operador ponto que serve para os objetos
! - ++ -- Negação, negativo e incrementos
* / % Multiplicação, divisão e módulo
+- Soma e diferença
<< >> >>> Mudanças a nível de bit
< <= > >= Operadores condicionais
== != Operadores condicionais de igualdade e desigualdade
& ^ Lógicos a nível de bit
&& Lógicos boleanos
= += -= *= /= %= <<= >>= >>>= &= ^= != Atribuição

Nos seguintes exemplos podemos ver como as expressões poderiam chegar a ser confusas, mas com a tabela de precedência de operadores poderemos entender sem erros qual é a ordem pela qual se executam:12 * 3 + 4 - 8 / 2 % 3
Neste caso, primeiro se executam os operadores * / y %, da esquerda a direita, com o qual se realizariam estas operações. Primeiro a multiplicação e logo a divisão por estar mais à esquerda do módulo:36 + 4 - 4 % 3
Agora o módulo:36 + 4 - 1
Por último as somas e as diferenças da esquerda para direita:40 - 1
39
De qualquer forma, é importante se dar conta que o uso dos parênteses pode nos economizar muitos quebra-cabeças e, sobretudo, a necessidade de sabermos de memória a tabela de precedência dos operadores. Quando virmos pouco claro a ordem com a qual se executarão as sentenças podemos utilizá-las e assim, forçar que se avalie antes o pedaço da expressão que se encontra dentro dos parênteses.

Operadores - Parte 2

Operadores de cadeiasAs cadeias de caracteres, ou variáveis de texto, também têm seus próprios operadores para realizar ações típicas sobre cadeias. Apesar do Javascript ter somente um operador para cadeias se podem realizar outras ações com uma série de funções pré-definidas na linguagem que veremos mais adiante.+Concilia duas cadeias, pega a segunda cadeia a seguir da primeira.Exemplo:cadeia1 = "ola"
cadeia2 = "mundo"
cadeiaConciliada = cadeia1 + cadeia2 //cadeia conciliada vale "olamundo"
Um detalhe importante que pode ser visto neste caso, é que o operador + serve para dois usos distintos, se seus operandos são números, os soma, mas se se trata de cadeias, as concilia. Isto ocorre em geral com todos os operadores que se repetem na linguagem, javascript é suficientemente esperto para entender que tipo de operação realizar mediante uma comprovação dos tipos que estão implicados nela.Um caso que seria confuso é o uso do operador + quando se realiza a operação com operadores texto e numéricos misturados. Neste caso javascript assume que se deseja realizar uma conciliação e trata aos dois operandos como se tratasse de cadeias de caracteres, inclusive se a cadeia de texto que temos for um número. Isto veremos mais facilmente com o seguinte exemplo:meuNumero = 23
minhaCadeia1 = "pedro"
minhaCadeia2 = "456"
resultado1 = meuNumero + minhaCadena1 //resultado1 vale "23pedro"
resultado2 = meuNumero + minhaCadeia2 //resultado2 vale "23456"
minhaCadeia2 += meuNumero //minhaCadena2 agora vale "45623"
Como podemos ver, também no caso do operador +=, se estamos tratando com cadeias de texto e números misturados, tratará aos dois operadores como se fossem cadeias.Operadores lógicosEstes operadores servem para realizar operações lógicas, que são aquelas que dão como resultado um verdadeiro ou um falso, e se utilizam para tomar decisões em nossos scripts. Ao invés de trabalhar com números, para realizar este tipo de operações se utilizam operandos boleanos, que conhecemos anteriormente, que são o verdadeiro (true) e o falso (false). Os operadores lógicos relacionam os operandos boleanos para dar como resultado outro operando boleano, tal como podemos ver no seguinte exemplo.Se tenho fome e tenho comida, então irei comer.
Nosso programa Javascript utilizaria neste exemplo um operando boleano para tomar uma decisão. Primeiro irá ver se tenho fome, se é certo (true) irá ver se disponho de comida. Se são os dois são certos, poderá comer. No caso de que não tenha comida ou de que não tenha fome não comeria, assim como se não tenho fome nem comida. O operando em questão é o operando Y, que valerá verdadeiro (true) no caso de que os dois operandos sejam verdadeiros:! Operador NO ou negação. Se é true passa a false e vice-versa.
&& Operador Y, se são os dois verdadeiros vale verdadeiro.
Operador O, vale verdadeiro se pelo menos um deles for verdadeiro.

Exemplo:
meuBoleano = true
meuBoleano = !meuBoleano //meuBoleano agora vale false
tenhofome = true
tenhoComida = true
comoComida = tenhoFome && tenhoComida

Operadores condicionaisServem para realizar expressões condicionais mais complexas que desejarmos. Estas expressões se utilizam para tomar decisões em função da comparação de vários elementos, por exemplo, se um número é maior que outro ou se são iguais. Os operadores condicionais se utilizam nas expressões condicionais para tomar decisões. Como estas expressões condicionais serão objeto de estudo mais adiante será melhor descrever os operadores condicionais mais adiante. De qualquer forma, aqui podemos ver a tabela de operadores condicionais:
== Comprova se dois números são iguais
!= Comprova se dois números são distintos
> Maior que, devolve true se o primeiro operador for maior que o segundo
<>= Maior igual.
<= Menor igual

Operadores - Parte 1

Ao desenvolver programas em qualquer linguagem se utilizam os operadores. Estes servem para fazer os cálculos e operações necessárias para realizar seus objetivos. Um programa que não realiza operações somente se pode limitar a fazer sempre o mesmo. É o resultado destas operações que faz com que um programa varie seu comportamento segundo os dados que obtenha. Existem operações mais simples ou mais complexas, que se podem realizar com operandos de distintos tipos de dados, como números ou textos, veremos neste capítulo de maneira detalhada todos estes operadores.
Exemplos de uso de operadores
Antes de começar a numerar os distintos tipos de operadores vamos ver dois exemplos destes para ajudar a termos uma idéia mais exata do que são. No primeiro exemplo, vamos realizar uma soma utilizando o operador soma:
3 + 5
Esta é uma expressão muito básica que não tem muito sentido por si só. Faz a soma entre os dois operadores, número 3 e 5, porém, não serve muito porque não se faz nada com o resultado. Normalmente combinam-se mais de um operador para criar expressões mais úteis. A expressão seguinte é uma combinação entre dois operadores, um realiza uma operação matemática e o outro serve para salvar o resultado:
minhaVariavel = 23 * 5
No exemplo anterior, o operador * se utiliza para realizar uma multiplicação e o operador = se utiliza para atribuir o resultado em uma variável, de modo que salvamos o valor para seu posterior uso.
Os operadores podem ser classificados segundo o tipo de ações que realizam. A seguir veremos cada um destes grupos de operadores e descreveremos a função de cada um.
Operadores aritméticos
São os utilizados para a realização de operações matemáticas simples como a soma, diferença ou multiplicação. Em javascript são os seguintes:

+ Soma de dois valores
- Diferença de dois valores, também se pode utilizar para mudar o sinal de um número se o utilizamos com um só operando -23
* Multiplicação de dois valores
/ Divisão de dois valores
% O resto da divisão de dois números (3%2 devolveria 1, o resto de dividir 3 entre 2)
++ Incremento em uma unidade, se utiliza com um só operando
-- Decremento em uma unidade, utilizado com um só operando

Exemplos:
preço = 128 //introduzo um 128 na variável preço
unidades = 10 //outra atribuição, logo veremos operadores de atribuição
fatura = preço * unidades //multiplico preço por unidades, obtenho o valor fatura
resto = fatura % 3 //obtenho o resto de dividir a variável fatura por 3
preço++ //incrementa em uma unidade o preço (agora vale 129)
Operadores de atribuiçãoServem para atribuir valores às variáveis, já utilizamos em exemplos anteriores o operador de atribuição =, mas existem outros operadores deste tipo, que provém da linguagem C e que muitos dos leitores já conhecerão:

= Atribuição. Atribui a parte da direita do igual à parte da esquerda. À direita se colocam os valores finais e à esquerda geralmente se coloca uma variável onde queremos salvar o dado.
+= Atribuição com soma. Realiza a soma da parte da direita com a da esquerda e salva o resultado na parte da esquerda.
-= Atribuição com diferença
*= Atribuição da multiplicação
/= Atribuição da divisão
%= Se obtém o resto e se atribui

Exemplos:
poupança = 7000 //atribui um 7000 à variável poupança
poupança += 3500 //incrementa em 3500 a variável poupança, agora vale 10500
poupança /= 2 //divide entre 2 minha poupança, agora ficam 5250

Tipos de dados em Javascript

Em nossos scripts vamos manejar variáveis de diversas classes de informação, como textos ou números. Cada uma destas classes de informação é o tipo de dados. Javascript distingue entre três tipos de dados e todas as informações que se podem salvar em variáveis vão estar encaixadas em algum destes tipos de dados. Vejamos detalhadamente quais são estes três tipos de dados.
Tipo de dados numérico
Nesta linguagem só existe um tipo de dados numérico, ao contrário do que ocorre na maioria das linguagens mais conhecidas. Todos os números são portanto, do tipo numérico, independentemente da precisão que tenham ou se são números reais ou inteiros. Os números inteiros são números que não têm vírgula, como 3 ou 339. Os números reais são números fracionários, como 2.69 ou 0.25, que também se podem escrever em nota científica, por exemplo, 2.482e12.
Com Javascript também podemos escrever números em outras bases, como a hexadecimal. As bases são sistemas de numeração que utilizam mais ou menos dígitos para escrever os números. Existem três bases com as que podemos trabalhar:
. Base 10, é o sistema que utilizamos habitualmente, o sistema decimal. Qualquer número, por padrão, se entende que está escrito em base 10;. Base 8, também chamado sistema octal, que utiliza dígitos do 0 ao 7. Para escrever um número em octal basta simplesmente escrever este número precedido de um 0, por exemplo 045;. Base 16 ou sistema hexadecimal, é o sistema de numeração que utiliza 16 dígitos, os compreendidos entre o 0 e o 9 e as letras da A à F, para os dígitos que faltam. Para escrever um número em hexadecimal devemos escrevê-lo precedido de um zero e um xis, por exemplo, 0x3EF.
Tipo boleano
O tipo boleano, boolean em inglês, serve para salvar ou sim ou um não, ou com outras palavras, um verdadeiro ou falso. Utiliza-se para realizar operações lógicas, geralmente para realizar ações se o conteúdo de uma variável é verdadeiro ou falso.
Os dois valores que podem ter as variáveis boleanas são true ou false:

minhaBoleana = true

minhaBoleana = false

Tipo de dados cadeia de caracteres
O último tipo de dados é o que serve para salvar um texto. Javascript só tem um tipo de dados para salvar texto e nele, se podem introduzir qualquer número de caracteres. Um texto pode estar composto de números, letras e qualquer outro tipo de caracteres e signos. Os textos se escrevem entre aspas, duplas ou simples:

meuTexto = "Miguel vai pescar"

meuTexto = '23%%$ Letras & *--*'

Tudo o que se coloca entre aspas, como nos exemplos anteriores é tratado como uma cadeia de caracteres independentemente do que coloquemos no interior das aspas. Por exemplo, em uma variável de texto podemos salvar números e nesse caso temos que ter em conta que as variáveis de tipo texto e as numéricas não são a mesma coisa e que enquanto as de numéricas nos servem para fazer cálculos matemáticos, as de texto não servem.
Caracteres de escape em cadeias de texto.
Existe uma série de caracteres especiais que servem para expressar em uma cadeia de texto determinados controles como pode ser uma quebra de linha ou um tabulador. Estes são os caracteres de escape e se escrevem com uma nota especial que começa por uma contra-barra (uma barra inclinada ao contrário da normal '\') e logo se coloca o código do caractere a mostrar.
Um caractere muito comum é a quebra de linha, que se consegue escrevendo \n. Outro caractere muito habitual é colocar umas aspas, pois se colocamos umas aspas sem seu caractere especial nos fechariam as aspas que colocamos para iniciar a cadeia de caracteres. Temos então que introduzir as aspas com \" ou \' (aspas duplas ou simples). Existem outros caracteres de escape, que veremos na tabela abaixo mais resumidos, apesar de que também há que destacar como caractere habitual o que se utiliza para escrever uma contra-barra, para não confundi-la com o início de um caractere de escape, que é a dupla contra-barra \\.
Tabela com todos os caracteres de escape:

Quebra de linha: \n

Aspas simples: \'

Aspas dupla: \"

Tabulador: \t

Enter: \r

Avance de página: \f

Retroceder espaço: \b

Contra-barra: \\

Alguns destes caracteres provavelmente não os chegará a utilizar nunca, pois sua função é um pouco rara e também, às vezes pouco clara.

O que podemos salvar em variáveis

Em uma variável podemos introduzir vários tipos de informação, por exemplo, texto, números inteiros ou reais, etc. A estas distintas classes de informação conhecemos como tipos de dados. Cada um tem características e usos distintos, vejamos quais são os tipos de dados de Javascript.
Números
Para começar temos o tipo numérico, para salvar números como 9 ou 23.6
Cadeias
O tipo cadeia de caractere salva um texto. Sempre que escrevemos uma cadeia de caracteres devemos utilizar as aspas (").
Boleanos
Também contamos com o tipo boleano, que salva uma informação que pode valer como sim (true) ou não (false).
Por último seria relevante assinalar aqui que nossas variáveis podem conter coisas mais complicadas, como poderia ser um objeto, uma função, ou vazio (null) mas já o vermos mais adiante.
Na verdade nossas variáveis não estão forçadas a salvar um tipo de dados em concreto e portanto, não especificamos nenhum tipo de dados para uma variável quando a estamos declarando. Podemos introduzir qualquer informação em uma variável de qualquer tipo, inclusive podemos ir mudando o conteúdo de uma variável de um tipo a outro sem nenhum problema. Vamos ver isto com um exemplo:
var nome_cidade = "Salvador"

var revisado = true

nome_cidade = 32

revisado = "no"

Esta agilidade na hora de atribuir tipos às variáveis pode ser uma vantagem à princípio, sobretudo para pessoas inexperientes, mas a longo prazo pode ser uma fonte de erros já que dependendo do tipo que são as variáveis se comportarão de um modo ou outro e se não controlamos com exatidão o tipo das variáveis podemos encontrar um texto somado a um número. Javascript operará perfeitamente, e devolverá um dado, mas em alguns casos pode que não seja o que estávamos esperando. Sendo assim, mesmo que tenhamos liberdade com os tipos, esta mesma liberdade nos faz estar mais atentos a possíveis desajustes difíceis de detectar ao longo dos programas. Vejamos o que ocorreria no caso de somar letras e números:
var parcela1 = 23

var parcela2 = "33"

var soma = parcela1 + parcela2document.write(soma)

Este script nos mostraria na página o texto 2333, que não se corresponde com a soma dos dois números, e sim com sua combinação, um atrás do outro.