Fundamento do JavaScript

 Oque são Variaveis

Variáveis no JavaScript são espaços de armazenamento que podem

conter diferentes tipos de dados, como números, strings, booleanos,
objetos, entre outros. Elas permitem armazenar e manipular informações
dentro de um programa.

Existem diversos tipos de variáveis em JavaScript:

1. var: Era a forma antiga de declarar variáveis antes do ES6. Tem escopo de
função e pode ser redeclarada.

2. let: Introduzido no ES6, possui escopo de bloco, o que significa que pode
ser limitada ao bloco em que é declarada. Não pode ser redeclarada no
mesmo escopo.

3. const: Também introduzido no ES6, é usado para declarar variáveis cujo

valor não será reatribuído. Assim como o let, possui escopo de bloco e não
pode ser redeclarada no mesmo escopo.
 Oque são dados e quais tipos de dados
Dados são informações ou valores que podem ser processados ou
armazenados em um programa de computador. No contexto da
programação, existem diversos tipos de dados com os quais você pode
trabalhar. Vamos explorar alguns tipos com exemplos de código em
JavaScript:

Tipos de Dados em JavaScript:

1. Número (Number):

 Representa valores numéricos, sejam inteiros ou de ponto flutuante.

Exemplo:

let idade = 25;

let preco = 9.99;

2. String:

 Uma sequência de caracteres, utilizada para representar texto.

Exemplo:

let nome = "Maria";

let saudacao = 'Olá, mundo!';

3. Booleano (Boolean):

 Representa um valor lógico, verdadeiro ou falso.

Exemplo:

let estaChovendo = false;

let diaEnsolarado = true;

4. Array:
 Uma estrutura que armazena uma coleção de elementos.

Exemplo:

let numeros = [1, 2, 3, 4, 5];

let cores = ['vermelho', 'azul', 'verde'];

5. Objeto (Object):
 Representa uma coleção de pares chave-valor.

Exemplo:

let pessoa = {

nome: 'João',
 idade: 30,

cidade: 'São Paulo'

};

6. Null:

 É um valor especial que representa a ausência intencional de qualquer

valor.

Exemplo:

let valorNulo = null;

7. Undefined:

 É o valor atribuído automaticamente a variáveis que não foram

inicializadas ou que não têm um valor atribuído.

Exemplo:

let valorIndefinido;

Esses exemplos mostram como você pode usar diferentes tipos de dados em
JavaScript para armazenar informações e realizar operações em um
programa. Cada tipo de dado tem seu propósito específico e pode ser
manipulado de maneiras distintas.
 Operadores em JavaScript
são símbolos que representam ações específicas em variáveis, valores ou
expressões. Eles permitem realizar operações matemáticas, lógicas, de
atribuição e comparação. Vamos ver exemplos de diferentes tipos de
operadores:

1. Operadores Aritméticos:
Realizam operações matemáticas básicas.

 Adição (+):

let soma = 10 + 5; // Resultado: 15

 Subtração (-):

let diferenca = 20 - 8; // Resultado: 12

 Multiplicação (*):

let produto = 6 * 4; // Resultado: 24

 Divisão (/):

let quociente = 50 / 2; // Resultado: 25

2. Operadores de Atribuição:
Atribuem valores a variáveis.

 Atribuição simples (=):

let x = 10;

 Atribuição com operação (+=, -=, =, /=):

let valor = 5;

valor += 3; // Equivalente a: valor = valor + 3;

3. Operadores de Comparação:
Comparam valores e retornam um valor booleano (true ou false).

* Igual (==):

let a = 5;

let b = '5';

let igual = a == b; // Resultado: true

 Estritamente Igual (===):

let c = 5;

let d = '5';

let estritamenteIgual = c === d; // Resultado: false

 Diferente (!= ou !==):

let e = 10;

let f = 20;

let diferente = e !== f; // Resultado: true

4. Operadores Lógicos:
Realizam operações lógicas em valores booleanos.

 E lógico (&&):

let sol = true;

let calor = true;

let climaAgradavel = sol && calor; // Resultado: true

 OU lógico (||):

let chove = false;

let vento = true;

let condicaoClimatica = chove || vento; // Resultado: true

 NÃO lógico (!):

let diaEnsolarado = true;

let naoChove = !diaEnsolarado; // Resultado: false

Estes são alguns dos operadores em JavaScript, e cada um tem um papel

específico na execução de operações diferentes. Eles são essenciais para
realizar cálculos, comparações e tomada de decisões dentro dos programas.

 undefined e null
são dois valores especiais em JavaScript que representam a ausência de
valor ou a falta de um valor atribuído a uma variável.

Undefined:

 undefined é um valor padrão atribuído automaticamente a variáveis que

foram declaradas, mas não inicializadas com um valor.

Exemplo:

let valorIndefinido;

[Link](valorIndefinido); // Saída: undefined

Quando uma variável é declarada sem atribuir um valor a ela, seu valor
inicial é undefined.

 Null:

 null é um valor que precisa ser explicitamente atribuído a uma variável.

Ele representa a ausência intencional de qualquer valor ou objeto.

Exemplo:

let valorNulo = null;

[Link](valorNulo); // Saída: null

Geralmente, null é usado quando se deseja indicar explicitamente que uma

variável não contém nenhum valor válido ou quando é necessário reiniciar
uma variável que já foi utilizada.

Apesar de ambos indicarem a ausência de valor, há uma diferença sutil:

