Primeiros passos com JavaScript

Um guia desenvolvido para iniciantes

Por: Marcelo Bitencourt

 Sobre o autor

Bacharel em Ciência da Computação, especialista em

Engenharia de Software e mestre em Educação. Atua no mercado
como Analista/Desenvolvedor e professor do ensino Médio e
Superior. Possui experiência em diversas tecnologias e linguagens
de programação.
Conteúdo

Capítulo 1
Introdução ao JavaScript
JavaScript e ECMAScript
Onde executar JavaScript?
Rodando JavaScript nos navegadores
Rodando JavaScript com Node.js

Capítulo 2
Variáveis
Variáveis em JavaScript e sua tipagem dinâmica
Variáveis e atribuição de valores
Variáveis e escopos
Escopo de declaração de bloco
Constantes
Tipos de dados e conversões
Dados primitivos
Tipo Objeto
Boolean
Tipo Null
O tipo de dados undefined
O tipo de dados Number
O tipo de dados String
Objetos Date

Capítulo 3
Operadores
Operadores de atribuição
Operadores de comparação
Operadores aritméticos
Abreviações de operadores de atribuição
 Expressões aritméticas
Operador módulo (%)
Operador de exponenciação (**)
Operador incremento (++)
Operador decremento (--)
Operadores lógicos
Operador condicional ternário
O operador typeof
Operadores lógicos

Capítulo 4
Controle de fluxo
Declaração if...else
Declaração switch

Capítulo 5
Laços de repetição (loops)
Laço for
Laço while
Laço do...while
Break
Continue

Capítulo 6
Funções
Declarando funções
Chamadas de funções
Funções anônimas
Arrow functions
Funções e Parâmetros

Capítulo 7
Arrays
 Criação de Arrays
Acessando itens do array
Alterando dados do array
Adicionando novos elementos no array
Removendo elementos de um array
Tamanho do array
Converter Strings em Arrays
Unindo Arrays
Converter Arrays em Strings
Ordenando e invertendo os elementos do Array

Considerações do autor
CAPÍTULO 1

Introdução ao JavaScript

Para você que está dando os primeiros passos no

aprendizado de JavaScript, saiba que nos últimos anos JavaScript
vem tornando-se uma das linguagens mais populares e preferidas
pelos desenvolvedores de software. Pode-se dizer que JavaScript
é a linguagem do momento, pois é ela que roda nos navegadores.
E não para por ai, atualmente também é possível encontrar código
escrito em JavaScript rodando tanto nos navegadores quanto em
servidores, e também em dispositivos móveis.
Toda essa popularidade do JavaScript fez com que novas
tecnologias surgissem no mercado, onde pode-se destacar:
AngularJS, Node.js, React, ReactNative, entre muitas outras.
É importante salientar que para se trabalhar com alguma
dessas tecnologias citadas anteriormente, é muito importante ter
uma bom conhecimento em JavaScript, pois todas elas são
baseadas nessa linguagem.
O propósito desse livro não consiste em aprofundar-se em
nenhuma dessas tecnologias, mas sim propor uma base conceitual
de JavaScript partindo de conceitos teóricos e estendendo-se a
exemplos práticos.
JavaScript e ECMAScript

O JavaScript é uma linguagem que surgiu nos anos de 1990

assim como muitas outras que surgiram no mercado. Sua primeira
versão foi desenvolvida pelo programador norte-americano
Brendam Eich em 1995. O primeiro protótipo da linguagem foi
batizado com o nome Mocha, e em setembro de 1995 foi chamada
de LiveScript. Apenas em dezembro de 1995 o nome foi modificado
para JavaScript.
Já nos primeiros anos do JavaScript os criadores da
linguagem percebem que para a linguagem evoluir e crescer no
mercado, ela necessita seguir alguma padronização. Nesse sentido
os mantenedores da linguagem resolveram associar-se ao ECMA
(European Computer Manufactures Association). Com essa fusão a
linguagem troca o nome para ECMAScript, pois o nome JavaScript
já havia sido patenteado pela antiga Sun MicroSystems, atual
Oracle. Mesmo com a alteração do nome, a linguagem ganhou
popularidade com o nome JavaScript, como é chamada até hoje, e
ECMAScript, tornou-se o nome de suas especificações. Atualmente
o ECMAScript está em sua oitava edição conhecida como
ECMAScript 2017 também conhecido como ES8, e sua
especificação pode ser encontrada em: https://www.ecma-
international.org/ecma-262/8.0/index.html.
Esse livro foi escrito baseando-se na especificação do EC-
MAScript 2015 ou ES6 e versões anteriores.
Onde executar JavaScript?

Antes de escrevermos nosso primeiro código em JavaScript,

vamos relembrar que podemos rodar JavaScript diretamente nos
navegadores e também no lado do servidor utilizando o Node.js.
Para executar o JavaScript nos navegadores não é necessário
efetuar nenhuma configuração, pois o JavaScript já é nativo nos
navegadores. Já para utilizar o JavaScript fora dos navegadores é
necessário instalar o Node.js que é o interpretador da linguagem
que possibilita rodar código JavaScript fora dos navegadores. A
instalação do Node.js é simples de ser feita, basta baixar e efetuar
a instalação de acordo com o seu sistema operacional. A instalação
do Node.js pode ser baixada no site:
https://nodejs.org/en/download/ .
Primeiro código em JavaScript

Vamos agora escrever nosso primeiro código em

JavaScript. Inicialmente escreveremos o código diretamente no
navegador. Para os exemplos desse livro utilizaremos o navegador
Chrome da Google.

Rodando JavaScript nos navegadores

Primeiramente vamos aprender a escrever mensagens no

console do navegador. Para essa tarefa vamos escrever nosso
primeiro programa em JavaScript que imprimirá no console do
navegador a seguinte frase: Bem vindo ao mundo do JavaScript!
Siga os procedimentos:
 Abra o navegador (Chrome);
 Clique em ferramentas do desenvolvedor ou tecle (Cntrl +
Shift + I);
 Após clicar em Ferramentas do desenvolvedor é exibida a tela
que possui a opção de console, que é o local onde podemos
escrever nossos códigos JavaScript

 Vamos agora escrever nosso programa. Digite o seguinte

comando: console.log("Bem vindo ao mundo do JavaScript!"),
e em seguida tecle <Enter>. Note que aparecerá logo abaixo
no console a frase que você escreveu no console.log.
Rodando JavaScript com Node.js

Muito bem, agora que você já escreveu seu primeiro código

