Como usar o setInterval

setInterval e clearInterval():

O setInterval() é uma função temporizadora. Ela executa uma função de retorno após determinado tempo. A função setInterval() executará infinitamente, até que você execute a função clearInterval().

Se você é iniciante, você pode pular a explicação Como funciona.

Como funciona?

Sendo uma função assíncrona, a instrução a ser executada é lançada no Event Loop. Mas o que é Event Loop? É uma instrução síncrona, ou seja, quando ela estiver executando, a thread ficará bloqueada e, assim que terminar, a próxima instrução é executada. Como o setInterval() executará infinitamente, sabemos que ele adicionará uma instrução ao Event Loop a cada quantia de tempo que for definida.

Definição:

O setInterval() chama uma função em intervalos de tempo definidos. Ele continuará chamando a função até que o clearInterval() seja chamado, ou que a página seja fechada.

Sintaxe:

// sintaxe da função setInterval, que define um temporizador
// que disparará uma ação definida em tempo estipulado
setInterval(function, miliseconds, parameter1, parameter2, …);
Onde:

function: é a função que será executada;

miliseconds: é o intervalo em milisegundos(ms) em que o código será executado. Se o valor especificado for menor que 10, o valor 10 será utilizado.

parameter: parâmetros para passar para a função.

Exemplo:

<!DOCTYPE html>
<html lang="pt-br">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>setInterval() e clearInterval()</title>
</head>

<body>
    <button id="btn">Clique aqui para iniciar</button>
    <script src="main.js"></script>
</body>

</html>
E no JavaScript:
// Crie uma variável
let variavel;

// Crie uma função, utilizando essa variável para 
// declarar o intervalo em que será disparado.
function minhaFuncao() {
    variavel = setInterval(consoleLog, 2000);
}
// Mensagem que será mostrada no console
function consoleLog() {
    console.log("Ola mundo!");
}

// Função será chamada utilizando o evento onclick
document.getElementById("btn").onclick = minhaFuncao;

O clearInterval() limpa o timer configurado pela função setInterval(). Ele desativa a função e não executa a função definida pelo temporizador.

Sintaxe:

// Função clearInterval travará a execução do setInterval
// bloqueando a ação definida pelo temporizador
clearInterval(id_do_setInterval)

Exemplo:

<!DOCTYPE html>
<html lang="pt-br">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>setInterval() e clearInterval()</title>
</head>
<body>
    <button id="btn">Clique aqui para iniciar</button>
    <button id="btn2">Clique aqui para parar</button>
    <script src="main.js"></script>
</body>
</html>
E no JavaScript:
// Crie uma variável
let variavel;

// Crie uma função, utilizando essa variável para 
// declarar o intervalo em que será disparado.
function minhaFuncao() {
    variavel = setInterval(consoleLog, 2000);
}
// Mensagem que será mostrada no console
function consoleLog() {
    console.log("Ola mundo!");
}

// Função que será executada para bloquear
// a ação do temporizador definido no setInterval
function pararFuncao() {
    clearInterval(variavel);
}

// Função será chamada utilizando o evento onclick
document.getElementById("btn").onclick = minhaFuncao;
document.getElementById("btn2").onclick = pararFuncao;

Gostou deste artigo? Deixe o seu comentário abaixo:

Gráficos Line e Bar com Chart.js

Criando gráficos com Chart.js

Os gráficos de linhas e barras são gráficos muito utilizados no mundo empresarial. O gráfico de linha é usado para mostrar tendências, comparar conjuntos de dados, mostrar evoluções e diminuições de algum fenômeno. Apresenta a variação de valores dos dados em determinado período.

Se você ainda não viu o artigo Iniciando com Chart.js, acesse-o no link:https://www.mundojs.com.br/iniciando-com-chart-js/

LINHA:

O gráfico de linhas é uma maneira de mostrar os pontos de dados em uma linha. O gráfico em linha permite que um número de propriedades seja especificado para cada um dos conjuntos de dados.

