Bem-vindo ao Curso Gratuito de JavaScript!

Números

Em JavaScript, os números podem ser inteiros ou de ponto flutuante (decimais). Você pode fazer operações matemáticas com eles, como soma, subtração, multiplicação e divisão.

Strings

As strings representam texto em JavaScript e são delimitadas por aspas simples ('') ou aspas duplas (""). Você pode concatenar strings usando o operador de adição (+).

Booleanos

Os booleanos representam valores verdadeiros (true) ou falsos (false). Eles são frequentemente usados em expressões condicionais e operações lógicas.

Arrays

Os arrays são coleções ordenadas de valores. Eles podem conter valores de diferentes tipos, incluindo números, strings, objetos e até outros arrays. Os índices começam em 0.

Exemplos:

            // Números
            var idade = 25;
            var altura = 1.75;
            
            // Strings
            var nome = "Maria";
            var saudacao = 'Olá, ' + nome;
            
            // Booleanos
            var temCarro = true;
            var gostaDeProgramar = false;
            
            // Arrays
            var frutas = ['maçã', 'banana', 'laranja'];
            var numeros = [1, 2, 3, 4, 5];
                        

Como Abrir o Console

O console do navegador é uma ferramenta poderosa para depurar código e visualizar mensagens e erros. Aqui está como abrir o console em alguns navegadores populares:

Google Chrome:

Pressione F12 ou Ctrl + Shift + J (Windows/Linux) ou Cmd + Option + J (Mac) para abrir o DevTools e vá para a guia "Console".

Mozilla Firefox:

Pressione F12 ou Ctrl + Shift + K (Windows/Linux) ou Cmd + Option + K (Mac) para abrir o Console Web no painel DevTools.

Microsoft Edge:

Pressione F12 ou Ctrl + Shift + I (Windows/Linux) ou Cmd + Option + I (Mac) para abrir as Ferramentas de Desenvolvedor, vá para a guia "Console".

Safari:

Pressione Option + Cmd + C para abrir o Console no painel "Desenvolvedor" nas Preferências do Safari.

Definindo e Chamando Funções

Uma função é um bloco de código que pode ser chamado várias vezes para executar uma tarefa específica. Aqui está um exemplo:

            // Definindo uma função
            function saudacao() {
                console.log("Olá! Bem-vindo ao nosso site.");
            }
            
            // Chamando a função
            saudacao();
                        

Passando Parâmetros

Funções podem receber parâmetros para aceitar valores externos:

            // Função com parâmetros
            function saudar(nome) {
                console.log("Olá, " + nome + "!");
            }
            
            // Chamando a função com um parâmetro
            saudar("Maria");
                        

Retornando Valores

Funções podem retornar valores usando a palavra-chave `return`:

            // Função que retorna o quadrado de um número
            function quadrado(numero) {
                return numero * numero;
            }
            
            // Chamando a função e armazenando o resultado
            var resultado = quadrado(5);
            console.log("O quadrado de 5 é: " + resultado);
                        

As funções ajudam a organizar e reutilizar código em JavaScript, tornando o código mais modular e legível.

Em JavaScript, você pode realizar uma variedade de operações aritméticas para realizar cálculos matemáticos. As operações aritméticas mais comuns incluem adição, subtração, multiplicação e divisão.

Adição (+)

A adição é realizada usando o operador +. Por exemplo:

            let a = 5;
            let b = 3;
            let resultado = a + b;
            console.log("Resultado da adição:", resultado); // Resultado da adição: 8
                        

Subtração (-)

A subtração é realizada usando o operador -. Por exemplo:

            let x = 10;
            let y = 4;
            let resultado = x - y;
            console.log("Resultado da subtração:", resultado); // Resultado da subtração: 6
                        

Multiplicação (*)

A multiplicação é realizada usando o operador *. Por exemplo:

            let p = 7;
            let q = 2;
            let resultado = p * q;
            console.log("Resultado da multiplicação:", resultado); // Resultado da multiplicação: 14
                        

Divisão (/)

A divisão é realizada usando o operador /. Por exemplo:

            let m = 20;
            let n = 5;
            let resultado = m / n;
            console.log("Resultado da divisão:", resultado); // Resultado da divisão: 4
                        

Além dessas operações básicas, JavaScript também oferece operadores para realizar outras operações aritméticas, como módulo (%) para obter o resto da divisão e operadores de incremento (++), decremento (--), entre outros.

Em JavaScript, temos três maneiras de declarar variáveis: var, let e const. Cada uma delas tem seu próprio escopo e regras de uso. Vamos explorar as diferenças entre elas:

var