em JavaScript no navegador, vamos aprender a escrever o mesmo
código no servidor, utilizando o Node.js. Lembrando que para que
seja possível rodar o JavaScript fora dos navegadores, é
necessário instalar o Node.js em seu sistema conforme citado
anteriormente. Vamos agora codificar utilizando o Node.js. Mas
onde você irá escrever seu código? Simples, você pode escolher
qualquer editor de texto para escrever código JavaScript. Você
pode escrever seu código fonte mesmo em um editor simples como
o bloco de notas e salvar o arquivo com extensão .js. Existem
atualmente no mercado muitos editores utilizados para codificação
como por exemplo: SublimeText, Visual Studio Code, Atom, entre
outros. Para esse exemplo vamos utilizar o Visual Studio Code por
ser um editor muito utilizado entre os desenvolvedores JavaScript.
Note que a utilização do Visual Studio Code não é obrigatória, você
pode utilizar o editor de sua preferência.
Vamos agora escrever o mesmo programa codificado no
navegador, porém agora utilizando o NodeJS. Siga os passos:
 Abra seu editor de texto;
 Crie um novo arquivo;
 No arquivo criado digite console.log(“Bem vindo ao
mundo do JavaScript!”);
 Salve o arquivo com o nome prog1.js
 Abra a linha de comandos do seu sistema operacional
no local que foi salvo o arquivo.
(Como exemplo utilizaremos o sistema operacional
Windows10 e salvamos o arquivo dentro da pasta
cursoJavaScript).

 Digite o seguinte comando: node prog1.js



 Tecle <ENTER>

Note que a mensagem Bem vindo ao mundo do

JavaScript! é exibida abaixo.
CAPÍTULO 2

Variáveis

Nesse capítulo trataremos de alguns conceitos importantes de

programação que são utilizados na maioria das linguagens de
programação. Para iniciar esses conceitos veremos inicialmente
as variáveis.

O que são variáveis?

Pode-se dizer que variáveis são locais que criamos para
armazenar dados quando o nosso programa está rodando.
Mas esses dados são gravados definitivamente?
Não, as variáveis são estruturas criadas para armazenar os
dados temporariamente, ou mais precisamente, no momento da
execução do programa. Quando o programa é finalizado esses
dados não ficam armazenados em disco.
É importante destacar que o conceito de variável é um
conceito muito importante no estudo das linguagens de
programação em geral.
Falando um pouco mais tecnicamente sobre o conceito de
variáveis, pode-se dizer que ao criarmos uma variável, realizamos
uma referência a um espaço na memória do computador destinado
a armazenar algum dado.
 Mas você pode estar se perguntando, afinal como criar
variáveis em JavaScript?
Em JavaScript é muito simples criamos variáveis, porém deve-
se prestar atenção em algumas regrinhas para que isso seja
possível.

Variáveis em JavaScript e sua tipagem dinâmica

Diferente de linguagens como Java e C, o JavaScript não

precisa de um tipo para suas variáveis, basta declarar a variável e
atribuir um valor que automaticamente o JavaScript irá tipar
automaticamente.
Mas como declarar as variáveis?
Para declarar variáveis em JavaScript necessita-se do
comando de declaração e um nome.
Antes do ES/6 as variáveis eram declaradas utilizando o
comando var.

/* Exemplo: criando variável usando var */

var nome;

No exemplo acima criamos uma variável chamada nome utilizando

o comando var.
Com o ES6 foram introduzidos o comandos let e const para a
criação de variáveis ou identificadores.

/* Exemplo: criando variável usando let */

let nome;
 /* Exemplo: criando variável usando const */
const nome;

Os comandos let e const serão vistos com mais detalhes em

um outro tópico.
Nesse momento você pode estar se questionando: Posso
colocar qualquer nome para as variáveis? A resposta para essa
pergunta é que deve-se seguir algumas regras para nomear as
variáveis.
A linguagem JavaScript faz distinção entre maiúsculas e
minúsculas. Portanto ao criar-se por exemplo as variáveis: Nome e
nome, o JavaScript tratará como duas variáveis distintas.
Como regra em JavaScript o primeiro caractere do nome da
variável deve ser uma letra ASCII ou um caractere underscore (_).

/* Exemplo: Nomes válidos de variáveis*/

var nome;
var _idade;

Nomes de variáveis que iniciam com números são

considerados inválidos.

/* Exemplo: Nomes inválidos de variáveis*/

var 4ever;

Após o primeiro caractere, os caracteres subsequentes devem

ser letras, números ou underscore (_).

Exemplos de nomes válidos:

/* Exemplo: Nomes inválidos de variáveis*/

var nivel2;
var salario_base;
Exemplos de nomes inválidos:

/* Exemplo: Nomes inválidos de variáveis*/

var ncarro&cia;

As variáveis em JavaScript também não podem ser nomeadas

com palavras reservadas da linguagem. A seguir são apresentadas
palavras reservadas do ECMA-Script 2015:

break case catch class

const continue debugger default
delete do else export
extends finally for function
if import in instanceof
new return super switch
this throw try typeof
var void while with
yield

Em JavaScript existem também algumas palavras conhecidas

com palavras reservadas para o futuro. Essas palavras reservadas
são palavras que poderão no futuro fazer parte do ECMAScript, e
não devem ser utilizadas para nomear variáveis.
Palavra sempre reserva:

enum

Palavras reservadas em strict-mode:

implements package public

interface private static
let protect
 Reservadas quando localizadas no código do módulo:

await

As palavras null, true e false também não devem ser

utilizadas para nomear variáveis.

Variáveis e atribuição de valores

Em JavaScript podemos atribuir as variáveis valores

numéricos, alfanuméricos, nulos, outras variáveis, arrays, objetos
e funções. Em JavaScript utiliza-se o sinal de igual ( = ) para
atribuir valores as variáveis.

var nome = 'John'

Nesse exemplo a variável nome recebeu o valor John que é

uma string (sequência de caracteres alfanuméricos delimitados por
aspas).
Também é possível atribuir valores numéricos as variáveis.

let idade = 20;

Quando criamos uma variável em JavaScript e não atribuímos

nenhum valor, ela terá o valor undefined.

let nome;
 No exemplo anterior, nome assume o valor undefined. Nesse
caso ao tentar acessar a variável o valor unefined será exibido.

let nome;
console.log(nome) // será exibido undefined

Variáveis e escopos

O escopo de uma variável refere-se a sua visibilidade ou

acessibilidade dentro do programa. Em JavaScript podemos criar
variáveis dentro e fora de funções. Quando criamos as variáveis
fora das funções podemos chamá-las de variáveis globais, e estão
visíveis em qualquer parte do código no documento.