Ao criar o seu documento HTML base, você deverá adicionar um Canvas na sua página.

<!-- adicione a tag canvas no seu HTML -->
<canvas id="myChart"></canvas>

Com o Canvas adicionado, você precisará incluir a biblioteca Chart.js na sua página.

<!-- o link a seguir direciona para a biblioteca online do Chart.js -->
<!-- a biblioteca também está disponível para download no site do Chart.js -->
<script src="https://cdnjs.cloudflare.com/ajax/libs/Chart.js/2.8.0/Chart.bundle.js"></script>

Para criar um gráfico do tipo Linha, você usará o seguinte código:

// criando um novo objeto, contendo o tipo, os dados
// e as opções que o gráfico terá.
let ctx = document.getElementById('myChart');

let chart = new Chart(ctx, {
    type: 'line',
    data: data,
    options: options
});

Onde:

Type:

É o tipo de gráfico que será feito;

Data:

Os dados que serão inseridos no gráfico.

Options:

As customizações que você fará no seu gráfico.

TYPE:

Este valor define de qual tipo será o gráfico. Você deve utilizar ‘line’ para o formato LINHA.

// type:'line'

DATA:

Para a construção do gráfico, é necessário que os datasets contenham os valores a ser inseridos no gráfico. Para isto, cria-se um vetor com os valores necessários.

Você também poderá inserir uma legenda (label) para a linha do gráfico.

// O objeto data possui os valores dispostos no gráfico
data: {
    // Legendas das Linhas
    labels: ['Janeiro', 'Fevereiro', 'Março', 'Abril', 'Maio', 'Junho', 'Julho'],
    datasets: [{
        // Legenda
        label: 'Meu primeiro gráfico',
        // Define-se a cor da linha.
        borderColor: 'rgb(245,222,179)',
        // Dados a serem inseridos nas barras
        data: [0, 10, 5, 2, 20, 12, 1],
    }]
}

OPTIONS:

Esse objeto define as opções a serem inseridas no seu gráfico. Confira as diversas customizações disponíveis para o seu tipo de gráfico em: https://www.chartjs.org/docs/latest/charts/line.html.

O exemplo a seguir utilizará a opção tension, que define se as linhas serão retas ou possuirão algum tipo de curvatura.

// Esta opção define se as linhas serão curvadas ou retas,
// use 0 para retas.
options: {
    elements: {
        line: {
            tension: 0
        }
    }
}

BARRAS:

O gráfico de barras mostra os valores dos dados com barras verticais. É muito utilizado para mostrar dados de tendências e comparação de vários conjuntos de dados. Cada barra retangular é correspondente a uma categoria e proporcional ao valor do dado na respectiva categoria.

De maneira semelhante à criação do gráfico em linhas, utilizaremos a mesma estrutura HTML para o gráfico de barras.

Para criar um gráfico do tipo Barra, você usará o seguinte código:

// criando um novo objeto, contendo o tipo, os dados
// e as opções que o gráfico terá.
let ctx = document.getElementById('myChart');
let myBarChart = new Chart(ctx, {
    type: 'bar',
    data: data,
    options: options
});

TYPE:

Este valor define de qual tipo será o gráfico. Você deve utilizar ‘bar’ para o formato BARRA VERTICAL e ‘horizontalBar’ para o formato BARRA HORIZONTAL.

// type: 'bar'
// type: 'horizontalBar'

DATA:

Assim como no gráfico em Linhas, é necessário que os datasets contenham um vetor com os valores a ser inseridos no gráfico. Você deve especificar também as cores de cada retângulo, sendo uma cor para cada valor no vetor. Também pode inserir legendas. Confira mais opções em: https://www.chartjs.org/docs/latest/charts/bar.html