undefined é mais usado para variáveis que foram declaradas, mas não
tiveram um valor atribuído, enquanto null é mais usado para indicar a
ausência intencional de valor.
 Oque são Arrays e como Acessar

Arrays são estruturas de dados em JavaScript que permitem armazenar uma

coleção de elementos. Esses elementos podem ser de diferentes tipos e são
organizados em uma sequência numerada, onde cada elemento possui um
índice que começa em 0.

Exemplo de Array:

let numeros = [10, 20, 30, 40, 50];

Neste exemplo, temos um array chamado numeros que contém cinco

elementos numéricos.

Acessando Elementos do Array:

Para acessar elementos de um array, você usa a notação de colchetes []

seguida do índice do elemento que você deseja acessar.

[Link](numeros[0]); // Saída: 10

[Link](numeros[3]); // Saída: 40

Os índices do array começam em 0, então numeros[0] retorna o primeiro

elemento do array (10) e numeros[3] retorna o quarto elemento (40).
Modificando Elementos do Array:

Você também pode modificar elementos do array acessando-os pelo índice

e atribuindo um novo valor.

numeros[2] = 35;

[Link](numeros); // Saída: [10, 20, 35, 40, 50]

No exemplo acima, o terceiro elemento (30) foi substituído por 35.

 Comprimento do Array:

Para saber o número de elementos em um array, você pode usar a

propriedade length.

[Link]([Link]); // Saída: 5

Isso retorna o número total de elementos no array numeros.

Os arrays são poderosos em JavaScript, pois permitem armazenar e

manipular conjuntos de dados de maneira eficiente, facilitando a
organização e a manipulação de informações em um programa.

 função push()
A função push() em JavaScript é usada para adicionar um ou mais elementos
ao final de um array. Ela modifica o array original, aumentando seu
comprimento e adicionando novos elementos no final.

Exemplo de push():
let frutas = ['maçã', 'banana', 'laranja'];

[Link](frutas); // Saída: ['maçã', 'banana', 'laranja']

[Link]('morango');

[Link](frutas); // Saída: ['maçã', 'banana', 'laranja', 'morango']

[Link]('uva', 'abacaxi');

[Link](frutas); // Saída: ['maçã', 'banana', 'laranja', 'morango', 'uva',

'abacaxi']

Neste exemplo, a função push() é usada para adicionar elementos ao array

frutas. Primeiro, adicionamos 'morango', e depois passamos dois elementos
de uma vez ('uva' e 'abacaxi'). Ao executar push(), os elementos são
inseridos no final do array.
Essa função é útil quando você deseja adicionar novos elementos a um array
existente sem precisar redefinir o array inteiro.

 função pop()
em JavaScript é utilizada para remover o último elemento de um array. Ela
modifica o array original, diminuindo o seu comprimento e retornando o
elemento removido.

Exemplo de pop():
let frutas = ['maçã', 'banana', 'laranja', 'morango'];

[Link](frutas); // Saída: ['maçã', 'banana', 'laranja', 'morango']

let ultimaFruta = [Link]();

[Link](ultimaFruta); // Saída: 'morango'

[Link](frutas); // Saída: ['maçã', 'banana', 'laranja']

Neste exemplo, pop() é usado no array frutas. Ele remove o último

elemento, que é 'morango', e retorna esse elemento, que é então
armazenado na variável ultimaFruta. Após o pop(), o array frutas contém
apenas 'maçã', 'banana' e 'laranja', pois o 'morango' foi removido.

Essa função é útil quando você precisa remover o último elemento de um

array e talvez usá-lo posteriormente em seu código.
 função shift()
em JavaScript é utilizada para remover o primeiro elemento de um array. Ela
modifica o array original, deslocando todos os outros elementos para um
índice menor e retornando o elemento removido.

Exemplo de shift():

let frutas = ['maçã', 'banana', 'laranja', 'morango'];

[Link](frutas); // Saída: ['maçã', 'banana', 'laranja', 'morango']

let primeiraFruta = [Link]();

[Link](primeiraFruta); // Saída: 'maçã'

[Link](frutas); // Saída: ['banana', 'laranja', 'morango']

Neste exemplo, shift() é usado no array frutas. Ele remove o primeiro

elemento, que é 'maçã', e retorna esse elemento, que é então armazenado
na variável primeiraFruta. Após o shift(), o array frutas contém apenas
'banana', 'laranja' e 'morango', pois a 'maçã' foi removida.

Essa função é útil quando você precisa remover o primeiro elemento de um

array e talvez usá-lo posteriormente em seu código.
 função splice()
em JavaScript é uma função poderosa que pode ser usada para realizar
diversas operações em um array, como adicionar, remover ou substituir
elementos em posições específicas.

Sintaxe da função splice():

[Link](inicio, quantidadeRemovida, elemento1, elemento2, ...);

 inicio: Índice onde a operação deve começar.

 quantidadeRemovida: Número de elementos a serem removidos a

partir do índice inicio.

 elemento1, elemento2, etc.: Elementos opcionais a serem

adicionados ao array.

Exemplo de splice() para remoção:

let frutas = ['maçã', 'banana', 'laranja', 'morango'];

[Link](frutas); // Saída: ['maçã', 'banana', 'laranja', 'morango']

// Removendo 'laranja' (índice 2)

let frutaRemovida = [Link](2, 1);

