JavaScript Primer

Tipos Primitivos

Nome	Descrição
number	Usado para representar valores numéricos. JavaScript não diferencia entre inteiros e valores de ponto flutuante.
string	Usado para representar dados de texto.
boolean	Pode ter valores `true` e `false`.
symbol	Usado para representar valores constantes únicos, como chaves em coleções.
null	Pode receber apenas o valor `null` e é usado para indicar uma referência inexistente ou inválida.
undefined	Usado quando uma variável foi definida mas não foi atribuído um valor.
object	Usado para representar valores compostos, formados a partir de propriedades e valores individuais.

Comparação de Igualdade Abstrata (==)

A comparação x == y produz true ou false seguindo estas regras:

Se Type(x) é o mesmo que Type(y), então:
- Retorna o resultado da Comparação de Igualdade Estrita x === y
Se x é null e y é undefined, retorna true
Se x é undefined e y é null, retorna true
Se Type(x) é Number e Type(y) é String, retorna o resultado da comparação x == ToNumber(y)
Se Type(x) é String e Type(y) é Number, retorna o resultado da comparação ToNumber(x) == y
Se Type(x) é Boolean, retorna o resultado da comparação ToNumber(x) == y
Se Type(y) é Boolean, retorna o resultado da comparação x == ToNumber(y)
Se Type(x) é String, Number ou Symbol e Type(y) é Object, retorna o resultado da comparação x == ToPrimitive(y)
Se Type(x) é Object e Type(y) é String, Number ou Symbol, retorna o resultado da comparação ToPrimitive(x) == y
Retorna false

Comparação de Igualdade Estrita (===)

A comparação x === y produz true ou false seguindo estas regras:

Se Type(x) é diferente de Type(y), retorna false
Se Type(x) é Number, então:
- Se x é NaN, retorna false
- Se y é NaN, retorna false
- Se x é o mesmo valor Number que y, retorna true
- Se x é +0 e y é -0, retorna true
- Se x é -0 e y é +0, retorna true
- Retorna false
Retorna SameValueNonNumber(x, y)

Desviando da coerção de tipo

let hatPrice = 100;
console.log(`Hat price: ${hatPrice}`);
let bootsPrice = "100";
console.log(`Boots price: ${bootsPrice}`);
if (hatPrice === bootsPrice) {
    console.log("Prices are the same");
} else {
    console.log("Prices are different");
}
let totalPrice = Number(hatPrice) + Number(bootsPrice);
console.log(`Total Price: ${totalPrice}`);
let myVariable = "Adam";
console.log(`Type: ${typeof myVariable}`);
myVariable = 100;
console.log(`Type: ${typeof myVariable}`);

Trabalhando com funções

let hatPrice = 100;
console.log(`Hat price: ${hatPrice}`);
let bootsPrice = "100";
console.log(`Boots price: ${bootsPrice}`);
function sumPrices(first, second, third) {
    return first + second + third;
}
let totalPrice = sumPrices(hatPrice, bootsPrice);
console.log(`Total Price: ${totalPrice}`)

Como por padrão vai fazer com que a coersão ou alguma especificidade do tipo, aconteça ou seja que com tipos como string, boolean, object a função vai ser invocada

Strict Mode

É uma forma de escrever JavaScript diferente com suas próprias regras e claro com regras do ECMA, mas tento suas diferenças

Uma das questões é que ele elimina os erros silênciosos por throw errors
Proibe algumas sintaxes como as que vão ser definidas nas versões futuras do ECMAScript

Entendo `this` in Arrow Functions

Arrow Functions são diferentes das funções comuns:

Não possuem os valores do seu this e herança

let myObject = {
    greeting: "Hi, there",
    getWriter() {
        return (message) => console.log(`${this.greeting}, ${message}`);
    }
}
greeting = "Hello";
let writer = myObject.getWriter();
writer("It is raining today");
let standAlone = myObject.getWriter;
let standAloneWriter = standAlone();
standAloneWriter("It is sunny today");

03 November 2025