// O objeto data possui os valores dispostos no gráfico
data: {
    // Legendas das Barras
    labels: ['Segunda', 'Terça', 'Quarta', 'Quinta', 'Sexta', 'Sábado'],
    datasets: [{
        // Legenda geral
        label: '$ em Vendas',
        // Dados a serem inseridos nas barras
        data: [10, 9, 12, 19, 21, 7],
        // Define as cores de preenchimento das barras
        // de acordo com sua posição no vetor
        backgroundColor: [
            'rgba(255, 99, 132, 0.2)',
            'rgba(54, 162, 235, 0.2)',
            'rgba(255, 206, 86, 0.2)',
            'rgba(75, 192, 192, 0.2)',
            'rgba(153, 102, 255, 0.2)',
            'rgba(255, 159, 64, 0.2)'
        ],
        // Define as cores de preenchimento das bordas das barras
        // de acordo com sua posição no vetor
        borderColor: [
            'rgba(255, 99, 132, 1)',
            'rgba(54, 162, 235, 1)',
            'rgba(255, 206, 86, 1)',
            'rgba(75, 192, 192, 1)',
            'rgba(153, 102, 255, 1)',
            'rgba(255, 159, 64, 1)'
         ],
         // Define a espessura da borda dos retângulos
         borderWidth: 1
    }]
},

OPTIONS:

Esse objeto define as opções a serem inseridas no seu gráfico. Você também pode conferir as diversas opções de customização na documentação do Chart.js.

Neste exemplo será utilizada a opção beginAtZero, que tem a função de começar a barra no valor 0 do eixo X.

// Customização que define onde irá começar a ser erguida a barra
// começando pelo ZERO, no eixo X.
options: {
    scales: {
        yAxes: [{
            ticks: {
                beginAtZero: true
            }
        }]
    }
}

 

Gráficos Pie e Doughnut com Chart.js

Criando gráficos com Chart.js

Os gráficos Donut(Doughnut) e Pizza(Pie) são, provavelmente, os gráficos mais utilizados atualmente. Eles são divididos em segmentos, e cada segmento é proporcional ao valor de cada dado. Esses segmentos são divididos na forma de arcos.

Se você ainda não leu o artigo Iniciando com Chart.js, acesse-o no link: https://www.mundojs.com.br/iniciando-com-chart-js/

Estes dois tipos de gráficos são excelentes para demonstrar as proporções entre os dados inseridos.

O gráfico do tipo Donut e do tipo pizza são do mesmo tipo no Chart.js, com a diferença de um único objeto, denominado cutoutPercentage. Este valor define o tamanho do espaço central vazio do gráfico, e possui como valor padrão 50%.

Ao criar o seu documento HTML base, você deverá adicionar um Canvas na sua página:

<!-- adicione a tag canvas no seu HTML -->
<canvas id="myChart"></canvas>

Com o Canvas adicionado, você precisará incluir o Chart.js na sua página.

<!-- o link a seguir direciona para a biblioteca online do Chart.js -->
<!-- a biblioteca também está disponível para download no site do Chart.js -->
<script src="https://cdnjs.cloudflare.com/ajax/libs/Chart.js/2.8.0/Chart.bundle.js"></script>

Para fazer um gráfico do tipo Donut, você usará o seguinte código:

// Criando um novo objeto, contendo o tipo, os dados
// e as opções que o gráfico terá.
let meuDonutChart = new Chart(ctx, {
    type: 'doughnut',
    data: dados,
    options: opcoes
});
Onde:

type: É o tipo de gráfico que será feito.

data: Os dados que serão inseridos no gráfico.

options: Serão as customizações que você fará no seu gráfico.

TYPE:

Este valor define de qual tipo será o gráfico. Você deve utilizar ‘pie’ para o formato PIZZA e ‘doughnut’ para o formato DONUT.

// type: 'doughnut'
// type: 'pie'

DATA:

Para construir o gráfico, é necessário que os datasets contenham um vetor com os valores a serem inseridos. Estes valores serão somados em um total e calculados levando em consideração a proporção relativa de cada dado.

Você poderá inserir uma legenda (label) para cada pedaço do gráfico. Verifique a estrutura no código abaixo:

