JavaScript

Essencial
Guia Prático para Estudantes

Maurício Samy Silva

Novatec
Copyright © 2010, 2024 da Novatec Editora Ltda.
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
Revisão gramatical: Tássia Carvalho
Capa: Karina Tsuchiya
ISBN impresso: 978-85-7522-891-3
ISBN ebook: 978-85-7522-892-0
Histórico de impressões:
Março/2024 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: https://novatec.com.br
Twitter: twitter.com/novateceditora
Facebook: facebook.com/novatec
LinkedIn: linkedin.com/in/novatec
GRA20240229
 Sumário

Agradecimentos..................................................................................................................................15
Isenção de responsabilidade................................................................................................................16
Sobre o autor......................................................................................................................................17
Introdução..........................................................................................................................................18
Capítulo 1  Introdução à JavaScript...................................................................................................23
1.1 Histórico............................................................................................................. 23
1.2 Transpilers JavaScript.......................................................................................... 23
1.3 Ambientes de estudo........................................................................................... 24
1.4 Começando com JavaScript................................................................................. 24
1.4.1 Objeto.......................................................................................................... 24
1.4.2 Caixas de diálogo......................................................................................... 26
1.4.3 Codificação de caracteres em JavaScript........................................................ 27
1.4.4 Escrever HTML com JavaScript.................................................................... 28
1.4.5 Eventos........................................................................................................ 28
1.4.6 Atrelar JavaScript a documentos................................................................... 28
1.4.7 Import e export............................................................................................ 29
1.4.8 Estrutura léxica da JavaScript....................................................................... 31
1.4.9 Variáveis...................................................................................................... 34
1.4.10 Operador typeof......................................................................................... 36
1.4.11 Valores primitivos....................................................................................... 36
1.4.12 Funções...................................................................................................... 37
1.4.13 Palavras reservadas let e const..................................................................... 37
1.4.14 Hoisting..................................................................................................... 39
1.5 DOM HTML...................................................................................................... 41
1.6 DOM CSS........................................................................................................... 45

Capítulo 2  Operadores.....................................................................................................................46
2.1 Introdução.......................................................................................................... 46
2.2 Operadores......................................................................................................... 46
2.2.1 Operandos................................................................................................... 48
2.2.2 Precedência dos operadores.......................................................................... 48
2.2.3 Associatividade dos operadores.................................................................... 49

5
6 JavaScript Essencial

2.3 Operações matemáticas....................................................................................... 50

2.4 Operações lógicas............................................................................................... 51
2.4.1 Operador lógico &&.................................................................................... 52
2.4.2 Operador lógico ||........................................................................................ 52
2.4.3 Operador lógico !......................................................................................... 52
2.5 Operações com strings........................................................................................ 52
2.6 Operações de atribuição...................................................................................... 53
2.7 Operações especiais............................................................................................ 53
2.7.1 Operador condicional ? :............................................................................... 54
2.7.2 Operador de separação , (vírgula)................................................................. 54
2.7.3 Operador delete............................................................................................ 54
2.7.4 Operador in.................................................................................................. 54
2.7.5 Operador instanceof..................................................................................... 55
2.7.6 Operador new.............................................................................................. 55
2.7.7 Operador this............................................................................................... 55
2.7.8 Operador typeof........................................................................................... 55
2.7.9 Operador ().................................................................................................. 56
2.7.10 Operador void............................................................................................ 56
2.7.11 Operador spread......................................................................................... 56

Capítulo 3  Declarações e estruturas..................................................................................................58

3.1 Declarações......................................................................................................... 58
3.1.1 var, let, const................................................................................................ 59
3.1.2 Arrow function............................................................................................ 59
3.1.3 return.......................................................................................................... 62
3.2 Estruturas condicionais....................................................................................... 62
3.2.1 if.................................................................................................................. 62
3.2.2 else.............................................................................................................. 63
3.2.3 else if........................................................................................................... 63
3.2.4 switch.......................................................................................................... 63
3.3 Estruturas para loops.......................................................................................... 63
3.3.1 for................................................................................................................ 64
3.3.2 while........................................................................................................... 64
3.3.3 do–while..................................................................................................... 64
3.3.4 for–in........................................................................................................... 65
3.3.5 for–of.......................................................................................................... 65
3.4 ObjetoError......................................................................................................... 65
3.4.1 message........................................................................................................ 65
3.4.2 name............................................................................................................ 65
3.4.3 toString()..................................................................................................... 66
3.5 try–catch–finally................................................................................................. 66
3.6 throw.................................................................................................................. 66
3.7 with.................................................................................................................... 67
Sumário 7