A declaração var é mais antiga e tem escopo de função ou global. Isso significa que a variável declarada com var pode ser acessada em todo o escopo da função onde foi declarada, ou globalmente se estiver fora de uma função.

let

A declaração let introduz a ideia de escopo de bloco. Variáveis declaradas com let têm escopo limitado ao bloco (por exemplo, dentro de loops ou condicionais) onde foram definidas.

const

A declaração const também tem escopo de bloco e, assim como o nome sugere, é usada para declarar constantes. Uma vez atribuído um valor a uma variável const, esse valor não pode ser reatribuído. No entanto, em caso de objetos e arrays, o conteúdo interno ainda pode ser modificado.

Em resumo, ao escolher entre var, let e const, leve em consideração o escopo necessário e a mutabilidade da variável. let é útil quando você precisa reatribuir valores, enquanto const é preferível para valores imutáveis.

Escopo Global e de Função

Aqui, vamos demonstrar como as declarações var, let e const se comportam em diferentes escopos:

            // Escopo Global
            var globalVar = "Variável Global";
            let globalLet = "Variável Global";
            const globalConst = "Variável Global";
            
            function testScope() {
                // Escopo de Função
                var functionVar = "Variável de Função";
                let functionLet = "Variável de Função";
                const functionConst = "Variável de Função";
            
                if (true) {
                    // Escopo de Bloco
                    var blockVar = "Variável de Bloco (var)";
                    let blockLet = "Variável de Bloco (let)";
                    const blockConst = "Variável de Bloco (const)";
                }
            
                console.log(globalVar);
                console.log(globalLet);
                console.log(globalConst);
                console.log(functionVar);
                console.log(functionLet);
                console.log(functionConst);
                console.log(blockVar);
            
                // Variáveis de bloco não são acessíveis aqui
                console.log(blockLet); // Vai causar erro
                console.log(blockConst); // Vai causar erro
            }
            
            testScope();
                        

Neste exemplo, observe como as variáveis `globalVar`, `globalLet` e `globalConst` têm escopo global e podem ser acessadas em qualquer lugar no código. As variáveis declaradas dentro da função `testScope` possuem escopo de função e só podem ser acessadas dentro dessa função. As variáveis `blockLet` e `blockConst` têm escopo de bloco e só podem ser acessadas dentro do bloco onde foram declaradas.

Condições com if e else

O uso de if e else permite executar diferentes blocos de código com base em condições. Aqui está um exemplo:

            var idade = 18;
            
            if (idade >= 18) {
                console.log("Você é maior de idade.");
            } else {
                console.log("Você é menor de idade.");
            }
                        

Neste exemplo, a mensagem "Você é maior de idade." será exibida se a variável idade for maior ou igual a 18. Caso contrário, a mensagem "Você é menor de idade." será exibida.

Condições Encadeadas com else if

Você também pode usar else if para lidar com várias condições:

            var hora = 14;
            
            if (hora < 12) {
                console.log("Bom dia!");
            } else if (hora < 18) {
                console.log("Boa tarde!");
            } else {
                console.log("Boa noite!");
            }
                        

Neste exemplo, o código verifica a variável hora e exibe mensagens diferentes com base no horário do dia.

Estrutura switch

O switch é usado para verificar diferentes valores de uma variável e executar ações com base nesses valores. Aqui está um exemplo:

            var diaSemana = 4;
            var mensagem = "";
            
            switch (diaSemana) {
                case 1:
                    mensagem = "Hoje é domingo.";
                    break;
                case 2:
                    mensagem = "Hoje é segunda-feira.";
                    break;
                case 3:
                    mensagem = "Hoje é terça-feira.";
                    break;
                case 4:
                    mensagem = "Hoje é quarta-feira.";
                    break;
                case 5:
                    mensagem = "Hoje é quinta-feira.";
                    break;
                case 6:
                    mensagem = "Hoje é sexta-feira.";
                    break;
                case 7:
                    mensagem = "Hoje é sábado.";
                    break;
                default:
                    mensagem = "Dia inválido.";
            }
            
            console.log(mensagem);
                        

Neste exemplo, o código verifica o valor da variável diaSemana e exibe a mensagem correspondente ao dia da semana usando a estrutura switch. O bloco break é usado para interromper a execução após cada caso.

Laço for

O laço for é usado para executar um bloco de código várias vezes. Aqui está um exemplo:

            for (var i = 1; i <= 5; i++) {
                console.log("Número: " + i);
            }
                        

Laço while

O laço while executa um bloco de código enquanto uma condição for verdadeira:

            var contador = 1;
            
            while (contador <= 5) {
                console.log("Contador: " + contador);
                contador++;
            }
                        

Laço do...while