// Cria-se um objeto chamado dados onde:
let dados = {
    datasets: [{
        // cria-se um vetor data, com os valores a ser dispostos no gráfico
        data: [10, 20, 30],
        // cria-se uma propriedade para adicionar cores aos respectivos valores do vetor data
        backgroundColor: ['rgb(255, 99, 132)', 'rgb(255, 199, 132)', 'rgb(55, 99, 132)']
    }],

    // cria-se legendas para os respectivos valores do vetor data
    labels: ['Vermelho', 'Amarelo', 'Azul']
};

OPTIONS:

Este objeto define as opções a ser inseridas no seu gráfico. Confira as diversas opções de customizações para o seu gráfico no link: https://www.chartjs.org/docs/latest/charts/doughnut.html.

O exemplo a seguir utilizará a opção cutoutPercentage, que, juntamente com o atributo “type”, define se o gráfico será do padrão Pizza ou Donut. Se esta opção não estiver definida, trará como valor padrão 50%. Se você utilizar o valor 0, retornará um gráfico sem espaço central. Confira no código abaixo:

// Crie um objeto que defina as opções customizáveis
// do seu gráfico.
let opcoes = {
    cutoutPercentage: 40,
};

Confira o código completo realizando o download: Exemplo Chart.js

Neste artigo, foi realizada a configuração de dois gráfico, Pizza e Donut, utilizando a biblioteca Chart.js. Gostou? Comente ou tire suas dúvidas!

Diferença de var, let e const no JavaScript

Diferenças:

Você sabe qual a diferença entre var, let e const em JavaScript? Sabe como aplicá-las? Descubra tudo no artigo abaixo:

Variável, um breve resumo:

Uma variável referencia um espaço na memória, utilizado para guardar informações. Uma variável é um dos, se não o conceito mais importante em programação, e independe da linguagem de programação utilizada. Na variável, nós armazenamos um valor neste espaço de memória e informamos o seu tipo. Ela se chama variável, pois poderá ser alterada ao longo do tempo, ou seja, o valor é “variável”.

No JavaScript, não precisamos informar o tipo do dado armazenado na memória. Mas existem três tipos de variáveis no JavaScript, elas são:

  • var;

  • let;

  • const;

Agora vamos ver o conceito e aplicação de cada uma delas:

Var:

Em JavaScript, o escopo é dado por funções, e não por blocos. A palavra “var” garante a variável dentro do escopo onde ela foi declarada, ou seja, pode ser acessada de qualquer ponto dentro do código, como no exemplo abaixo:

// var está sendo declarado dentro do escopo da função
function imprimeNome() {
    var nome = "Fulano";
}
imprimeNome();
console.log('Meu nome é: ', nome);

Executando este código, a saída será “Uncaught ReferenceError: nome is not defined”.

Mas por que? Porque a variável nome não possui nenhum valor definido fora do escopo da função, ou seja, a variável nome só existe dentro da função imprimeNome.

Segundo as boas práticas, o var está aos poucos sendo substituído pelo uso do let e const.

Let:

A palavra-chave “let” é usada para declarar as variáveis com escopo de bloco. Ou seja, quando é declarada dentro de qualquer bloco, seja ele uma função, uma condicional ou um loop, ela ficará acessível apenas dentro do bloco do qual foi declarada.

Seu comportamento é igual ao da variável “var” quando ela for declarada fora de função, no escopo global. Observe o exemplo abaixo:

// variável let a declarada no escopo global e
// variável let b declarada no escopo da função
let a = "fulano";
function imprimeNome() {
    let b = "ciclano";
    if (a != b) {
    console.log("Seu nome é ", a, "ou", b, "?");
    }
}
imprimeNome();

Executando o código acima, a saída será: Seu nome é fulano ou ciclano?

Mas por que funcionou? Veja bem, o let possui escopo global e também é acessível dentro da função, portanto, poderá ser acessada e retornar os seus valores.

Const:

A palavra-chave “const” indica uma variável que possui o valor fixo, uma constante. Não significa que é imutável, mas sim, que a constante não poderá ser alterada. A constante pode ser declarada tanto ao escopo global, quando em uma função, funcionando de maneira parecida com o “let”, com a diferença que o “const” terá um valor constante. Veja no exemplo a seguir:

// variável const declarada no escopo global
const valor = 12;
function imprimeValor(){
    for(valor = 12; valor < 15; valor++){
        console.log('Valor: ', valor);
    }
}
imprimeValor();

Executando o código, o retorno será um erro: Uncaught TypeError: Assignment to constant variable. Isso acontece porque o laço for incrementará a constante, alterando o seu valor.

Gostou deste artigo? Deixe sua opinião nos comentários!

Atualizações de Junho

logo
Prezados leitores do MundoJS,

A partir de hoje, será disponibilizado no site uma nova aba chamada Cursos, onde estarão disponíveis cursos gratuitos e pagos de empresas parceiras do MundoJS. Aqui, você encontrará e será direcionado para diversos cursos na área de desenvolvimento web, desde JavaScript básico até Front-End avançado e FullStack.

Clicando na palavra gratuitos, no subtítulo principal do site, você será redirecionado diretamente aos cursos que estão disponíveis gratuitamente. Fique ligado, pois novos cursos serão adicionados com o passar do tempo.

Atenciosamente,

Equipe Moderadora.

Eventos no JavaScript

O que são Eventos?

Eventos são ações que ocorrem no sistema. Envolver eventos na sua página web significa interação, que deixará a sua página mais atrativa e interessante. Podemos utilizar como exemplo, um clique em um botão em uma página web e este clique irá gerar uma ação (um evento).

Cada clique, cada tecla pressionada, um toque em uma tela touchscreen dão vida à sua página, criam interação. Estas interações são conhecidas como eventos.

Os eventos em JavaScript podem ser analisados em camadas. Por exemplo, preencher um formulário e devolver uma mensagem de sucesso ao usuário (alert()):

  • O campo é preenchido;
  • O usuário clica no botão de envio;
  • O botão dispara um evento;
  • O código escuta o evento disparado;
  • A mensagem de sucesso é mostrada ao usuário.

Quando o botão é clicado, o navegador emite a ação, que é conhecida como evento. A aplicação sabe que o botão foi clicado, mas se faz necessário saber o que acontece quando esta ação é realizada, fazendo-se necessário que o código esteja escutando ativamente o evento.

Cada evento disponível possui um manipulador de eventos, que é um bloco de código (uma função JavaScript) que é executado quando a ação foi disparada. Quando o código é rodado em resposta ao evento disparado, estamos registrando um manipulador de eventos. Em alguns casos, os manipuladores de eventos são chamados de escutadores de evento. Os escutadores escutam o evento acionado, e o manipulador de eventos é o código que será acionado em resposta a este acontecimento.

Eventos no JavaScript, como ocorrem?

// Nesta função, um evento será acionado
// quando o usuário pressioná-lo, e irá
// devolver uma mensagem de alerta na tela.
<!DOCTYPE html>
<html>

<head>
    <meta charset="UTF-8" />
    <title>Exemplo de Eventos</title>
</head>

<body>
    <button>Pressione Aqui</button>
    <script>
        var btn = document.querySelector('button');

        btn.addEventListener('click', mostrarCaixa, false);

        function mostrarCaixa(e) {
            window.alert("Você clicou em mim!");
        }
    </script>
</body>

</html>

Este código gera uma escuta de um evento (clicar no botão) e uma reação a ele (mostrar a caixa de diálogo).

Escutando Eventos (addEventListener()):

Eventos são disparados. A tarefa de escutar o evento certo é tratada pela função addEventListener(). Esta função notifica as outras partes do aplicativo quando o evento é disparado. Ela é usada da seguinte forma:

source.addEventListener(eventName, eventHandler, false);

Onde:

  • source é o nome da função (btn no caso de exemplo acima);
  • eventName é a especificação do evento que será escutado (‘click’ no nosso exemplo);
  • eventHandler é a especificação da função que será chamada quando o evento for disparado ( mostrarCaixa no exemplo acima);
  • O último argumento diz respeito às fases do evento, capturing e bubbling (conceitos que serão vistos adiante).