/*Exemplo: Variável global */

var fruta = 'Abacaxi' ;
function exibeFruta() {
console.log(fruta)
}
exibeFruta() // a saída será Abacaxi
console.log(fruta) // a saída será Abacaxi

No exemplo acima a variável fruta foi criada fora da função

exibeFruta, mas pode ser acessada dentro da função.
No próximo exemplo vamos criar a variável fruta dentro da
função exibeFruta().

function exibeFruta() {
var fruta = 'Abacaxi' ;
console.log(fruta)
}
exibeFruta() // a saída será: Abacaxi
console.log(fruta) // a saída será: ReferenceError: fruta is not defined
 Note que ao criarmos a variável fruta dentro da função ela
passa a ter escopo local e não poderá ser acessada fora da
função. Desse modo um erro é exibido na última linha do exemplo
pois estamos tentando acessar uma variável que não foi definida
no escopo global.

Praticando
• Abra o VSCode e digite o exemplo a seguir:

• Salve o arquivo como: variaveis.js

• Abra o terminal e execute: node variaveis.js
• O programa deverá exibir:

Escopo de declaração de bloco

Antes do ECMAScript 6 não era possível o escopo de

declaração de bloco. No escopo de declaração de bloco, a variável
criada dentro do escopo pertence apenas aquele bloco e não pode
ser acessada fora dele. Para melhor entender esse conceito
vamos analisar o código a seguir.

var idade = 18;

if (idade >= 18){

var maiorIdade = true;
}

console.log(maiorIdade); //Saída: true

Note no exemplo anterior que a variável maiorIdade foi criada

dentro do bloco da declaração if. Mesmo assim ela pode ser
acessada fora do escopo de declaração pois antes do ECMAScript
2015 não era possível escopo de declaração de bloco. Com a
introdução do comando let passou a ser possível o escopo de
declaração de bloco. Veja o exemplo a seguir:

var idade = 18;

if (idade >= 18){

let maiorIdade = true;
}

console.log(maiorIdade); //Saída: ReferenceError: maiorIdade is not defined

Note que a saída do exemplo acima será um erro, pois a

variável maiorIdade pertence ao bloco da declaração if e não pode
ser acessa fora desse bloco.
Constantes

Em JavaScript podemos criar constantes que possuem

valores apenas de leitura. As constantes são criadas por meio da
palavra const.

const valor = 200;

As regras para o nome da criação das constantes são as

mesmas aplicadas as variáveis.
Caso uma constante tenha seu valor alterado o seguinte erro
é exibido: Assignment to constant variable. Veja o exemplo
abaixo:

const valor = 200;

valor = 100; //Não é possível alterar o valor de uma constante.

Cabe ressaltar que as regras de escopo para as constantes

são as mesmas aplicadas as variáveis let, ou seja, declaração de
escopo de bloco.

Tipos de dados e conversões

Em JavaScript não há necessidade de tipar os dados

previamente, porém é necessário ter um bom entendimento de
como os tipos de dados são representados na linguagem.
 De acordo com o ECMAScript mais recente, o JavaScript
suporta sete tipos de dados: seis primitivos e o Objeto.

Dados primitivos
boolean Tipo de dado lógico possui os valores true e false
null É um valor nulo ou vazio (aponta para um objeto inexistente)
undefined Valor indefinido
number É um tipo de dado numérico inteiro ou ponto flutuante
string Sequência de caracteres alfanuméricos.
symbol Tipo de dado com instâncias únicas e imutáveis

Tipo Objeto

O objeto pode ser entendido como uma estrutura de dados

que pode conter diferentes tipos de dados primitivos, para melhor
representar um modelo do mundo real.

Boolean

O boolean é o tipo de dado utilizado para representar os

valores lógicos true e false. São muito utilizados em estruturas de
decisão como if.
No exemplo anterior nada será impresso, pois somente
entrará no bloco if se a variável chovendo possuir o valor true.

var chovendo = false;

if(chovendo) {
console.log('Está chovendo');
}
O tipo null

O tipo null em JavaScript representa nulo. Uma variável

quando setada para null não possui nenhum valor. Quando
necessitar limpar o valor de uma variável sem a necessidade de
excluí-la, basta atribuir null a ela. Cabe ressaltar que uma variável
quando setada para null possui o tipo Object.

O tipo de dados undefined

O tipo undefined é retornado quando tenta-se acessar uma

variável que foi criada mas ainda não foi iniciada.

var test;
console.log(test); // saída: undefined

Uma função também pode retornar undefined caso a variável

de retorno não possuir um valor.

function exibeFrase(){
var fraseDoDia;
return fraseDoDia;
}
console.log(exibeFrase()); // saída: undefined

O tipo de dados Number

O JavaScript trata os números como sendo do mesmo tipo

tanto os inteiros quando os de ponto flutuante (números com casas
decimais). O ECMAScript trata os números com o padrão double-
precision binary floating-point format: binary64.
Vamos praticar um pouco os números inteiros, declarando
algumas variáveis e atribuindo valores inteiros

var idade = 18;

var ano = 2018;
var temperatura = 30;
var nota = 10;

Para trabalhar com números de ponto flutuante em JavaScript

utiliza-se o ponto como separador das casas decimais.

var valorProduto = 351.35;

var nota = 7.5;
var analise = 0.001;

Os números em ponto flutuante também podem ser escritos

na forma de notação científica. Utiliza-se o e (maiúsculo ou
minúsculo) para representar números em notação científica.

var numero = 1e-4;

console.log (numero); // saída: 0.0001

O JavaScript também possui alguns casos especiais como:

• NaN (not a number): NaN (não é um número) é apresentado
quando os dados numéricos são relacionados com valores
inadequados como caracteres ou valores undefined.

var nome = 'Pedro';

console.log (nome * 2); // saída: NaN
 • Infinity: Valor que representa infinito. JavaScript exibe Infinity
para valores numéricos que excedem o limite dos valores de
ponto flutuante: 1.797693134862315e+308, tanto positivos
quanto negativos.

var valorA = '1.797693134862315e+308';

console.log (valorA); // saída: 1.797693134862315e+308

var valorB = '1.797693134862315e+309';

console.log (valorB); // saída: Infinity

O tipo de dados String

Os tipos de dados String são utilizados geralmente quando

necessita-se armazenar informações do tipo texto. Pode ser um
texto breve como um nome de cidade ou um texto longo como um
documento. Para declarar variáveis do tipo string em JavaScript,
basta colocar o seu conteúdo entre aspas simples ou duplas.