[Link](frutaRemovida); // Saída: ['laranja']

[Link](frutas); // Saída: ['maçã', 'banana', 'morango']

Neste exemplo, splice() remove um elemento do array frutas. Começa no
índice 2 (onde está 'laranja') e remove um elemento. O elemento removido
é retornado como um novo array (['laranja']), e o array frutas é atualizado
para não conter mais 'laranja'.

Exemplo de splice() para adição:

let numeros = [1, 2, 3, 4, 5];

[Link](numeros); // Saída: [1, 2, 3, 4, 5]

// Adicionando '6' e '7' no índice 3, removendo 0 elementos

[Link](3, 0, 6, 7);

[Link](numeros); // Saída: [1, 2, 3, 6, 7, 4, 5]

Neste exemplo, splice() adiciona os números 6 e 7 no índice 3 do array

numeros (sem remover nenhum elemento). O array é atualizado para incluir
os novos elementos.

 [Link]()
é um método em JavaScript que verifica se um determinado valor é um
array. Ele retorna true se o valor passado for um array e false caso contrário.

Exemplo de [Link]():
let array1 = [1, 2, 3];

let array2 = 'Olá, mundo!';

let array3 = { a: 1, b: 2, c: 3 };

[Link]([Link](array1)); // Saída: true

[Link]([Link](array2)); // Saída: false

[Link]([Link](array3)); // Saída: false

[Link]() é um método em JavaScript que verifica se um determinado

valor é um array. Ele retorna true se o valor passado for um array e false
caso contrário.

Exemplo de [Link]():

javascript

Copy code

let array1 = [1, 2, 3];

let array2 = 'Olá, mundo!';

let array3 = { a: 1, b: 2, c: 3 };

[Link]([Link](array1)); // Saída: true

[Link]([Link](array2)); // Saída: false

[Link]([Link](array3)); // Saída: false

Neste exemplo, [Link]() é usada para verificar se array1, array2 e

array3 são arrays.

array1 é um array, então [Link](array1) retorna true.

array2 é uma string, não um array, então [Link](array2) retorna

false.

array3 é um objeto, não um array, então [Link](array3) retorna

false.

Essa função é útil quando você precisa determinar se um valor é um array

antes de realizar operações específicas que são aplicáveis apenas a arrays.

 ordenação em JavaScript
Em JavaScript, ordenar refere-se à organização de elementos de um array
em uma sequência específica, seja em ordem alfabética, numérica ou com
base em algum critério personalizado.

Exemplos de Ordenação em JavaScript:

Ordenação Alfabética:

let frutas = ['Banana', 'Maçã', 'Abacaxi', 'Laranja'];

[Link]();
[Link](frutas); // Saída: ['Abacaxi', 'Banana', 'Laranja', 'Maçã']

Neste exemplo, o array frutas é ordenado em ordem alfabética usando o

método sort(). O JavaScript organiza os elementos em ordem alfabética
padrão.

Ordenação Numérica:

let numeros = [10, 5, 8, 2, 4];

[Link]((a, b) => a - b);

[Link](numeros); // Saída: [2, 4, 5, 8, 10]

Neste caso, o array numeros é ordenado em ordem numérica. A função de

comparação (a, b) => a - b é passada para o método sort() para garantir a
ordenação correta dos números.

Ordenação com Critério Personalizado:

let objetos = [

{ nome: 'Ana', idade: 30 },

{ nome: 'João', idade: 25 },

{ nome: 'Maria', idade: 28 }

];

[Link]((a, b) => [Link] - [Link]);

[Link](objetos);

Neste exemplo, um array de objetos é ordenado com base em um critério

personalizado, a idade das pessoas. A função de comparação (a, b) =>
[Link] - [Link] é usada para comparar e ordenar os objetos com base em
suas idades.

A ordenação em JavaScript é uma funcionalidade essencial para organizar

conjuntos de dados em uma sequência específica, seja alfabética, numérica
ou de acordo com critérios personalizados, facilitando a manipulação e a
apresentação desses dados.

 concat()
O método concat() em JavaScript é utilizado para combinar dois ou mais
arrays, criando um novo array que contém os elementos dos arrays
originais. Ele não modifica os arrays existentes, mas retorna um novo array
com todos os elementos combinados.

Exemplos de concat():
Combinando Dois Arrays:

let array1 = [1, 2, 3];

let array2 = [4, 5, 6];

let combinado = [Link](array2);

[Link](combinado); // Saída: [1, 2, 3, 4, 5, 6]

Neste exemplo, concat() é utilizado para combinar os arrays array1 e array2

em um novo array chamado combinado. O resultado é um novo array
contendo todos os elementos dos arrays originais.

Combinando Arrays e Valores:

let array = [1, 2, 3];

let combinado = [Link](4, 5, 6);

[Link](combinado); // Saída: [1, 2, 3, 4, 5, 6]

Neste exemplo, concat() é usado para adicionar valores individuais ao final

do array array, criando um novo array combinado que contém todos os
elementos do array original mais os valores passados como argumentos.

Concatenando Arrays Vazios:

let vazio = [];

let combinado = [Link]([1, 2], [3, 4]);

[Link](combinado); // Saída: [1, 2, 3, 4]

Neste exemplo, concat() é utilizado com um array vazio vazio para combinar
outros arrays. Ele cria um novo array combinado contendo os elementos dos
arrays fornecidos como argumentos para concat().