Manipuladores e Argumentos de Evento:

A função que é chamada quando um evento é disparado é conhecido como Manipulador de Eventos (event handler). Pelo addEventListener, conseguimos perceber que o nosso manipulador de eventos é a função mostrarCaixa.

btn.addEventListener('click', mostrarCaixa, false);

A declaração da função é praticamente a mesma que qualquer outra função declarada, com a exceção de que a função recebe um argumento, conhecido como argumentos de evento (“eventargs”). Estes argumentos de evento fornecem mais detalhes sobre o evento, tornando o manipulador mais inteligente. O manipulador de eventos do exemplo não faz nada com os argumentos do evento, mas serve como base para você criar argumentos ao seu critério.

Os argumentos de evento contém propriedades relevantes ao evento disparado. Por exemplo, uma ação disparada por um click do mouse terá propriedades diferentes em seus argumentos do evento de uma ação disparada por um toque na tela(no caso de telas touchscreen) e de uma tecla clicada.

Borbulhamento e captura de eventos (bubbling e capturing):

Borbulhamento e captura de eventos descrevem o que acontece quando dois manipuladores do mesmo tipo de evento são ativados em um elemento.

Na fase de captura:
  • O navegador verifica se o ancestral mais externo do elemento (<html>) tem um manipulador de eventos registrado nele e o executa.
  • Ele realiza o mesmo procedimento dentro dos elementos filhos até alcançar o elemento clicado.
Na fase de Borbulhamento:
  • O navegador verifica se o elemento clicado tem um manipulador de elementos registrado e o executa.
  • Em seguida, ele passa para o próximo elemento ancestral imediato e realiza a mesma coisa sucessivamente, até alcançar o elemento (<html>).

Qual a diferença entre JSON e um objeto JavaScript?

Neste post mostrarei brevemente o que é um JSON e o que é um objeto literal JavaScript e qual a diferença entre eles.

JSON

JSON é a abreviação de JavaScript Object Notation e é uma maneira de armazenar e comunicar informações de maneira organizada e fácil de acessar. Em resumo, o JSON nos dá uma coleção de dados legíveis por humanos que podemos acessar de uma maneira realmente lógica.

Atualmente o JSON tem sido muito utilizado para facilitar a comunicação e passagem de dados entre sistemas construídos em linguagens de programação diferentes. Em especial, muitas APIs usam o JSON como seu formato de recebimento e retorno de dados

Exemplo JSON

{
    "nome":"Paulo",
    "idade": 34
}

 

Objeto JavaScript

Um objeto JavaScript é uma representação abstrata de um modelo de dados composto, assim como nas outras linguagens de programação.

Exemplo:

let objeto = { 
    nome:"Paulo", 
    idade: 34 
}

Devido a semelhança entre o JSON e o Objeto Literal, quando o JavaScript lê o JSON ele o reconhece com se fosse um objeto literal. Isso facilita a programação e recebimento de dados, mas acaba confundindo alguns iniciantes.

 

Onde que o JavaScript e o JSON diferem?

Mesmo assim, existem algumas diferenças entre ambos que importante conhecer. Veja abaixo:

Criação de atributos

Como você deve ter notado no exemplo, no JSON é necessário criar as propriedades usando aspas duplas, enquanto no objeto apenas o nome é necessário.

//Obj Literal
let objeto = {
    umaProp: "Lorem Ipsum"
}

//JSON
let objeto2 = {
    "umaProp": "Lorem Ipsum"
}

Uso de aspas

Enquanto o objeto permite o uso de aspas simples ou dupla para expressar strings, o JSON já funciona de maneira mais uniforme e permite apenas o uso de aspas duplas.

// Os seguintes exemplos não são JSONs válidos
{
    'prop': "propriedade"
}

{
    "prop": 'propriedade'
}