var nome = 'João';

var cidade = "São Paulo”;

Também é possível declarar as strings usando o objeto String.

var x = "Pedro";
var y = new String("Pedro");

// typeof x -> string

// typeof y -> object
Objetos Date

Quando necessitamos trabalhar com datas em JavaScript

utilizamos os objetos date. Os objetos date consistem em um valor
de tempo numérico expresso em milisegundois baseados no UTC
(Universal Time Coordinated). Objetos date podem ser criados a
partir da função construtora Date.

var dataHoje = new Date();

console.log(dataHoje) // saída: 2018-01-09T12:22:05.647Z

Também é possível passar uma string como argumento da

função Date.

var dataHoje = new Date("2018/05/20");

console.log(dataHoje) // saída: 2018-05-20T03:00:00.000Z

CAPÍTULO 3

Operadores
No estudo das linguagens de programação um tópico bastante
importante e que deve ser bem compreendido pelos
desenvolvedores de software são os operadores. É com os
operadores que se aplica lógicas, atribui valores, entre outras
operações. O JavaScript possui vários operadores como: de
atribuição, de comparação, aritméticos, bit a bit, lógicos, de string,
condicionais, vírgula, unário e relacionais.

Operadores de atribuição

Esse operador serve para atribuir um valor a um operando.

Esse operador é representado pelo igual (=) . Como exemplo
podemos verificar um valor sendo atribuído a variável x por meio do
operador de atribuição.

var x = 10;

Podemos também atribuir ao operando o resultado de uma

expressão veja no exemplo abaixo.

var y = 10;
var x = y + 1;
console.log(x); //saída: 11
Operadores de comparação

Os operadores de comparação são usados quando

necessitamos comparar os operandos. Os operadores de
comparação retornam um valor lógico. Em JavaScript temos alguns
tipos de operadores de comparação: Igual (==), Não Igual (!=),
Estritamente igual (===), Estritamente desigual (!==), maior que
(>), menor que (<), maior ou igual (>=), menor ou igual (<=).
O operador Igual (==) é utilizado quando desejamos comparar
o valor de dois operandos sem se preocupar com o seu tipo. Nesse
caso se os operandos forem de tipos diferentes o JavaScript
procura convertê-los para um mesmo tipo. Veja alguns exemplos
abaixo.

var a = 2;
var b = 2;
var c = 3;
console.log(a==b); //saída: true
console.log(a==c); //saída: false

Note que se o valor da variável c for alterada para o tipo string

contendo o valor “2”, a comparação da variável a com a variável
c resulta em true. Nesse caso JavaScript converte para um tipo
mais apropriado e entende que os dois valores são iguais.

var a = 2;
var b = 2;
var c = "2";
console.log(a==b); //saída: true
console.log(a==c); //saída: true
 O operador não igual (!=), é usado quando deseja-se retornar
um valor verdadeiro quando os operandos não foram iguais.

var a = 2;
var b = 3;
console.log(a!=b); //saída: true

O operador estritamente igual (===), é usado quando

deseja-se retornar verdadeiro ao comparar-se dois operandos com
o mesmo valor e o mesmo tipo.

var a = 2;
var b = 2;
var c = "2";
console.log(a===b); //saída: true
console.log(a===c); //saída: false

O operador estritamente não igual (!==), é usado quando

deseja-se retornar verdadeiro ao comparar-se dois operandos com
valores diferentes mas com tipos iguais.
,
var a = 2;
var b = 2;
var c = "2";
console.log(a!==b); //saída: false
console.log(a!==c); //saída: true

O operador maior que (>) é usado quando deseja-se retornar

um valor verdadeiro ao comparar-se dois operandos, e o operando
da esquerda for maior do que o operando da direita.
 var a = 3;
var b = 2;
var c = 10;
console.log(a>b); //saída: true
console.log(a>c); //saída: false

O operador maior ou igual (>=) é usado quando deseja-se

retornar um valor verdadeiro ao comparar-se dois operandos, e o
operando da esquerda for maior ou igual ao operando da direita.

var a = 3;
var b = 3;
var c = 4;
console.log(a>=b); //saída: true
console.log(a>=c); //saída: false

O operador menor (<) é usado quando deseja-se retornar um

valor verdadeiro ao comparar-se dois operandos, e o operando da
esquerda seja menor do que o da direita.

var a = 5;
var b = 8;
var c = 2;
console.log(a<b); //saída: true
console.log(a<c); //saída: false

O operador menor ou igual (<=) é usado quando deseja-se

retornar um valor verdadeiro ao comparar-se dois operandos, e o
operando da esquerda seja menor ou igual ao operando da direita.
 var a = 5;
var b = 8;
var c = 5;
console.log(a<=b); //saída: true
console.log(a<=c); //saída: true

Operadores aritméticos

Quando desejamos realizar operações aritméticas entre os

operandos e retornar valores numéricos utilizamos os operadores
aritméticos. Em JavaScript os operadores aritméticos padrão são:
soma (+), subtração (-), multiplicação (*) e divisão (/). Além
desses operadores padrão podemos encontrar alguns operadores
complementares como: módulo (%), incremento (++),
decremento (--), exponenciação (**).

Operador soma (+)

Esse operador é utilizado quando deseja-se somar o valor de

variáveis em uma expressão aritmética.

var x = 10;
var y = 50;
var z = x + y;
console.log(z); //saída: 60
Operador subtração (-)

Esse operador é utilizado quando deseja-se subtrair o valor de

variáveis em uma expressão aritmética.

var a = 10;
var b = 3;
var c = a - b;
console.log(c); //saída: 7

Operador multiplicação (*)

Esse operador é utilizado quando deseja-se multiplicar o valor

de variáveis em uma expressão aritmética.

var a = 2;
var b = 5;
var c = a * b;
console.log(c); //saída: 10

Operador Divisão (/)

Esse operador é utilizado quando deseja-se dividir o valor de

variáveis em uma expressão aritmética.

var a = 6;
var b = 2;
var c = a / b;
console.log(c); //saída: 3
Abreviações com operadores de atribuição

Podemos escrever os operadores de atribuição encurtando

sua escrita. Esse procedimento torna o código menor e mais limpo.
Veja abaixo alguns exemplos.

Operador Abreviado Normal

Atribuição de adição x += y x=x+y
Atribuição de subtração x *= y x=x-y
Atribuição de multiplicação x *= y x=x*y
Atribuição de divisão x /= y x=x/y
Atribuição de resto x %= y x=x%y
Atribuição exponencial x **= y x = x ** y