Capítulo 4  Objeto.............................................................................................................................69
4.1 Objeto................................................................................................................. 69
4.1.1 Sintaxe formal.............................................................................................. 70
4.1.2 Sintaxe literal............................................................................................... 71
4.2 Construtor.......................................................................................................... 71
4.3 prototype............................................................................................................ 72
4.4 Classes................................................................................................................ 73

Capítulo 5  Array...............................................................................................................................75
5.1 Fundamentos...................................................................................................... 75
5.1.1 Array associativo.......................................................................................... 76
5.2 Propriedades do objeto Array............................................................................... 76
5.2.1 constructor.................................................................................................. 77
5.2.2 prototype..................................................................................................... 77
5.2.3 length.......................................................................................................... 77
5.3 Métodos do objeto Array..................................................................................... 77
5.3.1 Array.isArray(param).................................................................................... 77
5.3.2 concat(arr1 [, arr2, ... arrN])........................................................................ 77
5.3.3 join([separador])........................................................................................... 78
5.3.4 indexOf(el [,inicio])...................................................................................... 78
5.3.5 lastIndexOf(el [,inicio])................................................................................ 79
5.3.6 keys()........................................................................................................... 79
5.3.7 includes(elemento [,inicio])........................................................................... 79
5.3.8 shift().......................................................................................................... 80
5.3.9 pop()........................................................................................................... 80
5.3.10 unshift(elemento [,elemento1, ..., elementoN])............................................. 80
5.3.11 push(elemento [,elemento1, ..., elementoN])................................................. 80
5.3.12 splice(posição [,qde, elemento1..., elementoN])............................................ 80
5.3.13 valueOf().................................................................................................... 81
5.3.14 copyWithin(index [,inicio [,fim]])................................................................ 81
5.3.15 fill(el [,inicio [,fim])..................................................................................... 82
5.3.16 every(fn(el, [index [,arr]) [,thisValue]).......................................................... 83
5.3.17 some(fn(el [,index[,arr]] [,thisValue])........................................................... 83
5.3.18 find(fn(el, [index[,arr]) [,thisValue])............................................................. 83
5.3.19 findIndex(fn(el, [index[,arr]) [,thisValue]).................................................... 84
5.3.20 filter(fn(el, [index[,arr]) [,thisValue])............................................................ 84
5.3.21 map(fn(el, [index[,arr]) [,thisValue])............................................................ 84
5.3.22 forEach(fn(el, [index], [arr]), [thisValue])..................................................... 84
5.3.23 reduce(fn(acc, valorAtual[,index[,arr]) [,valorInicial]).................................. 85
5.3.24 reduceRight(fn(acumulador, valorAtual[,index[,arr]) [,valorInicial])............. 86
5.3.25 reverse()..................................................................................................... 86
5.3.26 slice(inicio [,fim])....................................................................................... 86
8 JavaScript Essencial

5.3.27 sort([fnComparadora])................................................................................ 87
5.3.28 toString()................................................................................................... 88
5.4 Atribuição via desestruturação (Destructuring assignment).................................. 88

Capítulo 6  Funções...........................................................................................................................90
6.1 Introdução.......................................................................................................... 90
6.2 Criando funções................................................................................................. 90
6.2.1 Declaração function..................................................................................... 91
6.2.2 Sintaxe literal – Função anônima.................................................................. 93
6.2.3 Construtor Function().................................................................................. 94
6.3 Retornando objetos............................................................................................. 95
6.3.1 Função retorna array indexado..................................................................... 95
6.3.2 Função retorna array associativo................................................................... 96
6.4 IIFE – Autoinvocar função................................................................................... 96
6.5 Escopo de uma função........................................................................................ 97
6.5.1 Sintaxe ES5.................................................................................................. 97
6.6 Closures............................................................................................................. 98
6.7 Funções globais..................................................................................................101
6.7.1 encodeURI(uri)........................................................................................... 102
6.7.2 decodeURI(uriCodificada).......................................................................... 102
6.7.3 encodeURIComponent(str)......................................................................... 102
6.7.4 decodeURIComponent(uriCodificada)........................................................ 102
6.7.5 eval(código)................................................................................................ 102
6.7.6 isFinite(valor)............................................................................................. 103
6.7.7 isNaN(valor)............................................................................................... 103
6.7.8 parseFloat(string)....................................................................................... 103
6.7.9 parseInt(string[, base])................................................................................ 104
6.8 Miscelânea........................................................................................................ 105
6.8.1 arguments.................................................................................................. 105
6.8.2 default parameters...................................................................................... 105
6.8.3 rest parameters.......................................................................................... 106
6.8.5 call(this, argumentos)................................................................................. 106
6.8.6 apply(this, array)........................................................................................ 109
6.8.7 setTimeout(fn [,delay, param1, ..., paramN])............................................... 109
6.8.8 clearTimeout(timeoutID).............................................................................110
6.8.9 setInterval(fn [,delay, param1, ..., paramN]).................................................110
6.8.10 clearInterval(intervalID)............................................................................111

Capítulo 7  Eventos......................................................................................................................... 112

7.1 Introdução........................................................................................................ 112
7.2 Atrelar evento com uso de propriedade............................................................... 113
7.3 Atrelar evento com uso de método......................................................................114
7.3.1 addEventListener(evento, fn[, useCapture])..................................................114
Sumário 9

7.3.2 removeEventListener(evento, fn [, useCapture])........................................... 115

7.4 Propagação de eventos....................................................................................... 115
7.5 Objeto event.......................................................................................................116
7.5.1 Propriedades do objeto event........................................................................116
7.6 Tipos de eventos.................................................................................................117
7.6.1 Eventos de mouse........................................................................................118
7.6.2 Eventos de teclado...................................................................................... 122
7.6.3 Eventos HTML........................................................................................... 123
7.7 Delegação de evento........................................................................................... 124
7.8 Remoção de manipulador de evento................................................................... 126

Capítulo 8  Objeto String................................................................................................................. 128

8.1 Definições......................................................................................................... 128
8.1.1 String como tipo de dado............................................................................ 128
8.1.2 String como objeto..................................................................................... 128
8.2 Criar strings...................................................................................................... 128
8.3 Propriedades das strings.................................................................................... 129
8.3.1 length........................................................................................................ 129
8.3.2 constructor................................................................................................ 129
8.3.3 prototype................................................................................................... 129
8.4 Métodos para strings......................................................................................... 129
8.4.1 charAt(index)............................................................................................. 129
8.4.2 charCodeAt(index)..................................................................................... 130
8.4.3 concat(string1, string2,...,stringN).............................................................. 130
8.4.4 endsWith(stringProcurada [,indexFim])...................................................... 131
8.4.5 fromCharCode(uni1, uni2,...,uniN)............................................................ 131
8.4.6 includes(stringProcurada [,inicio]).............................................................. 132
8.4.7 indexOf(stringProcurada [,inicio]).............................................................. 132
8.4.8 lastIndexOf(stringProcurada [,inicio])........................................................ 132
8.4.9 localeCompare(string)................................................................................ 133
8.4.10 repeat(count)............................................................................................ 133
8.4.11 match(expreg).......................................................................................... 133
8.4.12 replace(string | expreg, novaString | fn)..................................................... 134
8.4.13 search(expreg).......................................................................................... 135
8.4.14 slice(inicio [,fim])...................................................................................... 136
8.4.15 split([separador [,limite]])......................................................................... 136
8.4.16 startsWith(stringProcurada [,inicio])......................................................... 137
8.4.17 substring(inicio [,fim]).............................................................................. 137
8.4.18 toLowerCase().......................................................................................... 137
8.4.19 toString()................................................................................................. 138
8.4.20 toUpperCase().......................................................................................... 138
8.4.21 trim()....................................................................................................... 138
10 JavaScript Essencial

Capítulo 9  Objeto Number.............................................................................................................. 139

9.1 Construtor........................................................................................................ 139
9.2 Propriedades do objeto Number........................................................................ 139
9.2.1 MAX_VALUE............................................................................................ 139
9.2.2 MIN_VALUE............................................................................................. 140
9.2.3 POSITIVE_INFINITY............................................................................... 140
9.2.4 NEGATIVE_INFINITY............................................................................. 140
9.2.5 constructor................................................................................................ 140
9.2.6 prototype....................................................................................................141
9.3 Métodos do objeto Number................................................................................141
9.3.1 Number.isFinite(valor).................................................................................141
9.3.2 Number.isInteger(valor)...............................................................................141
9.3.3 Number.parseFloat(string)..........................................................................141
9.3.4 Number.parseInt(string [,base])...................................................................141
9.3.5 toString([base])...........................................................................................142
9.3.6 toFixed([digitos]).........................................................................................142
9.3.7 toPrecision([digitos])....................................................................................142
9.3.8 toExponential([dígitos])...............................................................................143

Capítulo 10  Objeto Math................................................................................................................144

10.1 Conceitos........................................................................................................ 144
10.2 Propriedades do objeto Math........................................................................... 144
10.3 Métodos do objeto Math..................................................................................145
10.3.1 abs(x)........................................................................................................145
10.3.2 sign(x).......................................................................................................145
10.3.3 max(x, y, z, ..., n).......................................................................................145
10.3.4 min(x, y, z, ..., n)....................................................................................... 146
10.3.5 hypot(x, y, ..., n)....................................................................................... 146
10.3.6 round(x)................................................................................................... 146
10.3.7 floor(x)..................................................................................................... 146
10.3.8 ceil(x)........................................................................................................147
10.3.9 trunc(x).....................................................................................................147
10.3.10 pow(x, y).................................................................................................147
10.3.11 sqrt(x).....................................................................................................147
10.3.12 random()................................................................................................ 148
10.3.13 exp(x).................................................................................................... 149
10.3.14 log(x)...................................................................................................... 149
10.3.15 log10(x).................................................................................................. 149
10.3.16 log2(x).................................................................................................... 149
10.3.17 log1p(x).................................................................................................. 150
10.3.18 sin(x)...................................................................................................... 150
10.3.19 cos(x)..................................................................................................... 150
Sumário 11

10.3.20 tan(x)..................................................................................................... 150

10.3.21 asin(x).................................................................................................... 150
10.3.22 acos(x)................................................................................................... 151
10.3.23 atan(x)................................................................................................... 151
10.3.24 atan2(y, x).............................................................................................. 151

Capítulo 11  Objeto Date................................................................................................................. 152

11.1 Introdução...................................................................................................... 152
11.2 Construtor...................................................................................................... 152
11.2.1 new Date()............................................................................................... 153
11.2.2 new Date(milissegundos).......................................................................... 153
11.2.3 new Date(data_string).............................................................................. 154
11.2.4 new Date(ano,mês[,dia][,hora][,minuto][,segundo][,milissegundo])............ 155
11.3 Métodos get do objeto Date............................................................................. 156
11.3.1 getDate().................................................................................................. 156
11.3.2 getFullYear()............................................................................................ 156
11.3.3 getMouth()............................................................................................... 156
11.3.4 getDay()................................................................................................... 156
11.3.5 getHours()............................................................................................... 157
11.3.6 getMinutes()............................................................................................. 157
11.3.7 getSeconds()............................................................................................. 157
11.3.8 getMillliseconds()..................................................................................... 157
11.3.9 getTime()................................................................................................. 157
11.3.10 getTimezoneOffset()............................................................................... 158
11.4 Métodos set do objeto Date.............................................................................. 158
11.4.1 setDate(dia_do_mês)................................................................................ 158
11.4.2 setYear(ano).............................................................................................. 158
11.4.3 setFullYear(ano [,mês][,dia])..................................................................... 158
11.4.4 setMonth(month [,dia])............................................................................. 159
11.4.5 setHours(hora [,min][,seg][,ms])............................................................... 159
11.4.6 setMinutes(min [,seg][,ms])...................................................................... 160
11.4.7 setSeconds(seg [,ms])................................................................................ 160
11.4.8 setMilliseconds(ms).................................................................................. 160
11.4.9 setTime(ms)...............................................................................................161
11.5 Outros métodos do objeto Date........................................................................161
11.5.1 toLocaleDateString().................................................................................161
11.5.2 toTimeString()...........................................................................................161
11.5.3 toLocaleTimeString()................................................................................ 162
11.5.4 toUTCString().......................................................................................... 162
11.5.5 toString()................................................................................................. 162
11.5.6 toGMTString()......................................................................................... 162
11.6 Manipulação de datas...................................................................................... 162
11.6.1 Contagem regressiva................................................................................. 163
12 JavaScript Essencial

Capítulo 12  Objeto RegExp............................................................................................................. 165

12.1 Introdução...................................................................................................... 165
12.2 Construtor...................................................................................................... 165
12.3 Modificador.................................................................................................... 166
12.4 Caracteres especiais......................................................................................... 166
12.4.1 Agrupadores............................................................................................. 166
12.4.2 Metacaracteres......................................................................................... 166
12.4.3 Quantificadores........................................................................................ 167
12.4.4 Memorizador............................................................................................ 167
12.5 Métodos do objeto RegExp.............................................................................. 167
12.5.1 test(str).................................................................................................... 168
12.5.2 exec(str)................................................................................................... 168
12.5.3 Métodos auxiliares................................................................................... 168
12.6 Busca e troca................................................................................................... 168

Capítulo 13  JSON............................................................................................................................ 170

13.1 Introdução.......................................................................................................170
13.2 JSON simples...................................................................................................170
13.3 JSON com arrays............................................................................................. 171
13.4 JSON aninhado............................................................................................... 171
13.5 Métodos JSON................................................................................................ 172
13.5.1 Método JSON.stringify().......................................................................... 172
13.6 API................................................................................................................. 173

Capítulo 14  AJAX............................................................................................................................ 175

14.1 Introdução........................................................................................................175
14.2 AJAX com API fetch.........................................................................................175
14.2.1 Promises...................................................................................................175
14.3.2 API Países.................................................................................................176
14.3 AJAX com Axios............................................................................................. 183
14.3.1 API REQRES............................................................................................ 184

Capítulo 15  CRUD com Node.js e Express.........................................................................................186

15.1 Introdução...................................................................................................... 186
15.2 Node.js........................................................................................................... 186
15.3 Ambiente de desenvolvimento.......................................................................... 187
15.3.1 Instalação do Node.js............................................................................... 187
15.3.2 CLI.......................................................................................................... 189
15.4 REST API........................................................................................................ 190
15.5 Apresentação da app livros.............................................................................. 191
15.6 CRUD na app livros........................................................................................ 195
15.6.1 Método GET............................................................................................ 196
Sumário 13

15.6.2 Método POST.......................................................................................... 198

15.6.3 Método PATCH....................................................................................... 199
15.6.4 Método DELETE..................................................................................... 200
15.6.5 POSTMAN.............................................................................................. 200
15.6.6 Teste da app crud-livros............................................................................ 201
15.6.7 Nota final................................................................................................. 203

Capítulo 16  ES6 Miscelânea............................................................................................................204

16.1 Introdução...................................................................................................... 204
16.2 Módulos ES6................................................................................................... 204
16.2.1 Sintaxes................................................................................................... 205
16.2.2 Renomear importação e exportação.......................................................... 206
16.2.3 Notas gerais sobre módulos...................................................................... 207
16.3 Tratamento de erros........................................................................................ 208
16.3.1 Tipos de erros........................................................................................... 208
16.3.2 Instrução throw....................................................................................... 210
16.3.3 Bloco try catch finally................................................................................211
16.4 Maps e sets.......................................................................................................211
16.4.1 Map......................................................................................................... 212
16.4.2 WeakMap.................................................................................................214
Referências bibliográficas.................................................................................................................. 215
Índice remissivo................................................................................................................................ 217