Importante: Note que se você estiver utilizando o JavaScript, não ocorrerá erro pois ele interpretará seu objeto como sendo literal.

Tipos de Dados:

JSON: O Json pode armazenar os seguintes valores

  • String
  • Número
  • Objeto JSON
  • Vetor
  • Booleano
  • Null

Objeto: Além dos valores acima, o objeto possuí alguns valores que não são válidos no JSON

  • Objeto Literal
  • Data (no formato Date)
  • Função
  • Undefined

É isso aí, espero que esta explicação rápida ajude mais alguém. Se você conhece outras diferenças, deixe aqui nos comentários que atualizarei a postagem conforme aparecerem contribuições.

Laço FOR em JavaScript

O laço FOR é uma estrutura de repetição muito utilizada em JavaScript. Este laço de repetição utiliza uma variável, que controlará a contagem do loop, podendo ser utilizada na forma de incremento ou decremento. É um comando que se faz muito útil quando se sabe de antemão quantas vezes a repetição será executada.

No JavaScript, o laço de repetição FOR poderá ser utilizado de quatro formas diferentes, sendo a mais usual:

PRIMEIRA FORMA (FOR)

Laço for com INCREMENTO:
// O laço de repetição for utiliza uma variável de varredura
// e irá retornar os valores do vetor, de forma crescente ou decrescente
let vetor=[11, 22, 33, 44];
for (let index = 0; index < vetor.length; index++) {
    console.log(vetor[index]);
}

Sendo nesta forma, normalmente serão passados como parâmetros uma variável auxiliar, que será utilizada para a varredura no laço, uma condição de saída/pause no laço e um incremento, que realizará uma varredura de forma crescente.

Laço for com DECREMENTO:
let vetor=[11, 22, 33, 44];
for (let index = 0; index < vetor.length; index--) {
    console.log(array[index]);
}

Nesta forma, o laço executará o loop de forma decrescente.


SEGUNDA FORMA (FOR…OF)

// O laço de repetição for...of percorre de forma iterativa e crescente
// e retorna os valores do vetor
let vetor=[11, 22, 33, 44];
for (const item of vetor) {
    console.log(item);
}

Nesta forma, chamada for…of, o laço percorre objetos de forma iterativa e crescente, chamando a função personalizada com instruções a serem executadas para o valor de cada objeto.


TERCEIRA FORMA (FOR…IN)

// O laço de repetição for...in percorre de forma iterativa e crescente
// e retornará quais são as posições em que os valores se encontram no vetor
let vetor=[11, 22, 33, 44];
for (const item in vetor) {
    console.log(item);
}

Na chamada for…in, o laço de repetição irá iterar sobre as propriedades do objeto de modo arbitrário. O loop irá iterar sobre todas as propriedades do próprio objeto, enumerando-as. Em suma, este laço enumerará quantas posições estão dispostas no vetor, retornando as suas posições.


QUARTA FORMA (FOREACH)

// O laço forEach usará de forma iterativa uma função
// para retornar os valores do vetor.
vetor.forEach(item => {
    console.log(item);
});

O laço forEach funciona de maneira semelhante ao laço forof, pois, de maneira iterativa e crescente, percorre os itens do laço e retorna os valores do vetor.

Como extrair um e-mail de uma String

Para extrair e-mails de uma string com JavaScript, ou qualquer outra linguagem, pode ser uma tarefa bem extensa devido a diversas conferencias que precisariam ser feitas para saber se aquele trecho é um e-mail

Por exemplo, você poderia ter algo do tipo:

let text = '@rediffmail.com blablabla farkal@gmail.com teste@@@ rodnsdfald ferdfnson <rfernsdfson@gmal.com> Affdmdol Gondfgale gyfanamosl@gmail.comtruform techno pidfpinfg@truformdftechnoproducts.com "NiTsdfeSh ThIdfsKaRe"';

let listaPalavras = text.split(" ");

let listaEmails = [];

listaPalavras.forEach((palavra) =>{
    if(palavra.includes("@")){
        listaEmails.push(palavra);
    }
});