O método concat() é útil para criar novos arrays combinando elementos de

arrays existentes ou adicionando elementos individuais a um array sem
modificar os arrays originais.

 join()
O método join() em JavaScript é usado para criar e retornar uma nova string
concatenando todos os elementos de um array usando um separador
específico.

 Sintaxe do join():
[Link](separador);

 array: O array cujos elementos serão combinados em uma string.

 separador (opcional): Uma string que será usada para separar os

elementos na string resultante. Se não for especificado, o separador
padrão é , (vírgula).

Exemplo de join():
let frutas = ['Maçã', 'Banana', 'Laranja'];

let resultado = [Link](', ');

[Link](resultado); // Saída: 'Maçã, Banana, Laranja'

Neste exemplo, join(', ') é usado no array frutas para criar uma nova string
onde os elementos do array são combinados usando (', ') como separador.
O resultado é uma string contendo todos os elementos do array separados
por vírgulas e espaços.

Exemplo com Separador Padrão:

Se nenhum separador for fornecido, o join() usará a vírgula como separador

padrão:

Neste caso, join() é usado no array numeros sem um separador específico,

portanto, a vírgula é usada como separador padrão para criar a string
resultante.

O método join() é útil para transformar os elementos de um array em uma

única string, facilitando a exibição ou manipulação dos dados de acordo com
um formato desejado.

 indexOf()
O método indexOf() em JavaScript é utilizado para encontrar a primeira
ocorrência de um elemento específico em um array e retorna o índice dessa
ocorrência. Se o elemento não for encontrado, o método retorna -1.

Sintaxe do indexOf():
[Link](elemento, índiceInicial);

 array: O array onde será feita a busca pelo elemento.

 elemento: O elemento a ser buscado no array.

 índiceInicial (opcional): Opcionalmente, você pode especificar a partir de

qual índice a busca deve começar. Se não for fornecido, a busca começa
do índice 0.

Exemplo de indexOf():
let frutas = ['Maçã', 'Banana', 'Laranja', 'Banana', 'Pêssego'];

let indiceBanana = [Link]('Banana');

[Link](indiceBanana); // Saída: 1

Neste exemplo, indexOf('Banana') é utilizado no array frutas para encontrar

a primeira ocorrência da string 'Banana'. Como 'Banana' está no índice 1 do
array, o método indexOf() retorna 1.

Usando o Parâmetro índiceInicial:

let frutas = ['Maçã', 'Banana', 'Laranja', 'Banana', 'Pêssego'];

let segundaBanana = [Link]('Banana', 2);

[Link](segundaBanana); // Saída: 3

Neste exemplo, indexOf('Banana', 2) procura a string 'Banana' a partir do

índice 2 do array frutas. Como a próxima ocorrência de 'Banana' está no
índice 3, é retornado o índice 3.

O método indexOf() é útil para encontrar a posição de um elemento em um

array, permitindo realizar operações com base nessa informação, como
remoção, substituição ou verificação da existência de um elemento
específico.

 objetos
Em JavaScript, objetos são estruturas fundamentais que permitem
armazenar coleções de dados e funcionalidades relacionadas. Eles consistem
em pares de chave-valor, onde cada chave (também chamada de
propriedade) está associada a um valor.

Criando Objetos em JavaScript:

Há algumas maneiras de criar objetos em JavaScript. Uma das maneiras mais
comuns é usar a notação de chaves {}:

let pessoa = {

nome: 'João',

idade: 30,

cidade: 'São Paulo'

};

Neste exemplo, pessoa é um objeto com três propriedades: nome, idade e

cidade, cada uma com seu valor correspondente.

Acessando Propriedades de um Objeto:

Você pode acessar as propriedades de um objeto usando a notação de
ponto . ou a notação de colchetes []:

[Link]([Link]); // Saída: 'João'

[Link](pessoa['idade']); // Saída: 30

Ambas as formas acessam o valor associado à propriedade do objeto.

Adicionando ou Modificando Propriedades:

É possível adicionar novas propriedades ou modificar propriedades
existentes de um objeto:

[Link] = 'Programador';

pessoa['idade'] = 31;

[Link](pessoa); // Saída: { nome: 'João', idade: 31, cidade: 'São Paulo',

profissao: 'Programador' }

Aqui, profissao é adicionada como uma nova propriedade, e idade é

modificada de 30 para 31.
Para que Serve um Objeto em JavaScript:
 Organização de Dados: Os objetos são úteis para organizar e armazenar
dados relacionados em uma estrutura coerente.

 Abstração de Dados: Permitem representar entidades do mundo real,

como usuários, produtos, etc.

 Funcionalidades: Além de armazenar dados, os objetos podem conter

métodos, que são funções associadas a eles, permitindo a manipulação
dos dados e a execução de ações específicas.

Os objetos são uma parte essencial da linguagem JavaScript, fornecendo

uma maneira flexível de estruturar e manipular dados, facilitando o
desenvolvimento de aplicativos mais complexos e dinâmicos.

 [Link]()
O método [Link]() em JavaScript é usado para retornar um array
contendo as chaves de um objeto. Essas chaves são os nomes das
propriedades enumeráveis do objeto.

Sintaxe do [Link]():
[Link](objeto);

 objeto: O objeto do qual se deseja obter as chaves.

Exemplo de [Link]():
let carro = {

marca: 'Toyota',

modelo: 'Corolla',

ano: 2022

};

let chaves = [Link](carro);