O laço do...while executa um bloco de código pelo menos uma vez e depois verifica a condição:

            var numero = 1;
            
            do {
                console.log("Número: " + numero);
                numero++;
            } while (numero <= 5);
                        

Os três tipos de laços permitem repetir tarefas de forma eficiente em seu código.

sessionStorage e localStorage

O `sessionStorage` e `localStorage` são mecanismos de armazenamento local em JavaScript para guardar informações no navegador do usuário.

sessionStorage

O `sessionStorage` mantém os dados enquanto a janela/aba do navegador estiver aberta. Quando a janela é fechada, os dados são removidos.

            // Armazenar dados no sessionStorage
            sessionStorage.setItem('nome', 'João');
            sessionStorage.setItem('idade', '30');
            
            // Obter dados do sessionStorage
            var nome = sessionStorage.getItem('nome');
            console.log('Nome: ' + nome);
            
            // Remover dado do sessionStorage
            sessionStorage.removeItem('idade');
                        

localStorage

O `localStorage` mantém os dados mesmo após o fechamento da janela/aba. Os dados só são removidos quando o usuário limpa o cache ou o código explicitamente remove os itens.

            // Armazenar dados no localStorage
            localStorage.setItem('email', 'joao@example.com');
            
            // Obter dados do localStorage
            var email = localStorage.getItem('email');
            console.log('Email: ' + email);
            
            // Remover dado do localStorage
            localStorage.removeItem('email');
                        

O armazenamento local é útil para salvar informações como configurações do usuário ou dados temporários.

Em programação, os operadores lógicos são usados para realizar operações lógicas em valores booleanos (verdadeiro ou falso). Eles permitem combinar condições e tomar decisões com base nessas combinações.

Operador E Lógico (&&)

O operador && retorna verdadeiro (true) se ambas as condições forem verdadeiras. Caso contrário, retorna falso (false).

            
    var condicao1 = true;
    var condicao2 = false;
    
    var resultado = condicao1 && condicao2;
    console.log(resultado); // Resultado será falso
            
        

Operador OU Lógico (||)

O operador || retorna verdadeiro (true) se pelo menos uma das condições for verdadeira. Retorna falso (false) somente se ambas as condições forem falsas.

            
    var condicao3 = true;
    var condicao4 = false;
    
    var resultado = condicao3 || condicao4;
    console.log(resultado); // Resultado será verdadeiro
            
        

Operador NÃO Lógico (!)

O operador ! é usado para negar o valor de uma condição. Ele inverte o valor booleano original.

            
    var condicao5 = true;
    
    var resultado = !condicao5;
    console.log(resultado); // Resultado será falso
            
        

Esses operadores lógicos são amplamente utilizados para criar condições e tomar decisões em programas JavaScript. Eles são essenciais para o controle de fluxo e a lógica de programação em geral.

Operador E Lógico (&&)

O operador && retorna verdadeiro (true) apenas quando ambas as condições são verdadeiras.

Condição A	Condição B	Resultado (A && B)
true	true	true
true	false	false
false	true	false
false	false	false

Operador OU Lógico (||)

O operador || retorna verdadeiro (true) se pelo menos uma das condições for verdadeira.

Condição A	Condição B	Resultado (A || B)
true	true	true
true	false	true
false	true	true
false	false	false

Introdução

Em JavaScript, a manipulação de strings é uma tarefa comum. Duas técnicas fundamentais para combinar strings ou adicionar variáveis a uma string são interpolação e concatenação. Neste guia, você aprenderá o que são essas técnicas e como usá-las no JavaScript.

Concatenação em JavaScript

A concatenação é a técnica de combinar duas ou mais strings em uma única string. Isso é feito usando o operador +. Aqui está um exemplo:

            let nome = "Alice";
            let saudacao = "Olá, " + nome + "! Bem-vindo ao nosso site.";
            console.log(saudacao);
                        

Neste exemplo, usamos o operador + para concatenar as strings "Olá, ", o valor da variável nome e " Bem-vindo ao nosso site." em uma única string.

Interpolação em JavaScript

A interpolação é uma técnica mais moderna e legível para criar strings complexas em JavaScript. Ela usa template literals (literais de modelo) delimitados por crases (`). Aqui está um exemplo:

            let nome = "Alice";
            let saudacao = `Olá, ${nome}! Bem-vindo ao nosso site.`;
            console.log(saudacao);
                        

No exemplo acima, usamos template literals (envolvendo a string com crases) e ${} para incorporar o valor da variável nome diretamente na string.

Quando usar qual técnica?

Use concatenação quando estiver trabalhando com JavaScript mais antigo ou se preferir uma abordagem mais tradicional.

Use interpolação com template literals quando desejar criar strings complexas ou incluir variáveis em strings de forma mais legível.