(EJS) Parte 1 - O livro mais difícil que já li sobre JavaScript

Esse é um dos livros que eu tenho guardado desde que comecei a querer estudar programação.
E pra mim sempre foi um livro bem difícil de ler, e ainda comprei a versão inglês (sem saber inglês 😂)

Mas quando isso aconteceu eu tinha ali meus 18 anos (hoje quase 22), muita coisa mudou de lá pra cá.

Apesar de não ter aprendido JavaScript por causa desse livro, hoje eu vejo ele como um livro pra se aprofundar na linguagem. Isso porque cada capítulo você tem exercícios, mas são “OS EXERCÍCIOS”.

Nessa saga o que iremos fazer é passar por todo o livro, vamos passar pelas partes que eu acho que valem a pena ver mais devagar e aquelas outras irei resumir. Também é interessante que você já saiba JavaScript, porque nem de longe eu vejo esse livro como um livro pra iniciantes na área.

O básico da linguagem

O livro é dividido em três partes — Linguagem, Browser, Node e o que tenho em casa é a 3° edição.

No primeiro capítulo que é “Values, Types, and Operators” conhecemos os valores Number que no JavaScript se resume a um tipo só, onde temos um limite de 9 quadrilhões (15 zeros).

E quando quisermos usar valores decimais podemos usar o ponto:

1
let integer = 10;
2
let decimal = 5.5;

Para números maiores que o limite que falei, podemos usar a notação científica adicionando um e (Para o expoente do número):

1
let bigNumber = 2.998e8; // Isso quer dizer: 299800000

Com isso, o resultado dessa operação é: 2.998 x 10^8 = 299.800.000

Logo depois disso vem a aritmética, que é o próximo tópico. Nele aprendemos o básico, operadores de soma, subtração, divisão, resto e ordem de operações.

E pra finalizar o assunto de números chegamos aos números especiais que são três: Infinity, -Infinity e o nosso querido NaN.

Chegando ao tópico de Strings vemos que podemos criar strings de três formas, utilizando ‘aspas simples’, “aspas duplas” e as crases. Também podemos concatenar duas strings “hello” + ” world!”

E usar as crases para interpolar valores, exemplo:

1
let myName = "Wesley Damasceno";
2
let greeting = `Hello ${myName}`;

Até aqui é tudo muito lindo né? Nada tão difícil, então vamos pular um pouco. Mas relaxa aqui está o resumo dos próximos tópicos desse capítulo:

Resumo dos tópicos do capítulo 1, tirando os que já vimos:

Operadores unários: typeof e o -
Booleanos: true, false
Operadores lógicos: && para “and”, | | para “or” e ! para “not”
Valores vazios: undefined e null

A estrutura de um programa

Nesse capítulo a gente começa ligar os conceitos aprendidos no capítulo passado a fim de criar um programa de fato, então nele vemos sobre as palavras reservados do JavaScript, algumas funções internas da linguagem, o console.log, valores de retorno, fluxo de controle que é quando começamos a ver sobre as condicionais, também vemos os loops, reatribuições de variáveis, o switch e algumas dicas de como deve ser escrito os nomes das instruções.

Com isso, já ganhamos nossas primeiras tarefas que são três exercícios que envolvem praticar os conhecimentos adquiridos.

O primeiro é o “Looping a Triangle”, nele devemos criar um loop que faça o desenho de um triangulo:

1
#
2
##
3
###
4
####
5
#####
6
######
7
#######
8
########

Para resolver esse problema, podemos usar um loop for, aproveitando sua estrutura para gerenciar a construção da string e a condição de parada.

Inicializamos uma variável line com o valor inicial ”#”. A cada iteração, verificamos se o comprimento da string é menor que 8 (o número de linhas desejado). Se a condição for verdadeira, concatenamos mais um ”#” à string e exibimos o conteúdo de line no console:

1
for (let line = "#"; line.length < 8; line += "#") {
2
  console.log(line);
3
}

O segundo é o clássico FizzBuzz, que pra resolver eu fiz assim:

1
for (let i = 1; i <= 100; i++) {
2
  if (i % 3 === 0 && i % 5 === 0) {
3
    console.log("FizzBuzz");
4
  } else if (i % 3 === 0) {
5
    console.log("Fizz");
6
  } else if (i % 5 === 0) {
7
    console.log("Buzz");
8
  } else {
9
    console.log(i);
10
  }
11
}

É eu sei, não gosto também de ter muitos Ifs, mas é o que dá pra esse problema 🤡.

Por último temos o Chessboard, que é chatinho até, mas se pensar com calma dá certo.

Você deve escrever um programa que cria uma string que representa um grid 8x8 usando o \n para separar as linhas. Cada posição do grid deve ser um espaço vazio ou um ”#”, quando executado o console deve mostrar um tabuleiro de xadrez mais ou menos assim:

1
 # # # #
2
# # # #
3
 # # # #
4
# # # #
5
 # # # #
6
# # # #
7
 # # # #
8
# # # #

Para resolver esse problema, podemos utilizar a estratégia aritmética de posições de um grid, onde somamos os valores posicionais (coluna + linha / 2) e verificamos se o resto dessa divisão é inteira ou uma divisão quebrada (Sério desse jeito é bem interessante, confia)

Com isso em mente, podemos fazer a seguinte implementação:

1
const size = 8;
2
let board = "";
3

4
for (let y = 0; y < size; y++) {
5
  for (let x = 0; x < size; x++) {
6
    if ((x + y) % 2 === 0) board += " ";
7
    else board += "#";
8
  }
9

10
  board += "\n";
11
}
12

13
console.log(board);

Sobreviveu até aqui? Ainda não é nem o começo

Se você leu até aqui, muito obrigado você é pessoa muito massa 😎.

Mas e ai? Gostou desse último problema? No próximo blog dessa saga iremos continuar os próximos capítulos do livro onde veremos sobre funções e estruturas de dados.

Se você tem interesse em ler o livro, existe uma versão online gratuita com a edição mais recente.

Então é isso, até a próxima! 👋