Expressões aritméticas

A partir dos operadores aritméticos vistos anteriormente

podemos montar expressões matemáticas mais complexas.

var a = 6;
var b = 2;
var c = 10;

var d = a * b - 10
var e = a * b + 10 / b
var f = (a * b + 10) / b

console.log(d); //saída: 2
console.log(e); //saída: 17
console.log(f); //saída: 11

Note no exemplo anterior que na expressão da variável f,

foram introduzidos os parênteses e o resultado obtido foi diferente
do resultado da variável e. Isso se dá pela precedência entre os
operadores.

Operador módulo (%)

Existem casos que necessita-se obter o valor do resto da

divisão entre duas variáveis. O operador módulo (%) é um
operador binário que retorna um valor inteiro resultante da divisão
de dois operandos.

var a = 3;
var b = 2;
var c = 3;
var d = a % b; // retornará o resto da divisão de 3 por 2
var e = a % c; // retornará o resto da divisão de 3 por 3

console.log(d); //saída: 1
console.log(e); //saída: 0

Operador de exponenciação (**)

Operador que calcula a base elevada a potência do expoente.

var a = 2 ** 3;

console.log(a); //saída: 8
console.log(e); //saída: 0
Operador incremento (++)

O operador incremento (++) é um operador unário que

adiciona o um (1) ao valor do seu operando. O operador
incremento pode ser pós-fixado (x++), ou pré-fixado (++x).

var x = 2;
var y = x++;

console.log(y); //saída: 2
console.log(x); //saída: 3

Note que no exemplo anterior foi usado o incremento pós-

fixado, e verificou-se no exemplo que o resultado para y foi 2 e
para x foi 3. Isso se dá porque o incremento pós-fixado retorna o
valor original da variável (no caso x=2) e após define o valor
aplicando o incremento de mais um (resultando no exemplo x=3).
Veja a seguir o mesmo exemplo porém agora usando o incremento
pré-fixado.

var x = 2;
var y = ++x;

console.log(y); //saída: 3
console.log(x); //saída: 3

Nesse caso o valor de x e y é igual a 3. Isso se dá porque o

incremento pré-fixado define e retorna o valor do operando
incrementado de mais 1 (um).
Operador decremento (--)

O operador decremento (--) é um operador unário que subtrai

um (1) ao valor do seu operando. Assim como o operador
incremento, o operador decremento pode ser pós-fixado (x--), ou
pré-fixado (--x).Exemplo de decremento pós-fixado.

var x = 2;
var y = x--;

console.log(y); //saída: 2
console.log(x); //saída: 1

Exemplo de decremento pré-fixado.

var x = 2;
var y = --x;

console.log(y); //saída: 1
console.log(x); //saída: 1

Operadores lógicos

Operadores lógicos são comumente utilizados quando se

deseja definir algum tipo de lógica com operandos. Os operadores
lógicos podem ser utilizados com valores booleanos ou não. Em
JavaScript temos os seguintes operadores lógicos: And lógico
(&&), OU Lógico (||), NOT lógico (!).
And lógico (&&)

Utilizamos o operador lógico && quando desejamos que todos

os argumentos sejam verdadeiros em uma expressão lógica. Caso
algum argumento da expressão não seja verdadeiro teremos falso
como retorno.

var argumento1 = true;

var argumento2 = true;
var argumento3 = false;

console.log(argumento1 && argumento2); //saída: true

console.log(argumento1 && argumento2 && argumento3); //saída: false

OR lógico (||)

O operado lógico II retorna verdadeiro caso algum dos

argumentos da expressão avaliada seja verdadeiro (true).

var argumento1 = true;

var argumento2 = true;
var argumento3 = false;

console.log(argumento1 || argumento2); //saída: true

console.log(argumento1 || argumento2 || argumento3); //saída: true

NOT lógico (!)

O operador NOT lógico (!) nega o argumento ou expressão

invertendo de verdadeiro para falso e vice-versa.
 var argumento1 = true;
var argumento2 = true;
var argumento3 = false;

console.log(!(argumento1 && argumento3)); //saída: true

console.log(!argumento1 || !argumento2 || argumento3); //saída: false

Operador condicional ternário

Operador condicional utilizado quando deseja-se testar uma

condição e retornar um valor verdadeiro ou falso. Nesse operador
trabalha-se com três operandos.

condicao ? valor_1 : valor_2

No exemplo acima caso a condição seja verdadeira retornará

o valor_1 caso contrário o valor_2. Vamos agora ver um exemplo
prático da utilização de um ternário.

var botaoSalvarVisivel = (dadosForm === 'validados') ? true : false;

No exemplo acima a variável dadosForm é verificada e caso

seu valor seja igual validados a variável botaoSalvarVisivel
recebe o valor true, caso contrário recebe false.
O operador typeof

O operador typeof é usado quando necessita-se saber o

tipo da variável. Note que no exemplo a seguir o operador typeof é
usado para exibir o tipo da variável condicao. E como visto
anteriormente percebe-se que ao verificar o tipo da variável após
ela ter sido setada para null o JavaScript exibe o valor object e não
null.

var condicao = true;

console.log(typeof(condicao)); // saída: boolean
condicao = null;
console.log(typeof(condicao)); // saída: object
CAPÍTULO 4

Controle de fluxo

Antes de iniciarmos propriamente o conteúdo referente a

controle de fluxo, vamos entender o conceito de declaração de
bloco. Quando precisamos agrupar código em determinadas
regiões declaramos blocos para esse fim. Os blocos em JavaScript
são declarados entre chaves. Veja o exemplo abaixo.

{
declaração a;
declaração b;
.
.
.
declaração n;
}

Perceba que no exemplo anterior foi aberto as chaves, em

seguida foram escritas algumas declarações (código em
JavaScript), e em seguida foram fechadas as chaves. As
declarações em bloco serão usadas nos controles de fluxo.

Declaração if….else

Quando formos controlar o fluxo de execução baseando-se

em uma condição lógica, podemos utilizar a declaração condicional
if….else. Esse modelo condicional verifica se uma dada condição
é verdadeira. Se for verdade ele executa um bloco, caso contrário
executa um outro bloco.

if (condicao) {
codigo_1;
} else {
codigo_2;
}

No exemplo anterior caso a variável condicao, seja

verdadeira o programa executará o codigo_1, caso falsa será
executado o codigo_2. Vamos ver um outro exemplo mais prático.

var nota = 7