[Link](chaves); // Saída: ['marca', 'modelo', 'ano']

Neste exemplo, [Link](carro) retorna um array contendo as chaves do

objeto carro, ou seja, ['marca', 'modelo', 'ano'].

Utilizando as Chaves Retornadas:

Você pode usar o array retornado por [Link]() para iterar sobre as
chaves ou realizar outras operações com elas:

let carro = {

marca: 'Toyota',

modelo: 'Corolla',

ano: 2022

};

let chaves = [Link](carro);

for (let chave of chaves) {

[Link](`A chave '${chave}' tem o valor '${carro[chave]}'`);

Este exemplo utiliza o array retornado por [Link]() para iterar sobre as
chaves do objeto carro e exibir tanto o nome da chave quanto seu valor
correspondente.

O [Link]() é útil quando você precisa acessar apenas as chaves de um

objeto para realizar operações com elas, como iteração, verificação da
existência de chaves específicas, entre outras manipulações.

 [Link]()
O método [Link]() em JavaScript é usado para retornar um array
contendo os valores das propriedades enumeráveis de um objeto. Ele
retorna um array com os valores associados às chaves do objeto.

Sintaxe do [Link]():
[Link](objeto);

 objeto: O objeto do qual se deseja obter os valores.

Exemplo de [Link]():
let carro = {

marca: 'Toyota',
 modelo: 'Corolla',

ano: 2022

};

let valores = [Link](carro);

[Link](valores); // Saída: ['Toyota', 'Corolla', 2022]

Neste exemplo, [Link](carro) retorna um array contendo os valores

das propriedades do objeto carro.

Utilizando os Valores Retornados:

Você pode utilizar o array retornado por [Link]() para iterar sobre os
valores do objeto ou realizar outras operações com eles:

let carro = {

marca: 'Toyota',

modelo: 'Corolla',

ano: 2022

};

let valores = [Link](carro);

for (let valor of valores) {

[Link](`Valor: ${valor}`);

Este exemplo utiliza o array retornado por [Link]() para iterar sobre
os valores do objeto carro e exibir cada um deles.

O [Link]() é útil quando você precisa acessar apenas os valores de

um objeto para realizar operações com eles, como iteração, cálculos, ou
qualquer outra manipulação específica dos valores do objeto.

 [Link]()
em JavaScript é um método que é utilizado para copiar os valores de todas
as propriedades enumeráveis de um ou mais objetos de origem (source
objects) para um objeto destino (target object). Ele retorna o objeto destino
após as propriedades terem sido modificadas.

Sintaxe de [Link]():
[Link](objetoDestino, objetoOrigem1, objetoOrigem2, ...);

 objetoDestino: O objeto para o qual os valores serão copiados.

 objetoOrigem1, objetoOrigem2, ...: Um ou mais objetos que fornecem os

valores a serem copiados para o objeto destino.

Exemplo de [Link]():
let destino = { a: 1, b: 2 };

let origem = { b: 3, c: 4 };

let resultado = [Link](destino, origem);

[Link](resultado); // Saída: { a: 1, b: 3, c: 4 }

[Link](destino); // Saída: { a: 1, b: 3, c: 4 }

Neste exemplo, o método [Link]() copia as propriedades

enumeráveis do objeto origem para o objeto destino. Se o objeto destino já
possui uma propriedade com o mesmo nome, o valor será substituído pelo
valor correspondente do objeto origem. No final, ele retorna o objeto
destino modificado.

Copiando para um Novo Objeto:

Também é possível utilizar o [Link]() para criar um novo objeto:

let origem = { a: 1, b: 2 };

let copia = [Link]({}, origem);

[Link](copia); // Saída: { a: 1, b: 2 }

Neste exemplo, o [Link]() é usado para criar uma cópia do objeto

origem, passando um objeto vazio {} como destino. Isso cria um novo objeto
contendo as mesmas propriedades e valores de origem.

O [Link]() é frequentemente utilizado para combinar ou copiar

propriedades de objetos diferentes, útil em casos onde é necessário criar ou
modificar objetos a partir de outros objetos existentes.

 delete
em JavaScript é um operador usado para remover uma propriedade de um
objeto. Ele permite remover tanto propriedades próprias (ou seja, não
herdadas) quanto elementos de um array.

Uso do delete com Objetos:

let carro = { marca: 'Toyota', modelo: 'Corolla' };

delete [Link];

[Link](carro); // Saída: { marca: 'Toyota' }

Neste exemplo, delete [Link] remove a propriedade modelo do

objeto carro.
Uso do delete com Arrays:
let numeros = [1, 2, 3, 4, 5];

delete numeros[2];

[Link](numeros); // Saída: [1, 2, empty, 4, 5]

Neste caso, delete numeros[2] remove o elemento no índice 2 do array

numeros. No entanto, ele não reorganiza os índices do array, deixando um
índice vazio (empty).

O delete é útil quando você precisa remover propriedades específicas de um

objeto ou elementos específicos de um array. No entanto, ao usá-lo com
arrays, ele não reduzirá o comprimento do array, apenas criará elementos
vazios (undefined).

 métodos get e set

Os métodos get e set são recursos em objetos JavaScript que permitem
controlar como as propriedades são acessadas (lidas) e modificadas
(escritas). Eles são parte dos "acessores" em objetos e permitem definir
lógica personalizada para obter e definir valores de propriedades.

 get: Define a lógica para acessar (obter) o valor de uma propriedade

quando ela é lida.
let objeto = {

get nome() {

return 'João';

};

[Link]([Link]); // Saída: 'João'

 set: Define a lógica para modificar (definir) o valor de uma propriedade

quando ela é atribuída.

let objeto = {

_nome: '', // Convenção para propriedade privada

set nome(novoNome) {

this._nome = novoNome;

};

[Link] = 'Maria';

[Link](objeto._nome); // Saída: 'Maria'

Esses acessores permitem que você adicione lógica personalizada ao acesso

e à modificação de propriedades de objetos, sendo úteis para validação,
transformação de dados, execução de ações adicionais durante a leitura ou
atribuição de valores, entre outras funcionalidades.
let pessoa = {

_nome: '', // Convenção para propriedade privada

// Acessor 'get' para obter o valor da propriedade 'nome'

get nome() {

return this._nome;

},

// Acessor 'set' para definir o valor da propriedade 'nome'

set nome(novoNome) {

if (typeof novoNome === 'string') {

this._nome = novoNome;

} else {

[Link]('O nome deve ser uma string!');

};

[Link]([Link]); // Saída: ''

[Link] = 'Alice';

[Link]([Link]); // Saída: 'Alice'

[Link] = 42; // Tentativa de atribuir um valor inválido

// Saída: 'O nome deve ser uma string!'

[Link]([Link]); // Saída: 'Alice' (valor anterior mantido)

Neste exemplo, temos um objeto pessoa com os acessores get e set para a
propriedade nome. O acessor get permite acessar o valor atual da
propriedade nome, enquanto o acessor set valida se o novo valor atribuído
é uma string antes de definir o valor da propriedade _nome.

Isso demonstra como os acessores get e set podem ser utilizados em

conjunto no mesmo objeto para controlar e modificar o comportamento de
uma propriedade.

 Math
Em JavaScript, Math é um objeto embutido que fornece um conjunto de
métodos e constantes para realizar operações matemáticas. Ele não é um
construtor e, portanto, não é possível instanciá-lo. Todos os métodos e
propriedades do objeto Math são estáticos, o que significa que você acessa
diretamente o objeto Math para usá-los.

Alguns métodos e propriedades do objeto Math:

1. Constantes:

 [Link]: Representa a razão entre a circunferência de um círculo e seu

 diâmetro (aproximadamente 3.14159).

2. Funções Matemáticas:

 [Link](x): Retorna o valor absoluto de x.

 [Link](x): Retorna o maior número inteiro menor ou igual a x.

 [Link](x): Retorna o menor número inteiro maior ou igual a x.

 [Link](x): Retorna o valor arredondado de x para o número inteiro

mais próximo.

 [Link](x, y, ...) e [Link](x, y, ...): Retorna o menor ou o maior valor

entre os argumentos passados.

 [Link](): Retorna um número pseudoaleatório entre 0 (inclusive)

e 1 (exclusivo).

3. Funções Trigonométricas:

 [Link](x), [Link](x), [Link](x): Funções trigonométricas.

 Math.atan2(y, x): Retorna o arco tangente do quociente entre y e x.

4. Funções Exponenciais e Logarítmicas:

 [Link](x): Retorna o valor de e elevado à potência de x.

 [Link](x), Math.log10(x), Math.log2(x): Funções logarítmicas.

Esses são apenas alguns exemplos dos métodos e propriedades disponíveis

no objeto Math. Eles são amplamente utilizados para realizar cálculos
matemáticos em JavaScript e estão disponíveis globalmente, sendo
acessados diretamente através do objeto Math.

Exemplos de Sintaxe do Objeto Math:

Acessando um Método:

let raizQuadrada = [Link](25); // Calcula a raiz quadrada de 25

[Link](raizQuadrada); // Saída: 5

Acessando uma Propriedade:

let pi = [Link]; // Acessando a constante PI

[Link](pi); // Saída: 3.141592653589793

Utilizando Métodos Matemáticos:

let valorAbsoluto = [Link](-10); // Valor absoluto de -10

let seno = [Link]([Link] / 2); // Seno de π/2 (90 graus)

let arredondado = [Link](3.7); // Arredonda 3.7 para o número inteiro

mais próximo

[Link](valorAbsoluto); // Saída: 10

[Link](seno); // Saída: 1 (aproximadamente)

[Link](arredondado); // Saída: 4

Essa é a estrutura básica para utilizar os métodos e propriedades disponíveis

no objeto Math. Basta escrever Math. seguido pelo nome do método ou
propriedade que deseja utilizar, passando os argumentos necessários, se
houver.

 Date
Em JavaScript, o objeto Date é utilizado para trabalhar com datas e horários.
Ele oferece métodos para criar, manipular e formatar datas, permitindo lidar
com diferentes aspectos temporais.

Como Criar um Objeto Date:

 Criando uma Data Atual:
let dataAtual = new Date();

[Link](dataAtual); // Exibe a data e hora atuais

 Criando uma Data Específica:

let dataEspecifica = new Date('2023-01-15'); // Ano-Mês-Dia

[Link](dataEspecifica); // Exibe a data especificada

Métodos e Propriedades do Objeto Date:

 getDate(): Obtém o dia do mês (1 a 31).

 getMonth(): Obtém o mês (0 a 11).

 getFullYear(): Obtém o ano com quatro dígitos.

 getHours(), getMinutes(), getSeconds(): Obtêm as horas, minutos e

segundos.

 setDate(), setMonth(), setFullYear(): Configuram o dia, mês e ano da

data.
 toDateString(), toLocaleDateString(): Convertem a data para uma string
legível.

 getTime(): Retorna o número de milissegundos desde 1º de janeiro de

1970 (época Unix).

Tipos de Datas:
 Data e Hora Atuais:
let dataAtual = new Date();

 Data Específica:
let dataEspecifica = new Date('2023-01-15');

 Timestamp (Milissegundos desde 1º de janeiro de 1970):

let timestamp = new Date(1632892877000); // Milissegundos

Criando por Componentes de Data e Hora:

let dataHora = new Date(2023, 0, 15, 12, 30, 0); // Ano, Mês, Dia,

Hora, Minuto, Segundo

O objeto Date permite trabalhar com datas, realizar operações de

manipulação temporal e formatar datas para exibição. É uma ferramenta
fundamental para lidar com informações temporais em JavaScript.

 funcoes
As funções em JavaScript são blocos de código que podem ser nomeados ou
anônimos, que podem ser reutilizados ao longo do seu programa. Elas são
um dos principais conceitos da programação e permitem encapsular um
conjunto de instruções para serem executadas quando necessário.
Principais Tipos de Funções Mais Usadas:
Funções Declarativas:

 São definidas utilizando a palavra-chave function.

Exemplo:
function somar(a, b) {
return a + b;
}
 Expressões de Função (Funções Anônimas):
 São definidas sem nome e podem ser atribuídas a variáveis.
Exemplo:
let subtrair = function(a, b) {
return a - b;
};
Arrow Functions (Funções de Seta):
 Introduzidas no ECMAScript 6 (ES6), são uma forma mais concisa de
escrever funções.
Exemplo:
let dobrar = (x) => x * 2;

 Métodos de Objetos:
 Funções associadas a objetos.
Exemplo:
let objeto = {
 nome: 'Exemplo',
saudacao: function() {
return 'Olá!';
}
};

 Callbacks:
 Funções passadas como argumentos para outras funções.
Exemplo:
function executar(funcao) {
funcao();
}

executar(function() {
[Link]('Isso é um callback.');
});

 Funções Recursivas:
 Funções que chamam a si mesmas para resolver um problema de
maneira iterativa.
Exemplo:
function contarAteDez(numero) {
if (numero <= 10) {
[Link](numero);
contarAteDez(numero + 1);
 }
}

contarAteDez(1);

 Funções Mais Comuns:

 Manipulação de Arrays: map(), filter(), reduce(), forEach().
 Temporizadores: setTimeout(), setInterval().
 Eventos: Funções associadas a eventos de interação do usuário.
O uso de funções em JavaScript é essencial para a modularização do código,
reutilização de lógica, abstração e organização do programa. Cada tipo de
função tem seus próprios usos e vantagens, e a escolha depende do
contexto e da necessidade específica do seu código.

 Class Em JavaScript
a palavra-chave class é uma forma de criar classes, que são um tipo de
estrutura para criar objetos com características similares. A introdução das
classes no JavaScript (ES6/ECMAScript 2015) simplificou a forma de
trabalhar com o paradigma de programação orientada a objetos.

As classes são uma maneira mais clara e estruturada de criar objetos e lidar
com herança em comparação com o sistema de protótipos usado
anteriormente no JavaScript.

Sintaxe da class:
class NomeDaClasse {
 constructor(propriedade1, propriedade2) {
this.propriedade1 = propriedade1;
this.propriedade2 = propriedade2;
}

metodo1() {
// Método da classe
}

metodo2() {
// Outro método da classe
}
}

Principais Conceitos:
 constructor: Método especial para inicializar os objetos criados a partir
da classe. É chamado automaticamente quando um novo objeto é criado.
 Métodos: Funções que definem o comportamento dos objetos criados a
partir da classe.

Exemplo de Uso de class:

class Carro {
constructor(marca, modelo) {
[Link] = marca;
 [Link] = modelo;
}

apresentar() {
return `Este é um ${[Link]} ${[Link]}.`;
}
}

let meuCarro = new Carro('Toyota', 'Corolla');

[Link]([Link]()); // Saída: Este é um Toyota Corolla.
A palavra-chave class é uma sintaxe mais amigável e semântica para criar
objetos e lidar com herança em JavaScript. Ela simplifica a criação de
estruturas de objetos e seu comportamento, tornando o código mais
organizado e legível.

 constructor
O constructor em JavaScript é uma propriedade presente em todos os
objetos que faz referência à função que foi usada para criar esse objeto. Esta
propriedade é parte do protótipo de todos os objetos e é acessada através
do protótipo do objeto.

Utilidade do constructor:
 Identificação do Tipo de Objeto: O constructor pode ser útil para
identificar o tipo de um objeto.

 Criação de Novos Objetos: Ele pode ser usado para criar novos
 objetos do mesmo tipo.

Exemplo de Uso do constructor:

function Carro(marca, modelo) {
[Link] = marca;
[Link] = modelo;
}

let carro1 = new Carro('Toyota', 'Corolla');

[Link]([Link]); // Saída: [Function: Carro]

Neste exemplo, [Link] faz referência à função Carro, pois foi

usada para criar o objeto carro1.

Criando um Novo Objeto Usando o constructor:

Você pode usar a propriedade constructor para criar um novo objeto do
mesmo tipo. Isso é especialmente útil quando você não tem acesso direto à
função que criou o objeto original, mas possui acesso ao objeto e ao seu
constructor.
let carro2 = new [Link]('Ford', 'Focus');
[Link](carro2); // Cria um novo objeto Carro com marca 'Ford' e
modelo 'Focus'
Essa abordagem permite criar novos objetos com base no tipo do objeto
existente, acessando o constructor do objeto existente para criar um novo
objeto similar.

O constructor é um recurso útil para entender a estrutura e a origem dos

objetos em JavaScript, além de possibilitar a criação de novos objetos do
mesmo tipo sem ter que criar uma nova função construtora.

 if e else
são palavras-chave em JavaScript (e em muitas outras linguagens de
programação) que permitem controlar o fluxo do programa baseado em
condições lógicas. Eles são usados para executar blocos de código se uma
condição específica for verdadeira (if) ou falsa (else).

Sintaxe:
if:
if (condicao) {
// Bloco de código a ser executado se a condição for verdadeira
}
if...else:
if (condicao) {
// Bloco de código a ser executado se a condição for verdadeira
} else {
// Bloco de código a ser executado se a condição for falsa
}

Exemplo de Uso:
let numero = 10;

if (numero > 0) {
[Link]('O número é positivo.');
} else {
[Link]('O número é negativo ou zero.');
}
Neste exemplo, se a condição numero > 0 for verdadeira, o código dentro
do bloco if será executado. Caso contrário, o código dentro do bloco else
será executado.

if...else if...else
Além do if e do else, podemos utilizar o else if para adicionar mais
condições ao fluxo do programa:
let numero = 10;

if (numero > 0) {
[Link]('O número é positivo.');
} else if (numero < 0) {
[Link]('O número é negativo.');
} else {
[Link]('O número é zero.');
}
Isso permite testar várias condições em sequência. Se a primeira condição if
for falsa, o programa testará a próxima condição else if e assim por diante.
Se nenhuma condição for verdadeira, o bloco else final será executado.

O if e o else são fundamentais para controlar o fluxo do programa com base

em condições lógicas, permitindo que determinados blocos de código sejam
executados dependendo do estado das variáveis ou valores testados.

 else if
O else if é uma extensão do if e do else em JavaScript que permite adicionar
múltiplas condições ao fluxo do programa. Ele é usado quando há a
necessidade de testar várias condições em sequência após um if inicial.

Sintaxe do else if:

if (condicao1) {
// Bloco de código a ser executado se a condição1 for verdadeira
} else if (condicao2) {
// Bloco de código a ser executado se a condição1 for falsa e a condição2
for verdadeira
} else if (condicao3) {
// Bloco de código a ser executado se a condição1 e a condição2 forem
falsas e a condição3 for verdadeira
} else {
// Bloco de código a ser executado se todas as condições anteriores
forem falsas
}
Exemplo de Uso do else if:
let numero = 0;

if (numero > 0) {
[Link]('O número é positivo.');
} else if (numero < 0) {
[Link]('O número é negativo.');
} else {
[Link]('O número é zero.');
}
Neste exemplo, o else if é usado para testar uma condição adicional caso a
primeira condição if seja falsa. Isso permite a verificação sequencial de
condições e a execução do bloco de código correspondente à primeira
condição verdadeira encontrada.

O else if é útil quando é necessário testar várias condições em sequência e

executar diferentes blocos de código com base no resultado dessas
condições. Essa estrutura é fundamental para controlar fluxos complexos
dentro do programa.

 switch case
é uma estrutura condicional em JavaScript que permite testar o valor de
uma expressão e, em seguida, executar um bloco de código dependendo do
valor da expressão. Ela é uma alternativa ao uso repetitivo de múltiplos
if...else if...else.
Sintaxe do switch:
switch (expressao) {
case valor1:
// Bloco de código a ser executado se expressao for igual a valor1
break;
case valor2:
// Bloco de código a ser executado se expressao for igual a valor2
break;
// Outros cases conforme necessário...
default:
// Bloco de código a ser executado se nenhum case corresponder a
expressao
}
 A expressao é avaliada e seu valor é comparado com os cases.

 Se o valor da expressao corresponder a um case, o bloco de código

associado a esse case será executado.

 O break é usado para sair do switch após um case ser correspondido e

seu bloco de código ser executado. Caso contrário, a execução
continuará no próximo case.

 O default é opcional e é executado se nenhum case corresponder ao

valor da expressao.

Exemplo de Uso do switch:

let diaSemana = 2;
let nomeDia;

switch (diaSemana) {

case 1:

nomeDia = 'Domingo';

break;

case 2:

nomeDia = 'Segunda-feira';

break;

case 3:

nomeDia = 'Terça-feira';

break;

case 4:

nomeDia = 'Quarta-feira';

break;

case 5:

nomeDia = 'Quinta-feira';

break;

case 6:

nomeDia = 'Sexta-feira';

break;
 case 7:

nomeDia = 'Sábado';

break;

default:

nomeDia = 'Dia inválido';

[Link](`O dia ${diaSemana} da semana é ${nomeDia}`);

O switch é útil quando há uma necessidade de testar um valor específico em

comparação com vários outros valores e executar diferentes blocos de
código com base nesse valor. Ele oferece uma forma mais organizada e
legível de lidar com múltiplas condições para uma única expressão.