Console.
log(“”) = usa para apareceres a mensagem ou soma de números dentro do “”
ex:
[Link]("Pablo Oliveira")
resultado é Pablo Oliveira
<p> ... </p> = usa para apareceres a mensagem ou soma entres os “<p>” no site e o
“</p>” significa fim do texto
ex:
<p> Texto novo </p>
resultado é “ texto novo “ mas no site não no terminal
<h1> ... </h1> = usa para apareceres a mensagem ou soma entres os “<h1>” no site
como Título com letras grandes e o “</h1>” significa fim do texto
ex:
<h1> Título </h1>
resultado é “TÍTULO “ mas no site não no terminal
<body> ... </body> = usa para acrescentar botões no site
ex:
<body>
<h1> título </h1>
<p>
cionou </p>
</body>
resultado é “ TÍTULO “ e “ Funcionou “ logo embaixo do título
<head> ... </head> = usa para mudar nome da página na web ou até configurar título,
links de estilo, scripts, metadados mais como configuração
ex:
<head>
<title>Página do Pablo </title>
</head>
resultado é uma Página na web com nome “Página do Pablo”
<title> ... </title> = usa para dar título a página na web o que tiver entre “<title> </title>”
vai ser o título da página na web
ex:
<head>
<title> Minha Página </title>
</head>
resultado é o título da página da web “Minha Página “
<script> ... </script> = usa para carregar para inserir ou carregar código JavaScript de
outro arquivo dentro do HTML
ex:
<script src="[Link]"></script>
resultado é o código que está no arquivo “[Link]” rodar no HTML
src = usa para carregar arquivo externo JavaScript
ex:
<script src="[Link]"></script>
resultado é programa que está no arquivo com nome “[Link]”
defer = usa para Fazer o script externo rodar só depois que toda a página carregar na
web
ex:
<script src="[Link]" defer></script>
resultado é programa que está no arquivo com nome “[Link]” aparecerá no terminal só
depois que carregar a página na web
async = usa para fazer o script externo rodar imediatamente, em paralelo ao
carregamento da página
ex:
<script src="[Link]" async></script>
resultado é programa que está no arquivo com nome “[Link]” aparecerá antes de carregar a
página na web
let = usa para declarar uma variável que só pode ser declarada 1 vez dentro do
escopo,dentro de uma função, bloco { ... }
ex:
let altura = 170;
altura = 180; // ✅ apenas muda o valor
[Link](altura);
resultado é 180
var = usa para declarar uma variável que só pode ser declarada 2, 3 até 4 vezes dentro
do escopo,dentro de uma função, bloco { ... }
ex:
var altura = 160;
var altura = 170;
var altura = 180; // ✅ permitido
[Link](altura);
resultado é 180
const = usa para declarar uma variável que não pode ser alterada
ex:
const altura = 170;
[Link](altura);
resultado é 170 pois esse é o valor determinado primeiro
use strict = usado para ativar o modo moderno do JavaScript ou modo “ estrito “ no
modo estrito voce nao consegue usar variável sem declarar let, var ou const
ex:
"use strict";
let altura = 180;
[Link](altura);
resultado é 180 Por ser o valor determinado com “let” e o “use strict” deve ser adicionado
logo antes da variável
{...} = Bloco de código é usado para separar partes do programa. Tudo dentro das
chaves pertence ao bloco como “ container ”
ex:
{
[Link]("Dentro do bloco");
}
resultado é Dentro do bloco, “let” se for criada dentro e fora do “{...}” o que vir fora do “{...}”
vai aparecer no terminal, “const “ mesma coisa, o que foi criado fora de “{...}”, é o certo já
“var” funciona dentro do “{...}” e fora, os 2 valores, texto e etc… aparecem no terminal
typeof = usado para definir o tipo da variável poder número, texto ou comando
ex:
a = typeof 10
b = typeof "Olá"
c =typeof true
resultado é a = number, ele reconhece que é um número já b = string, ele conhece que é
um texto e por último c = boolean, ele reconhece que é um comando então no terminal sai
number,string e boolean
! = usado para Inverter o valor
ex:
[Link](!true)
resultado é false o inverso de true é false
&& = significa “E”
ex:
[Link](true && false)
resultado é false mas consegue colocar 2 valores ou comandos até 2 palavras dentro do
mesmo parentes
| | = usado como “ ou “
ex:
[Link](true | | false)
resultado é true
.length = usa para mostrar quantas letras uma string ( texto ) tem
ex:
a = “Teste”.length
resultado é 5 no terminal pois a palavra “teste” tem 5 letras
.slice(...) = usa para escolher quais letras serão selecionadas escolhe numero que
começa e o número que acaba as letras selecionadas
ex:
a = "JavaScript".Slice(0,4)
resultado é as letras “J,a,v,a” o número “0” é onde começa e o número “4” não é o fim mas
um número antes do “4” no caso o “3” e se fosse o “6” acabaria no “5”
.split(...) = usa para dividir a string em partes e vira uma lista apresentando quantos itens
tem na lista
ex:
a = “10.20.30”.split(“.”)
resultado é “ (3) [ ‘10’, ‘20’, ‘30’ ] “ entre o “(...)” quantos itens tem na lista e dentro do “[...]”
os itens da string listados
${...} = usa para poder adicionar variáveis dentro da string adicionando nome da variável
usando `... ` dentro do “{...}”
ex:
nome = “Pablo”
a = ` ${nome} escobar `
[Link](a)
resultado é “ Pablo escobar “ com a variável “nome” adicionada depois na variável “a”
string(...) = usa para poder converter ou criar uma string que esteja dentro do “(...)”
ex:
const str = String(Pablo);
[Link](str);
resultado é “Pablo” o exemplo usou o comando constante que é inalterável mas com
comando “string” ele poder ser alterado para algum texto apenas
number(...) = usa para poder converter ou criar qualquer número que esteja dentro do
“(...)”
ex:
const num = number(7);
[Link](num);
resultado é “7” o exemplo usou o comando constante que é inalterável mas com comando
“number” ele poder ser alterado para algum número apenas
boolean(...) = usa para poder converter ou criar um comando ( boolean ) que esteja dentro
do “(...)”
ex:
const bool = boolean();
[Link](bool);
resultado vai ser o comando adicionado dentro do (...) o exemplo usou o comando
constante que é inalterável mas com comando “boolean” ele poder ser alterado para algum
comando de Js apenas
BigInt(...) = usa para poder adicionar valores inteiros muito grandes e se nao tiver um
número dentro do “(...)” da erro
ex:
const big1 = BigInt(42);
[Link](big1);
resultado é “42n” sai o valor inteiro sem vírgula ou ponto e o “n” no final não importa o valor
(“11”) = usa para poder adicionar valores normais
ex:
const num = number(“7”);
[Link](num);
resultado é “11” sai o valor inteiro normal
(“0x11”) = usa para poder adicionar valores em hexadecimal
ex:
const num = number(“0x11”);
[Link](num);
resultado é “17” sai o resultado de 11 em hexadecimal
(“0o11”) = usa para poder adicionar valores em octal
ex:
const num = number(“0o11”);
[Link](num);
resultado é “9” sai o resultado de 11 em octal
(“0b11”) = usa para poder adicionar valores em binário
ex:
const num = number(“0b11”);
[Link](num);
resultado é “3” sai o resultado de 11 em binário
(“12e3”) = usa para poder adicionar valores em notação científica
ex:
const num = number(“12e3”);
[Link](num);
resultado é “12000” sai o resultado em notação científica
delete = usa para poder deleter de um objeto alguma informação exata
ex:
let user1 = {
nome: "Pablo",
telefone: 12981806373
};
delete [Link];
[Link](user1);
resultado é a informação dentro do “objeto “ que é as informações dentro do “{...}” e o
“delete“ apaga a informação dentro do objeto com nome que vem logo depois do nome do
objeto no caso o nome desse é “ user1” e apagou o telefone
.length = usa para poder ver quantos/acrescentar itens tem no array, lista ou até objetos só
colocar nome do array antes do “.”
ex:
let nomes = [ Pablo, Gabriel, Rafael, Raissa]
[Link]
[Link](nomes)
nomes[4] = Barbosa
resultado é primeiro a lista de nome e quantos itens tem no caso 4 e no segundo comando
adiciona o nome barbosa no fim da lista e mostrando quantos itens tem agora no caso 5
.indexof = usa para poder encontrar a posição exata de um elemento
ex:
let nomes = [ “Pablo”, “Gabriel”, “Barbosa”, “Oliveira”];
[Link]([Link](“Barbosa”));
resultado é “2” que é número que o nome “Barbosa” na lista corresponde começando pelo 0
.push = usa para poder adicionar itens ao fim da lista
ex:
let nomes = [ “Pablo”, “Gabriel”, “Barbosa”];
nomes,push (“Oliveira”);
resultado é “[ “Pablo”, “Gabriel”, “Barbosa”, “Oliveira”]” uma lista nova com o item pedido no
fim da lista
.unshift = usa para poder adicionar itens ao começo da lista
ex:
let nomes = [ “Pablo”, “Gabriel”, “Barbosa”];
nomes,push (“Oliveira”);
resultado é “[ “Oliveira”, “Pablo”, “Gabriel”, “Barbosa”]” uma lista nova com o item pedido no
começo da lista
.pop = usa para poder remover o item escolhido da lista
ex:
let nomes = [ “Pablo”, “Gabriel”, “Barbosa”, “Oliveira”];
let remover = [Link](“Gabriel”)
resultado é “[ “Pablo”, “Barbosa”, “Oliveira”]” uma lista nova com o item pedido removido da
lista
.shift() = usa para poder remover o Primeiro no caso o item 0 da lista
ex:
let nomes = [ “Pablo”, “Gabriel”, “Barbosa”, “Oliveira”];
let remover = [Link]()
resultado é “[ “Gabriel”, “Barbosa”, “Oliveira”]” uma lista nova com o primeiro item ou item
“0” removido da lista
.reverse() = usa para poder reverter a ordem da lista lista
ex:
let nomes = [ “Pablo”, “Gabriel”, “Barbosa”, “Oliveira”];
let reverter = [Link]()
resultado é “[ “Oliveira”, “Barbosa”, “Gabriel”, “Pablo”]” uma lista nova com os itens em
ordem invertida
.slice() = usa para poder criar uma nova lista a partir da original
ex:
let nomes = [ “Pablo”, “Gabriel”, “Barbosa”, “Oliveira”];
[Link](2);
[Link](1, 3);
[Link](-1);
resultado é “[ “Gabriel”, “Barbosa”, “Oliveira”]” uma lista nova tendo os itens “ 2 = barbosa “,
“ 1 = Gabriel “, “ 3 = Oliveira ” e “ -1 = Oliveira “
.slice() = usa para poder criar uma nova lista a partir da original
ex:
let nomes = [ “Pablo”, “Gabriel”, “Barbosa”, “Oliveira”];
[Link](2);
[Link](1, 3);
[Link](-1);
resultado é “[ “Gabriel”, “Barbosa”, “Oliveira”]” uma lista nova tendo os itens “ 2 = barbosa “,
“ 1 = Gabriel “, “ 3 = Oliveira ” e “ -1 = Oliveira “
.concat() = usa para poder juntar 2 ou mais lista
ex:
let a = “Pablo ”
let b = “Gabriel ”
let c = “Oliveira”
let nome = [Link](b, c)
resultado é “ Pablo Gabriel Oliveira “ esse comando junta os arrays
+ = usa para poder somar números e unir strings
ex:
let soma = 2 + 5
let texto = “Pablo” + “Gabriel”
let St = “ Pablo ” + 7
resultado para variável soma é “ 7 “ no caso um número, para variável texto é “ Pablo
Gabriel ” e para variável St é “ Pablo7 “
- = usa para poder fazer subtração de números
ex:
let subtração = 5 - 2
resultado é “ 3 “
* = usa para poder fazer multiplicação de números
ex:
let multiplicação = 5 * 2
resultado é “ 10 “
/ = usa para poder fazer divisão de números
ex:
let divisão = 5 / 2
resultado é “ 2.5 “
% = usa para poder retornar o resto da divisão
ex:
let resto = 5 % 2
resultado do resto da divisão é “ 1 ”
** = usa para poder gerar exponenciação
ex:
let divisão = 5 ** 2
resultado é “ 25 “ como se o 2 fosse o expoente do 5
+variável = usa para poder converter a variável para “number”
ex:
let Texto = “123”;
let número = +Texto;
resultado é “123” que eram string convertidos para number
-variável = usa para poder converter a variável para “number”
ex:
let Texto = “123”;
let número = -Texto;
resultado é “123” que eram string convertidos para number mas vira número negativo
++ = usa para poder adicionar 1 ao valor
ex:
let a = 5;
[Link](++a);
resultado é “ 6 ” porque “++” vale 1
-- = usa para poder subtrair 1 do valor
ex:
let a = 5;
[Link](--a);
resultado é “ 6 ” porque “++” vale 1
+= = usa para poder fazer soma em formato mais curta
ex:
let x = 10;
x += 2;
resultado é “ 12 ” pois é a mesma coisa que “x = x + 10”
-= = usa para poder fazer subtração em formato mais curta
ex:
let x = 10;
x -= 2;
resultado é “ 8 ” pois é a mesma coisa que “x = x - 10”
*= = usa para poder fazer multiplicação em formato mais curta
ex:
let x = 10;
x *= 2;
resultado é “ 20 ” pois é a mesma coisa que “x = x * 10”
/= = usa para poder fazer a divisão em formato mais curta
ex:
let x = 10;
x /= 2;
resultado é “5 ” pois é a mesma coisa que “x = x / 10”
%= = usa para poder dar o resto da divisão em formato mais curta
ex:
let x = 10;
x %= 10;
resultado é “4 ” pois é a mesma coisa que “x = x % 10”
**= = usa para poder elevar potência ao valor em formato mais curto
ex:
let x = 10;
x **= 2;
resultado é “100 ” pois é a mesma coisa que “x = x ** 10”
!! = usa para poder converter qualquer valor para em boolean
ex:
x = 0;
x = !!x
resultado é o 0 que é number virar boolean
=== = usa para poder ver se são mesmo número e tipo
ex:
5 === 10
resultado é o “ false ” pois são o mesmo tipo mas não mesmo valor
== = usa para poder ver se são mesmo valor
ex:
10 == “10”
resultado é o “ true ” pois são o mesmo valor
!== = usa para poder ver se são valores ou tipos diferentes
ex:
5 !== 10
resultado é o “ true ” pois não são o mesmo valor
!= = usa para pode ver se são valores diferentes
ex:
10 != 5
resultado é o “ true ” pois são valores diferentes
<, <= , =>, > = usa para poder comparar valores e strings
ex:
a = 10 > 0
b=a<b
resultado para variável “a” é true pq o numero da esquerda “10 “ é maior que o da direita “ 0
“ e a variável “ b “ é true também pois a letra da direita “b” é string igual a da esquerda “a”
instanceof = usa para poder saber qual objeto é
ex:
let a = [ “ Pablo”, “Gabriel”, “Barbosa”, “Oliveira “];
let b = [ 0 ];
[Link]( a instanceof array );
[Link]( b instanceof array );
resultado de “ a “ é true por ser um array, e a “ b ” é false por não ser um array
delete = usa para poder remover uma propriedade de um objeto
ex:
let user = {
nome: "Alice",
idade: 38
};
[Link]([Link]);
delete [Link];
[Link]([Link]);
resultado é a “ idade “ deletado do “ user “
? : = usa para se caso a condição atribuída antes do “ ? “ se for “ false “ acontece tal coisa
se for “ true “ acontece outra coisa um if compacto “ condição ? valorSeVerdadeiro :
valorSeFalso “
ex:
let nome = 1 > 2 ? "Alice" : "Bob";
[Link](name);
se 1 for maior que 2 ( 1 > 2 ) se isso for verdadeiro resultado é “ alice “ se for mentira então
é “ bob ”
alert() = usa para pode apenas exibir uma mensagem no HTML
ex:
alert("Hello, World!");
alert(4 * 7);
resultado é “ hello world ” e um número 28 com um botão de OK
confirm() = usa para pode apenas exibir uma pergunta de Sim/Não no HTML
ex:
let decisao = confirm(" tudo OK?");
[Link](decisao);
resultado é uma pergunta que se for “ OK “ é true se for “ Cancelar ” é false
prompt() = usa para pedir uma aba para digitar no HTML
ex:
let nome = prompt("Digite seu nome:");;
resultado é uma pergunta “ Digite seu nome: ” e uma aba para você digitar seu nome
If = usado como “ se “ e se a condição depois do If for true o bloco de código é executado
se for false é ignorado
ex:
if (condição) {
bloco de código
}
resultado é se a condição for true (verdadeiro) o bloco é executado se for false ( falso ) o
bloco é ignorado
Else = usado como “ outro “ e se a condição antes do If for false o bloco de código é
executado
ex:
if (condição) {
bloco de código
} else {
bloco de código caso seja false
}
resultado é se a condição do if for false (falso) o bloco de else é executado
Else if = usado para testar múltiplas condições em sequências
ex:
let n = prompt("Enter a number", 0);
if (n < 10) {
alert("<10");
} else if (n < 30) {
alert("<30");
} else if (n < 60) {
alert("<60");
} else {
alert(">=60");
}
resultado é dependendo do resultado do prompt a condição
? : = usa para se caso a condição atribuída antes do “ ? “ se for “ false “ acontece tal coisa
se for “ true “ acontece outra coisa um if compacto “ condição ? valorSeVerdadeiro :
valorSeFalso “
ex:
let nome = 1 > 2 ? "Alice" : "Bob";
[Link](name);
se 1 for maior que 2 ( 1 > 2 ) se isso for verdadeiro resultado é “ alice “ se for mentira então
é “ bob ”
switch(expressão){...} = usado para comparar o valor da expressão com diferentes casos.
case valor = usa quando o “valor “ e valor da expressão é exatamente igual
break = usa para interromper a execução do “ switch “ Sem ele, o código continua rodando
default =usa para caso nenhum “ case “ corresponde ao valor.
ex:
let gate = prompt("Choose gate: a, b, or c");
switch (gate) {
case "a":
alert("Gate A: empty");
break;
case "b":
alert("Gate B: main prize");
win = true;
break;
default:
alert("No gate " + String(gate));
}
if (win) {
alert("Winner!");
}
resultado é se o usuário digitar “a” no prompt mostra “empty” se digitar “b” mostra “main
prize “ e marca win = true e se win === true aparece “winner” se nada for marcadao entre a
opções resultado é default e aparece “ no gate “
While = usa para fazer laço de repetição/loop tanto infinito ou se tal condição for
verdadeira “true” a repetição para de funcionar
ex:
let n = 0;
while (n < 91) {
[Link](n);
n += 10;
}
Resultado é enquanto N que tem valor 0 e for menor que 91 “ n < 91 “ essa é a condição o
loop vai acrescentar 10 ( n += 10 ) ao N até chegar em um valor maior que 91 ai o loop para
do…While = usa para fazer laço de repetição/loop tanto infinito mas a diferença é que o
“do…while” vê se a condição é verdadeira depois de executar o código pelo menos 1 vez e
só repete de novo se a condição for verdadeira “true”
ex:
do {
bloco de código
} while (condição);
Resultado é o código no “ bloco de código “ executado pelo menos 1 vez ai depois vê se a
condição é verdadeira para executar em loop
For = usa para dar limite a repetição em 3 partes dentro do “ () “ a primeira que é a
“inicialização”,” segunda a “ condição “ e a terceira “ incrementação “
ex:
for (let i = 0; i < 10; i++) {
[Link](i);
}
Resultado é “0,1,2,3,4,5,6,7,8,9 “ dentro do for tem as 3 partes “inicialização” ( let i = 0 ) que
serve para iniciar em algum valor o segundo que é a “condição” ( i < 10 ) enquanto valor de i
for menor que 10 o loop continua a parte 3 que é a “ incrementação “( i++) a cada vez que
o loop ver se i é menor que 10 ele acrescenta 1 ao valor de i que é zero
For…of = usa para um array/lista o “ for “ recebe os elementos do array de uma maneira
mais rápida
ex:
let valores = [10, 30, 50, 100];
let soma = 0;
for (let números of valores) {
soma += números;
}
[Link](soma);
Resultado é “ 190 “ mas da variável “ soma “ ela tinha o valor 0 todos do array “ valores “
foram para variável “ soma “ e dentro do “ for “ uma variável foi criada a “ números “ para
somar ela foi para números e somou os valores das variáveis “ soma “ = 0 e da variável
“números “ = 10, 30, 50, 100 somando tudo ( += ) 190
For…in = usa para mostrar nome das variáveis em vez das variáveis em um objeto se uma
das variáveis chama “número: 0“ só é devolvido o “número “
ex:
let user = {
nome: "Pablo"
idade:20,
email: "Pablopng888@[Link]"
};
for (let chaves in user) {
[Link](`${chaves} -> ${user[chaves]}`);
}
Resultado é toda informação do objeto “user” passa para “ chaves “ o nome das variáveis
dentro do objeto “ user “ as variáveis nome, idade e email só os nomes delas aparecem mas
se acrescentar [ ] no programa as variáveis e seus valores também aparecem “$
{user[chaves]}”
Function = usa para dar nome a funções para deixar o programa mais fácil e menor de
conduzir
ex:
let Temperatura
function TemperaturaMedia() {
let soma = 0;
for (let i = 0; i < [Link]; i++) {
soma += temperatura [1];
}
return soma / [Link];
}
Temperatura = [12, 12, 11, 11, 10, 9, 9, 10, 12, 13, 15, 18, 21]
[Link](`Resultado: ${temperaturamedia()}`);
Temperatura = [17, 16, 14, 12, 10, 10, 10, 11, 13, 14, 15, 17, 22]
[Link](`Resultado: ${temperaturamedia()}`);
resultado é a média da temperatura somando todos os valores divididos pela quantidade
das 2 lista assim tendo 2 médias e com a “ function “ posso fazer isso 2 vezes chamando o
nome da função “ temperaturaMedia “
Return = usa para 2 opções uma é encerrar a função como um “ break “
ex:
function Msg() {
[Link]("mensagem 1");
return;
[Link]("Mensagem 2");
}
showMsg();
Resultado é “ mensagem 1 “ a função “ msg “ encerra na mensagem 1 em vez de aparecer
“mensagem 1” e “ mensagem 2 “
Return = usa para 2 opções segunda é devolver o valor escrito dentro da função para
fora em uma variável
ex:
function obterTrue() {
return true;
}
let test = obterTrue();
[Link](test);
Resultado é “true “ mas qualquer valor que seja colocado à frente do “return“ dentro da
função é considerado string e number
parâmetro/ argumento = é usado como nomes no parentes da função “ function ( a, b) “ e
depois de fazer o bloco de função escreve o nome da função e o que cada variável vale
tanto string ou number
ex:
function soma( a, b) {
return a + b;
}
let resultado = soma(5, 7)
[Link](resultado)
resultado é a soma porque a função soma “ a “ e “ b “ e nesse exemplo “a “ e “ b “ tem o
valor de 5 = a e 7 = b então resultado é “12”
instanceof = usa para verificar o tipo do valor foi criado de um array, number, string e etc…
ex:
function TemperaturaMedia() {
if (!(temperatura instanceof Array)) {
let soma = 0;
for (let i = 0; i < [Link]; i++) {
soma += temperatura [1];
}
return soma / [Link];
}
Temperatura = [12, 12, 11, 11, 10, 9, 9, 10, 12, 13, 15, 18, 21]
[Link](`Resultado: ${temperaturamedia()}`);
Resultado é “ true “ caso “ temperatura “ for um array pode também ver se é number, strings
e etc…
callback = usa para que uma função execute outra função recebida como parâmetro
ex:
let inner = function() {
[Link]('Gabriel');
}
let outer = function(callback) {
[Link]('Pablo');
callback();
[Link]('Barbosa');
}
Resultado é uma lista onde “Gabriel “ é adicionado entre o “ Pablo “ e o “ Barbosa “ mas
apenas chamando callback
setTimeout = usa para que a função ( callback ) seja executada aposta um determinando
tempo, sem parar o programa e o tempo é em milissegundos 1000 = 1 segundo
ex:
let inner = function() {
[Link]('Gabriel');
}
let outer = function(callback) {
[Link]('Pablo');
setTimeout (callback, 2000);
[Link]('Barbosa');
}
Resultado é uma lista onde “Gabriel “ é adicionado depois de 2 segundos a lista com
programa funcionando
setInterval = usa para que a função seja executada em intervalos fixos repetidamente em
milissegundos 1000 = 1 segundo
ex:
let inner = function() {
[Link]('Gabriel');
}
let outer = function(callback) {
[Link]('Pablo');
setInterval (callback, 2000);
[Link]('Barbosa');
}
Resultado é uma lista onde “Gabriel “ é adicionado depois de 2 segundos na lista com
programa funcionando sucessivamente a cada 2 segundos
clearInterval = usa para que a função setInterval seja cancelado depois de um certo tempo
determinado em milissegundos 1000 = 1 segundo
ex:
let contador = setInterval ( function () {
[Link] (‘Pablo’);
}, 1000);
setTimeout(function () {
clearInterval(contador);
}, 4000);
Resultado é “Pablo “ aparecendo sucessivamente por 4 segundos e depois o programa para
sozinho
addEventlistener = usa para que alguma função aconteça assim que evento acontece
(clique, tecla, mouse, etc).
ex:
[Link]("click", function () {
[Link]("Clique detectado!");
});
Resultado é “clique detectado!” assim que fizer um clique
=> = usa para encurtar funções pequenas
ex1
let soma = (a, b) => a + b;
[Link](soma(10, 20));
Resultado é 30
ex 2:
let dobro = x => x * 2;
[Link](dobro(5));
Resultado é 10 e o X vale 5
ex 3:
let quadrado = n => n * n;
[Link](quadrado(4));
Resultado é 16 pois o “ n “ vale 4
ForEach = usa para percorrer o array/lista e executar uma função para cada elemento
ex:
let nomes = ['Alice', 'Eve', 'John'];
[Link](function (elemento) {
[Link](elemento);
});
Resultado é cada elemento do array “Alice, Eve, john”
ForEach + => = usa para percorrer o array/lista mas só com “ ForEach + => “
ex:
let nomes = ['Alice', 'Eve', 'John'];
[Link](elemento => [Link](elemento));
Resultado é cada elemento do array “Alice, Eve, john” mas em uma função menor
ForEach + índice = usa para dar o índice de cada cada elementos do array/lista
ex:
let nomes = ['Alice', 'Eve', 'John'];
[Link](elemento => [Link](elemento));
Resultado é cada elemento do array com um índice mas em uma função menor “ 0:Alice,
1:Eve, 2:John “
sort () = usa para ordenar os elementos de um array tanto número ( number ) ou letras
( string )
ex:
let números = [10, 2, 30];
nú[Link]((a, b) => a - b);
[Link](números);
Resultado é cada elemento do array ordenado em menor para maior “ 2,10,30 “ mas para
chegar a isso usa a função de comparação “ ( a, b ) => a - b ) “
“use strict” = use para Ativar o modo estrito do JavaScript, que deixa o código mais rigoroso
e ajuda a detectar erros
ex:
"use strict";
x = 10;
Resultado é “ Uncaught ReferenceError: x is not defined “
array(...) = usa para Criar um array novo; se passar 1 número, ele vira o tamanho do array
ex:
let arr = Array(5);
Resultado é Array com 5 posições vazias (lenght = 5)
instanceof = use para verificar se o objeto/Tipo é dessa categoria se sim respostas é “true”
se não é “false” variável instanceof Tipo
ex:
let números = [1, 2, 3];
[Link](números instanceof Array);
Resultado é “ true “ a variável números está sendo verificada por instanceof se é um Array
( Tipo )
try = Bloco de código onde você tenta executar algo que pode causar um erro.
ex:
try {
throw "Erro!";
}
Resultado é Uncaught Erro!
catch = Bloco de código onde captura o erro dentro do “ try “ e permite que o código siga
sem parar
ex:
try {
throw 100;
} catch (error) {
[Link](error);
}
Resultado é 100
new rangerError(...) = use para Criar um objeto de erro de Tipo RangerError indicando que
um valor está fora do intervalo Permitido
ex:
throw new RangeError("Valor máximo 20");
Resultado é “ Uncaught RangeError: Valor máximo 20 “
Factorial(n)= use para Criar uma função que fatora o número até chegar a 1
ex:
function factorial(n) {
let result = 1;
for (; n > 1; n--) {
result *= n;
}
return result;
}
[Link](factorial(5));
Resultado é 120 fatorando o “5” = 5x4x3x2x1 =120
Função fatorial com validação = use para Criar uma função que fatora mas se for maior que
tal número que você escolher ele rejeita sendo o limite
ex:
function factorial(n) {
if (n > 20) {
throw new RangeError("Max value 20");
}
let result = 1;
for (; n > 1; n--) {
result *= n;
}
return result;
}
[Link](factorial(20));
[Link](factorial(1000));
Resultado é um número maior que 20 ele nao fator “1000” já o “20” ele fatora sendo o limite
debugger = use para pausar depuração e execução do código e ativa depurador do
navegador
ex:
[Link]("Começo debugger");
debugger;
[Link]("After debugger");
Resultado é exibido no navegador “Começo debugger” e ele ja pausa e se clicar em
continuar aparece o “After debugger”