if (nota>=7) {
console.log('Aluno aprovado.');
} else {
console.log('Aluno em exame.');
}

No exemplo o valor de nota foi iniciado com sete, logo ao ser

verificado na condicional if, ele retorna verdadeiro. Portanto o
programa irá imprimir: Aluno aprovado.
Podemos também testar várias condições em sequência na
estrutura if….else.

if (condicao_a) {
codigo_1;
} else if (condicao_b) {
codigo_2;
} else if (condicao_n) {
codigo_n;
} else {
outro_codigo;
}
 Vamos agora utilizar esse modelo para escrever um pequeno
tradutor de palavras de inglês para português.

var palavra = 'whale';

if (palavra == 'dog') {
console.log('cão');
} else if (palavra == 'cat') {
console.log(palavra == 'gato');
} else if (palavra == 'wolf') {
console.log('lobo');
} else {
console.log('palavra não encontrada');
}

No exemplo acima a variável palavra será testada três vezes e

em nenhum dos casos retorna verdadeiro. Diante disso o fluxo será
redirecionado para o else com a seguinte saída: palavra não
encontrada.

Declaração switch

Outra forma de controlar o fluxo de execução em JavaScript é por

meio da declaração condicional switch. Nesse modelo uma
expressão é avaliada e em seguida associada a um rótulo case.
switch (expressao) {
case rotulo_1:
codigo_1
[break;]
case rotulo_2:
codigo_2
[break;]
...
default:
codigo_padrao
[break;]
}
 No exemplo acima o case verifica os rótulos com o valor da
expressão. Caso seja verdadeiro ele executa o comando e em
seguida sai do bloco do switch por meio do comando break. Caso
nenhuma condição seja satisfeita ao testar todos os rótulos com o
comando case, o fluxo da estrutura switch é direcionado para
default e o codigo_padrao é executado.
Vamos agora ver um exemplo prático na utilização do switch.

switch (diaSemana) {
case "Sunday":
console.log("Domingo");
break;
case "Monday":
console.log("Segunda-feira");
break;
case "Tuesday":
console.log("Terça-feira");
break;
case "Wednesday":
console.log("Quarta-feira");
break;
case "Thursday":
console.log("Quinta-feira");
break;
case "Friday":
console.log("Sexta-feira");
break;
case "Saturday":
console.log("Sábado");
break;
default:
console.log("Não econtrado.");
}
CAPÍTULO 5

Laços de repetição (loops)

Existem casos onde deseja-se repetir um trecho de código n

vezes. Para isso utiliza-se os laços de repetição ou loops como
também são conhecidos. Em JavaScript existem alguns tipos de
laços de repetição como: for, while, do...while, for...in.

Laço for

Assim como em outras linguagens de programação como

Java e C, o JavaScript também utiliza o laço for para repetir um
determinado trecho de código. Veja a sintaxe do for no exemplo
abaixo.

for ([inicio]; [condicao]; [incremento]){

codigo
}

• inicio: é onde inicializa-se uma variável de controle;

• condicao: é onde a variável de controle é avaliada em uma
determinada condição.
• incremento: incrementa a variável de controle.

Vamos ver um alguns exemplos da utilização do for.

Exemplo1: Imprimir três vezes na tela a string ola mundo!
 for (var i=0; i<3; i++){
console.log('ola mundo!')
}

// saída: ola mundo!

ola mundo!
ola mundo!

Exemplo2: Imprimir na tela números de um a cinco.

for (var x=1; x<=5; x++){

console.log(x);
}
// saída: 1
2
3
4
5

Exemplo3: Imprimir na tela números de um a cinco em ordem

decrescente.

for (var x=5; x>=1; x--){

console.log(x);
}
// saída: 5
4
3
2
1

Note que no exemplo três foi utilizado decremento x--, para diminuir
o valor da variável x de um.
Laço while

O laço while assim como o laço for é uma estrutura de

repetição utilizada quando necessita-se repetir algum trecho de
código. No laço while uma condição lógica é avaliada no início e
caso seja verdadeira continua executando suas instruções.

while (condicao){
//codigo
}

Vamos agora escrever os exemplos utilizados no laço for,

porém agora na estrutura do laço while.

Exemplo1

var condicao = 0

while (condicao < 3){

console.log('ola mundo!');
condicao++;
}

// saída: ola mundo!

ola mundo!
ola mundo!

Note que no exemplo acima foi criado uma variável de

controle fora do bloco do while que servirá como condicao para o
laço. Um outro detalhe importante é que dentro do bloco do laço
while a variável condição é incrementada em um. Caso a variável
condicao não tivesse sido incrementada o laço nunca finalizaria.
Esse caso é conhecido como loop infinito e deve-se tomar
cuidado para que esse tipo de situação não ocorra.

Exemplo 2:

var x = 1
while (x <= 5){
console.log(x);
x++;
}
// saída: 1
2
3
4
5

Exemplo 3:

var x = 5
while (x >= 1){
console.log(x);
x--;
}
// saída: 5
4
3
2
1

Laço do….while

Nesse modelo de laço de repetição, o teste condicional ao

invés de ser realizado no início do bloco, é feito no final, logo após
o fechamento do bloco. Isso faz com que pelo menos uma vez o
código que está dentro do bloco do laço seja executado.

do {
//código
} while (condicao);

Vamos ver os mesmos exemplos anteriores usando agora o laço

do….while.

Exemplo1

var condicao = 0

do {
console.log('ola mundo!');
condicao++;
}while (condicao < 3)

// saída: ola mundo!

ola mundo!
ola mundo!

Exemplo 2:

var x = 1
do {
console.log(x);
x++;
}while (x <= 5)
// saída: 1
2
3
4
5
Exemplo 3:

var x = 5
do {
console.log(x);
x--;
}while (x >= 1)
// saída: 5
4
3
2
1

Break

Quando deseja-se forçar o término de um laço utiliza-se a

declaração break.

for (i = 0; i < 7; i++) {

if (i === 3) {
break;
}
console.log(i);
}
// saída: 0
1
2

No exemplo acima a variável i é avaliada e caso seu valor

seja igual a 3 a declaração break é executada fazendo com que o
laço seja interrompido, passando o fluxo para a primeira linha após
o fechamento do bloco do laço for.
Continue

Assim como o break a declaração continue também

interrompe a execução de uma iteração. A declaração continue faz
com que seja chamada a próxima iteração do laço. Desse modo
ela não necessariamente finaliza o laço como no caso do break.

for (i = 0; i < 7; i++) {

if (i === 3) {
continue;
}
console.log(i);
}
// saída: 0
1
2
4
5
6