console.log(listaEmails);

Poderíamos ter uma lista de e-mails filtrada com base no @. Mas dai você pode se perguntar se “@Joao” entre outras possíveis variações tanto devido ao conteúdo do texto quanto a possíveis erros de digitação. Com isso podemos acabar tendo um código como o abaixo:

let text = '@rediffmail.com blablabla farkal@gmail.com teste@@@ rodnsdfald ferdfnson <rfernsdfson@gmal.com> Affdmdol Gondfgale gyfanamosl@gmail.comtruform techno pidfpinfg@truformdftechnoproducts.com "NiTsdfeSh ThIdfsKaRe"';

let listaPalavras = text.split(" ");

let listaEmails = [];

listaPalavras.forEach((palavra) =>{
    if(palavra.includes("@") 
        && palavra[0] != "@" 
        && palavra.includes(".co")
        && palavra.includes(palavra.substr(0, palavra.indexOf("@"))) != "!"){
        listaEmails.push(palavra);
    }
});

console.log(listaEmails);

E isso é só o começo, estre IF teria que ser muito maior.

Mas existe uma solução usando REGEX (conheça o Regex aqui) que faz diversas conferencias ao mesmo tempo e permite a extração em poucas linhas. Veja o exemplo:

let text = '@rediffmail.com blablabla farkal@gmail.com teste@@@ rodnsdfald ferdfnson <rfernsdfson@gmal.com> Affdmdol Gondfgale gyfanamosl@gmail.comtruform techno pidfpinfg@truformdftechnoproducts.com "NiTsdfeSh ThIdfsKaRe"';

let listaEmails = text.match(/([a-zA-Z0-9.-]+@[a-zA-Z0-9.-]+\.[a-zA-Z0-9._-]+)/gi);

console.log(listaEmails);

Espero que este snippet ajude mais alguém como me ajudou. Deixe sua duvida ou comentário na sessão abaixo caso você tenha notado algo que possa melhorar ou caso esses snippet ajudou você

Introdução ao Node.js

Neste post, estarei falando resumidamente sobre o que é o NodeJS, como configura-lo, alguns pontos básicos importantes e como executar um Olá Mundo.

O que é o Node.js?

O Node.js é um interpretador de código aberto do JavaScript para execução no servidor. Seu objetivo é ajudar programadores na criação de aplicações de alta escalabilidade, com códigos capazes de manipular milhares de conexões simultâneas. Criado em 2009, ele é baseado no interpretador do V8 JavaScript Engine que é um interpretador open source implementado pelo Google em C++.

Como instalar e executar o Node.js

Para começar a desenvolver com Node.js pode-se baixar a versão mais recente no site: https://nodejs.org. Após baixar e instalar ele, é bem fácil iniciar um projeto. Para configurar um projeto faça o seguinte:

  1. Abra o terminal do Node
  2. Acesse (crie se não tiver feito) a pasta que você quer colocar seu projeto
  3. Digite npm init
  4. O node irá lhe perguntar diversos dados para a criação do projeto. Caso queira deixar a configuração padrão, basta ir apertando enter até o fim. Você terá deverá ter uma lista igual a está:

    Ou caso você tenha colocado algum valor, pode ficar parecido com
  5. O node após o License, o node irá criar e exibir um arquivo Json similar a este

    Basta apertar OK
  6. Agora sua pasta conterá um projeto com um arquivo chamado package.json com os dados do objeto acima
  7. Sem fechar o terminal (ou abrindo o terminal de sua IDE/Editor) abra o projeto no e crie dentro dele o arquivo index.js com o seguinte código:
    console.log("Olá Mundo");
  8. Não esqueça de salvar o arquivo.
  9. Por último, no terminal digite node index.js e você deverá ver a frase “Olá Mundo”.

Com isso concluímos o tutorial de introdução ao node.js e como rodar um olá mundo. Espero que a postagem tenha ajudado e caso alguém queira aprender o setup de algo mais complexo, escreva nos comentários abaixo.