console.log('Bem Vindo ao inicio de JavaScript!')//aviso comum
console.error('esse e um suposto erro')//erro em vermelho
console.warn('esse é um warn') //alerta em amarelo
console.info('esse é um info') //esse é um informação
1. `var`: essa é a maneira mais antiga de declarar uma variável em JavaScript.
O escopo dessa variável é global ou local, dependendo de onde ela é declarada.
Ela pode ser reatribuída e redeclarada.
2. `let`: essa é uma nova maneira de declarar uma variável em JavaScript.
A variável declarada com let é acessível apenas dentro do bloco em que foi declarada.
Ela pode ser reatribuída, mas não pode ser redeclarada.
3. `const`: essa é uma maneira de declarar uma variável em JavaScript que não pode ser reatribuída nem redeclarada.
O valor atribuído a ela é constante e não pode ser alterado.
4. `undefined`: esse valor é atribuído a uma variável quando ela é declarada, mas ainda não foi atribuído um valor.
5. `null`: esse valor é atribuído a uma variável quando você deseja que ela não tenha nenhum valor ou referência.
const product = {
name: 'camisa',
price: 15.99,
inStock: true,
sizes: ['P', 'M', 'G'],
'main color':'azul',
}
console.log(product.name);
console.log(product['name']);
console.log(product['main color']);
tconst dog = {
name:'Shark',
age: 10,
}
const json = JSON.stringify(dog) //converte para JSON
console.log(json)
const obj = JSON.parse(json) // convertendo json para usar quando vier de api
console.log(obj)
Além do if, else if e else, em JavaScript temos também a condicional switch.
switch (expressao) {
case valor1:
// Bloco de código a ser executado caso a expressão seja igual a valor1
break;
case valor2:
// Bloco de código a ser executado caso a expressão seja igual a valor2
break;
default:
// Bloco de código a ser executado caso a expressão não seja igual a nenhum dos valores anteriores
}
// A 'expressao' é avaliada e comparada com cada um dos 'valores'.
// Se a expressão for igual a um dos valores, o bloco de código correspondente é executado.
// Se não houver nenhum caso correspondente, o bloco de código dentro do 'default' é executado.
Em JavaScript, as funções são blocos de código que podem ser chamados para executar uma tarefa específica. As funções permitem que você escreva um código mais modular e reutilizável, evitando a repetição de código desnecessária. A sintaxe básica para criar uma função é a seguinte:
function nomeDaFuncao(parametro1, parametro2, ...) {
// Bloco de código a ser executado
return valorDeRetorno;
}
//O nomeDaFuncao é o nome que você escolhe para a função.
//Os parâmetros são valores opcionais que você pode passar para a função, para que ela possa trabalhar com eles.
// O bloco de código dentro da função é executado quando a função é chamada.
// A palavra-chave return é usada para retornar um valor para quem chamou a função.
function soma(a, b) {
return a + b;
}
//Você pode chamar a função passando os parâmetros desejados:
let resultado = soma(2, 3);
console.log(resultado); // Saída: 5
// Além disso, em JavaScript, as funções são objetos de primeira classe,
// o que significa que elas podem ser atribuídas a variáveis,
// passadas como argumentos para outras funções e retornadas por outras funções.
// Por exemplo:
let minhaFuncao = function(parametro) {
// Bloco de código a ser executado
}
function executaFuncao(funcao, parametro) {
return funcao(parametro);
}
let resultado = executaFuncao(minhaFuncao, "Hello World");
console.log(resultado);
// Nesse exemplo, a função executaFuncao recebe como argumentos outra função e um parâmetro.
// Ela executa a função passada e retorna o resultado.]
// A variável minhaFuncao armazena uma função anônima que recebe um parâmetro e executa um bloco de código.
// Quando minhaFuncao é passada como argumento para executaFuncao, ela é executada com o parâmetro "Hello World".
// O resultado é armazenado na variável resultado e exibido no console.
`==` e `===` são operadores de comparação em JavaScript.
`==` verifica se dois valores são iguais, mesmo que eles tenham tipos diferentes.
Por exemplo, `1 == "1"` é verdadeiro porque ambos os valores são iguais a 1.
Já `===` verifica se dois valores são iguais e do mesmo tipo.
Por exemplo, `1 === "1"` é falso porque os valores são iguais, mas têm tipos diferentes.
`||` e `&&` são operadores lógicos em JavaScript.
`||` (ou lógico) retorna `true` se pelo menos uma das condições for verdadeira.
Por exemplo, `true || false` é verdadeiro porque pelo menos uma das condições é verdadeira.
Já `&&` (e lógico) retorna `true` se todas as condições forem verdadeiras.
Por exemplo, `true && true` é verdadeiro porque ambas as condições são verdadeiras.
Além desses operadores, há outros operadores em JavaScript que podem ser úteis em estruturas condicionais, tais como:
- `>` (maior que): verifica se um valor é maior do que outro.
- `<` (menor que): verifica se um valor é menor do que outro.
- `>=` (maior ou igual a): verifica se um valor é maior ou igual a outro.
- `<=` (menor ou igual a): verifica se um valor é menor ou igual a outro.
- `!=` (diferente de): verifica se dois valores são diferentes, mesmo que tenham tipos diferentes.
- `!==` (estritamente diferente de): verifica se dois valores são diferentes e de tipos diferentes.
- `!` (negação): inverte o valor de uma expressão booleana. Por exemplo, `!true` é falso.
É importante lembrar que a ordem de precedência dos operadores em JavaScript pode afetar o resultado final.
Por isso, é importante entender como os operadores são avaliados para escrever código correto e eficiente.