No exemplo acima a variável i é avaliada e caso seu valor

seja igual a 3 a declaração continue é executada fazendo com que
seja executada a próxima iteração do laço.
CAPÍTULO 6

Funções

Uma função em JavaScript é um bloco de código ou um

subprograma que serve para armazenar uma sequência de
instruções desenhadas para um propósito específico. Em
JavaScript funções podem ser entendidas como um tipo de objeto
que pode ser invocado.

Declarando funções

Existem algumas maneiras de declarar funções em

JavaScript. A forma mais comum de definição de funções em
JavaScript segue a seguinte sintaxe:
• Nome da função;
• Lista de parâmetros;
• Retorno da função.

function soma (a,b) {

return a + b;
}

É importa destacar que a lista de parâmetros não é obrigatória,

nem a palavra return.

function olaMundo() {
console.log('ola Mundo!');
}
Chamadas de funções

Em JavaScript definir uma função não necessariamente quer

dizer que estamos a invocando. Veja no exemplo a seguir a função
olaMundo sendo chamada.

function olaMundo() {
console.log('ola Mundo!');
}
olaMundo(); //chamada da função

Caso a função possua parâmetros basta na chamada da

mesma informar os valores dos parâmetros.

function olaMundo(frase) {
console.log(frase);
}
olaMundo('Ola Mundo!'); //chamada da função passando parâmetros

Funções anônimas

Existem funções em JavaScript que não possuem nomes.

Essas funções são conhecidas como funções anônimas. Uma
função anônima pode ser passada como expressão de função para
uma variável.

var quadrado = function(n) { return n * n};

console.log(quadrado(3)); //saída: 9
Arrow functions

As arrow functions foram introduzidas com o ES6. Elas são

funções anônimas com uma sintaxe mais reduzida. Vamos
implementar agora o exemplo anterior usando uma arrow function.

var quadrado = (n) => { return n * n};

console.log(quadrado(3)); //saída: 9

Note que no exemplo acima foi retirada a palavra function e

introduzido o símbolo (=>). Quando a função possui apenas uma
linha, podemos suprimir as chaves e a palavra return. Observe
como a sintaxe fica bem mais reduzida tornando o código mais
limpo.

var quadrado = (n) => n * n;

console.log(quadrado(3)); //saída: 9

Funções e Parâmetros

Vimos anteriormente que podemos passar valores para

funções por meios de parâmetros. Os parâmetros em JavaScript
possuem o valor undefined. Dessa forma é possível dentro do
corpo da função avaliar se o parâmetro possui algum valor
diferente de undefined. Porém com o ES6, é possível definir um
valor default para o parâmetro.

function soma(a, b=1) {

return a+b;
}

No exemplo acima o valor de b é por padrão igual a 1 caso

não seja passado nenhum valor para ele na chamada da função.
CAPÍTULO 7

Arrays

Um dos conceitos mais importantes quando estuda-se

linguagens de programação em geral são os arrays. Pode-se dizer
que os arrays em JavaScript, são estruturas de dados que
armazenam uma lista de valores. Se não tivéssemos as estruturas
do tipo array e fossemos utilizar variáveis comuns, teríamos que
criar uma variável para cada item da lista. Dessa forma os arrays
surgiram para simplificar o armazenamento de estruturas que
possuem listas de vários elementos. Na prática, os arrays são
utilizados para armazenar listas em geral como: listas de clientes,
produtos, vendas, entre muitas outras.

Criação de Arrays

Para criarmos arrays em JavaScript seguimos os mesmos

conceitos utilizados para a criação de variáveis. O que difere a
sintaxe de criação de um array em comparação a uma variável é
que atribuimos colchetes como seu valor. No exemplo a seguir
criamos um array vazio chamado numeros.

var numeros = [];

console.log(numeros) // saída: []
console.log(typeof(numeros)) // saída: Object
 Vamos agora criar um array para armazenar uma lista de
pessoas, iniciando com os valores: Pedro, Ana, Maria, Léo.

var pessoas = ['Pedro', 'Ana', 'Maria', 'Léo'];

console.log(pessoas) // saída: [ 'Pedro', 'Ana', 'Maria', 'Léo' ]

Vimos no exemplo anterior que para criaramos arrays e iniciá-

los com alguns valores basta colocar os valores dentro dos
colchetes e separá-los por vírgulas. Veja um outro exemplo de
como criar um array e iniciá-lo com valores numéricos.

var notas = [7, 5.5, 3.3, 9.6,10,4.5];

console.log(notas) // saída: [ 7, 5.5, 3.3, 9.6, 10, 4.5 ]

Podemos também encontrar arrays com tipos de dados

diferentes como strings, números, outros arrays, etc .

var professores = ['Carlos','Ana']

var disciplina = ['programação', professores, 2018];
console.log(disciplina) // saída: [ 'programação', [ 'Carlos', 'Ana' ], 2018 ]

Acessando itens do array

Os arrays são estruturas de dados indexadas, onde cada

elemento do array possui sua posição. Os elementos do array
podem ser acessados por meio de suas posições. Os arrays em
JavaScript são indexados iniciando na posição 0 (zero) até a sua
última posição.
Exemplo: Ao criarmos um array chamado vogais e iniciar suas
posições com as vogais: A, E, I, O, U, internamente o JavaScript
cria uma estrutura com cinco posições para representar o array
definido. Perceba que o primeiro elemento está na posição 0 e o
último na posição 4.
var vogais = ['A','E','I','O','U']
A E I O U
0 1 2 3 4
Vamos agora acessar as posições do array do exemplo
anterior e imprimir os resultados na tela.

var vogais = ['A','E','I','O','U']

console.log( vogais[0] ) //saída: A
console.log( vogais[1] ) //saída: E
console.log( vogais[2] ) //saída: I
console.log( vogais[3] ) //saída: O
console.log( vogais[4] ) //saída: U

Perceba que para acessar qualquer posição do array deve-se

digitar o nome do array seguido de sua posição entre colchetes.

Alterando dados do array

Para alterar os valores do array também se faz necessário

acessar o elemento em específico que deseja-se alterar. Basta
acessar sua posição e digitar um novo valor para o mesmo. No
próximo exemplo vamos criar um array para representar notas e
vamos alterar os valores da primeira e última posição.
 var notas = [4,6,7.5,5,9]
console.log(notas) //saída: [ 4, 6, 7.5, 5, 9 ]

notas[0] = 5.5 // alterando o valor do elemento da posição 0

notas[4] = 8 // alterando o valor do elemento da posição 4

console.log(notas) //saída: [ 5.5, 6, 7.5, 5, 8 ]

Adicionando novos elementos no array

Existem casos em que desejamos adicionar novos elementos

em array. Em JavaScript para adicionarmos novos elementos em
um array usamos a função push(). Ao utilizarmos a função push um
novo elemento será inserido no final do array.

var cidades = ['Sao Paulo','Porto Alegre','Salvador']

console.log(cidades) //saída: [ 'Sao Paulo', 'Porto Alegre', 'Salvador' ]

cidades.push('Curitiba')
console.log(cidades) //saída: [ 'Sao Paulo', 'Porto Alegre', 'Salvador', 'Curitiba' ]

Uma outra forma de inserir elementos em um array é por meio

do método unshift(). A diferença dele do método push(), é que
adiciona elementos no início do array. Vamos observar o mesmo
exemplo anterior porém agora utilizando o método unshift para
inserir um novo elemento.

var cidades = ['Sao Paulo','Porto Alegre','Salvador']

console.log(cidades) //saída: [ 'Sao Paulo', 'Porto Alegre', 'Salvador' ]

cidades.unshift('Curitiba')
console.log(cidades) //saída: [ 'Curitiba', 'Sao Paulo', 'Porto Alegre', 'Salvador' ]
Removendo elementos de um array

Para remover elementos de um array podemos utilizar o

método pop(). Esse método remove o último elemento do array.

var cidades = ['Sao Paulo','Porto Alegre','Salvador']

console.log(cidades) //saída: [ 'Sao Paulo', 'Porto Alegre', 'Salvador' ]

cidades.pop()
console.log(cidades) //saída: [ 'Sao Paulo', 'Porto Alegre' ]

Além do método pop também podemos utilizar o método

shift() para remover elementos de um array. O método shift é
utilizado quando desejamos remover elementos do início do array.

var cidades = ['Sao Paulo','Porto Alegre','Salvador']

console.log(cidades) //saída: [ 'Sao Paulo', 'Porto Alegre', 'Salvador' ]

cidades.shift()
console.log(cidades) //saída: [ 'Porto Alegre', 'Salvador' ]

Tamanho do array

Em JavaScript quando necessitamos saber o comprimento de

um array (número de posições), podemos utilizar a propriedade
length.

var pessoas = ['John','Alice','Peter','Jack', 'Alex']

console.log(pessoas.length) //saída: 5
 Note que se formos acessar o array em uma posição que não
existe, teremos como resultado: undefined.

var pessoas = ['John','Alice','Peter','Jack', 'Alex']

var posicao = pessoas.length
console.log(pessoas[posicao]) //saída: undefined

Converter Strings em Arrays

Existem situações onde necessita-se converter strings em

arrays. Em JavaScript essa tarefa pode ser feita utilizando o
método split(). Vamos supor que no exemplo anterior ao invés do
array pessoas tivéssemos uma string contento os dados separados
por vírgula. Podemos facilmente converter essa string em um
array, observe o exemplo abaixo.

var pessoas = 'John,Alice,Peter,Jack, Alex';

console.log(pessoas) //saída: John,Alice,Peter,Jack, Alex
pessoas = pessoas.split(',')
console.log(pessoas) // saída: [ 'John', 'Alice', 'Peter', 'Jack', ' Alex' ]

Unindo Arrays

Para unir dois arrays em JavaScript, podemos utilizar o

método concat().O método concat serve para unir dois arrays e
retornar um novo array.
 var n1 = [0,1,2,3,4,5];
var n2 = [10,12,15,30,45,80];

console.log(n1.concat(n2)); // saída: [ 0, 1, 2, 3, 4, 5, 10, 12, 15, 30, 45, 80 ]

Converter Arrays em Strings

Em JavaScript para unir todos os elementos de um array em

uma string utiliza-se o método join(). Para organizar os elementos
do array na string, o método join aceita um delimitador que é
passado como argumento. No exemplo a seguir vamos converter
um array em string delimitando os itens com vírgula.

var pessoas = ['John','Alice','Peter','Jack', 'Alex'];

var lista = pessoas.join(",") ;
console.log(lista); //saída: John,Alice,Peter,Jack,Alex

Poderíamos usar um outro delimitador no lugar da vírgula como um

traço por exemplo.

var pessoas = ['John','Alice','Peter','Jack', 'Alex'];

var lista = pessoas.join("-") ;
console.log(lista); //saída: John-Alice-Peter-Jack-Alex
Ordenando e invertendo os elementos do Array

Podemos utilizar o método sort() para ordenar os elementos

de um array. Veja no exemplo a seguir que o array pessoas foi
ordenado alfabeticamente com o método sort.

var pessoas = ['John','Alice','Peter','Jack', 'Alex'];

console.log(pessoas.sort()); //saída: [ 'Alex', 'Alice', 'Jack', 'John', 'Peter' ]

Caso exista a necessidade de inverter a ordem dos elementos

do array, onde o último elemento passa a ser o primeiro, podemos
utilizar o método reverse().

var pessoas = ['John','Alice','Peter','Jack', 'Alex'];

console.log(pessoas); //saída:[ 'John', 'Alice', 'Peter', 'Jack', 'Alex' ]
console.log(pessoas.reverse()); //saída: [ 'Alex', 'Jack', 'Peter', 'Alice', 'John' ]

Podemos também extrair uma quantidade de elementos de

um array a partir de uma posição definida. Para esse procedimento
utiliza-se o método slice(). O método possui dois argumentos. A
primeira e a última posição da faixa de elementos a serem
extraídos do array. A contagem das posições inicia em 0 de acordo
com o índice do array.

var pessoas = ['John','Alice','Peter','Jack', 'Alex'];

console.log(pessoas.slice(1,4)); //saída:[ 'Alice', 'Peter', 'Jack' ]
Considerações do autor

Agora que você já possui uma boa base nos conceitos

introdutórios da linguagem JavaScript, você pode seguir seus
estudos aprimorando-se ainda mais na linguagem, ou até mesmo
em alguma tecnologia baseada nessa poderosa e tão popular
linguagem. Conforme citado no início desse livro, atualmente
existem no mercado muitas tecnologias baseadas em JavaScript.
Pesquise sobre essas tecnologias para você tornar-se um
desenvolvedor JavaScript atualizado com as tecnologias mais
atuais do mercado. Desejo a você muito sucesso e espero que de
alguma forma tenha contribuído para o seu crescimento
profissional.

Um Abraço!
O autor