Exercício Fácil: Do…While

Você pode executar o mesmo código várias vezes usando o loop while.

O loop Do..While executa primeiro o código dentro do loop, para depois executar o “while” com a condição especificada. Veja este exemplo:

let nossoArray = [];
let i = 0;

do {
  nossoArray.push(i);
  i++;
} while (i < 5);

Este loop retornará um vetor com resultado : [0, 1, 2, 3, 4]. Ele difere do loop while normal que possui a condição especificada no início do loop.

Este é um loop while normal que executará enquanto a variável i for menor que 5:

let nossoArray = [];
let i = 0;

while (i < 5){
  nossoArray.push(i);
  i++;
}

Observe que inicializamos o valor de i como 5. Quando executamos a próxima linha, notamos que i não é menor que 5. Portanto, não executamos o código dentro do loop. O resultado disso é que o vetor terminará com nada sendo adicionado a ele, portanto continuará vazio.

Agora, façamos o mesmo com o do…while:

let nossoArray = [];
let i = 5;

do {
  nossoArray.push(i);
  i++;
} while (i < 5);

Nesse caso, inicializamos o valor de i como 5, assim como no exemplo anterior. Quando chegamos à proxima linha, não há verificação do valor de i. Portanto, vamospara o código dentro do loop e executamos. Adicionaremos um elemento ao vetor e incrementaremos antes de chegar à verificação da condição. Então, quando verificamos se i < 5, vemos que agora i é 6, que falha na verificação da condicional. Então, saímos do loop e terminamos. O valor de retorno será [5]. O do…while garante que o código dentro do loop seja executado pelo menos uma vez.

EXERCÍCIO:

Altere o loop while no código para um loop do…while, para que adicione o número 10 para meuVetor e o i será 11 quando seu código finalizar.

REQUISITOS:

  • Você deve usar um loop do…while para este exercício;
  • meuVetor deve ser igual a [10];
  • i deve ser igual a 11.

Você pode visualizar o resultado no código abaixo:

let meuArray = [];
let i = 10;

// Altera o código apartir desta linha
do {
  meuArray.push(i);
  i++;
} while (i < 11) ;

Gostou deste exercício? Digite seu resultado nos comentários!

JavaScript: Campos privados, classes estáticas e mais

Embora as classes estejam disponíveis para o JavaScript desde o ES2015, elas não incluem campos e métodos privados. Esses recursos foram descartados durante o release inicial devido a divergências no comitê do TC39. Três rascunhos de especificações pretendem levar esses recursos às classes JavaScript em um futuro próximo.

Depois que essas especificações forem formalmente aceitas, os campos e métodos privados poderão ser definidos usando o sinal de hash ‘#’. A decisão de usar o sinal de hash em vez do sublinhado mais tradicional ‘_’ foi tomada para evitar alterações nas bibliotecas existentes, que atualmente marcam os campos privados dessa maneira.

Isso pode parecer contra intuitivo, no entanto, apesar das bibliotecas marcarem campos ou métodos como privados usando o sublinhado, os desenvolvedores de sinal ainda os usam. Transformar essas variáveis em variáveis verdadeiramente privadas pode interromper vários aplicativos e, portanto, retardar a adaptação das novas especificações.

O problema pode ser demonstrado por uma anedota do React, que teve que recorrer a alguns nomes de variáveis bastante contundentes para impedir que os desenvolvedores os usassem (apesar de serem marcados como privados), como ‘_SECRET_DOM_DO_NOT_USE_ORYOU_WILL_BE_FIRED’. (Lê-se _DOM_SECRETO_NAO_USE_OU_VOCE_SERA_DEMITIDO ).

Cada uma das 3 propostas do TC39 aborda um aspecto diferente de campos e métodos privados nas classes. No entanto, deve ser seguro tratá-los como uma única proposta, pois provavelmente serão adicionados ao JavaScript ao mesmo tempo. As propostas são:

Declaração de campos da classe

Atualmente não é possível definir campos (variáveis) direto na classe. Ao invés disso, os desenvolvedores precisam fazê-lo diretamente no construtor da classe.

class Counter { 
  constructor() { 
    this.xValue = 0; 
  } 
}

A proposta pretende adicionar esta habilidade para escrever os campos diretamente na definição da classe.

class Counter { 
  xValue = 0;
  #yValue = 0;
  constructor() { }
}

Criação de métodos privados e de getter e setters privados para as classes.

Esta proposta pretende permitir a adição de métodos privados e o uso de getter e setter privados.

class Counter { 
  get #x() { return #xValue; } 
  set #x(value) { }

  #clicked() { } 
}

Funcionalidades de classes estáticas (static).

Esta proposta define como será implementado a funcionalidade de campos e métodos estáticos, podendo ser públicos ou privados.

class CustomDate { 
  static public() = {} 
  static #private() = {} 
}

Para mais informações veja o post original no link abaixo:

Fonte: https://www.infoq.com/news/2019/10/javascript-private-class-fields/

Exercício Intermediário: multiplicando em FOR aninhado.

Uma tarefa muito comum em JavaScript é percorrer o conteúdo de um vetor. Você pode utilizar o loop FOR para isso. Lembre-se de que os vetores começam com o índice em 0, o que significa que o último elemento do vetor é o comprimento -1.

Se você tem um vetor multidimensional, você pode utilizar a mesma lógica do laço for para percorrer os vetores e os sub-vetores. Este é um exemplo:

let arr = [[1,2], [3,4], [5,6]];
for (let i=0; i < arr.length; i++) {
  for (let j=0; j < arr[i].length; j++) {
    console.log(arr[i][j]);
  }
}

Este laço de repetição aninhado percorre cada sub-elemento do sub-vetor por vez. Observe que, para percorrer o loop interno, estamos verificando o comprimento de arr[i], visto que arr[i] é, em si, um vetor.

EXERCÍCIO:

Modifique a função multiplicarTudo de modo que multiplique a variável produto por cada número nos sub-vetores do array:

function multiplicarTudo(arr) {
  let produto = 1;
  // Altere o código a partir desta linha

  // Altere o código até esta linha.
  return produto;
}

// Modifique os valores para testar o seu código.
multiplicarTudo ([[1,2],[3,4],[5,6,7]]);

RESULTADOS:

  • A função multiplicarTudo([[1],[2],[3]]) deve retornar 6;
  • A função multiplicarTudo([[1,2],[3,4],[5,6,7]]) deve retornar 5040;
  • A função multiplicarTudo([[5,1],[0.2,4, 0.5],[3,9]]) deve retornar 54;

Gatsby recebe US$ 15 milhões em financiamento

O Gatsby anunciou que levantou um financiamenteo de US$ 15 milhões para impulsionar a modo como reinventou o desenvolvimento de sites.
O Gatsby é uma estrutura de código aberto gratuita baseada em React. Com uma plataforma de malha de conteúdo, ela auxilia na criação de sites e aplicativos extremamente rápidos.

Acreditando que a arquitetura de sites está sendo reinventada, o Gatsby proporciona a criação de sites rápidos, seguros e estáveis. Ele retira uma grande parte da complexidade do desenvolvimento de sites, tornando o processo incrível e divertido.
Ele se esforça para fornecer dados e códigos divididos imediatamente, otimizando as imagens e carregando a página com seus elementos críticos primeiro.

Com uma malha de conteúdo, o Gatsby preserva os fluxos de trabalho dos criadores de conteúdo e oferecem acesso à serviços em nuvem sem integração manual. Como a web está migrando para uma arquitetura cada vez mais dissociada, o Gatsby é o que torna a experiência mais incrível.
Sendo uma ferramente de código aberto, o Gatsby contribui muito para a comunidade, ajudando a tornar a web um espaço acessível e aberto. Com os financiamentos mais recentes, mais de US$ 3 milhões por ano serão investidos em código aberto, produzindo plugins e materiais de aprendizado.

As tendências que impulsionam a web são três principais, como o Gatsby acredita: Arquitetura dissociada, com serviços modulares especializados; Ecossistema de JavaScript em amadurecimento para criar sites escaláveis e com excelência em qualidade e a necessidade de criar experiências mais atraentes para os usuários.
Atualmente existem mais de 35 membros atuando em código aberto, escrevendo documentações e tutoriais, criando ferramenta de design e construção de sites de última geração.

Para mais informações veja o post original no link abaixo:
Fonte: https://www.infoq.com/news/2019/10/react-gatsby-raises-15m-usd/

Gatsby Blog: https://www.gatsbyjs.org/blog/2019-09-26-announcing-gatsby-15m-series-a-funding-round/

Gostou desta notícia? Comente abaixo!

Criando Captcha com JavaScript

Neste artigo, ensinarei como criar um captcha simples utilizando JavaScript puro e com poucas linhas de código.

Requisitos:

Para criar este captcha, você precisará de:

  • Algumas imagens para usar como captcha;
  • Baixar o arquivo HTML com os campos necessários para procedimento do captcha.

Vamos iniciar!

Podemos começar o nosso captcha criando um arquivo chamado captcha.js

Neste arquivo, iremos criar três variáveis:

  • Uma variável chamada random;
  • Uma variável chamada imgCaptcha;
  • Uma variável chamada imgName.
let random;
let imgCaptcha;
let imgNome;

Agora, iremos criar um objeto chamado testeCaptcha que irá conter:

  • O nome do arquivo de cada imagem utilizada como captcha;
  • Uma string que conterá os números e letras da sua imagem de captcha.
let testeCaptcha = {
    captcha1: "jnjd5",
    captcha2: "9lup6",
    captcha3: "xt17y",
    captcha4: "iu1it",
};

É importante lembrar de salvar as imagens em uma mesma extensão, pois as imagens serão importadas de modo aleatório. Também é importante colocar os nomes em sequência. Por exemplo: captcha1.png, captcha2.png…

Adicionamos um evento click ao botão do nosso HTML. Para isso, utilizaremos o addEventListener e chamaremos a função validaCaptcha() que será criada adiante.

document.getElementById("enviaCaptcha").addEventListener("click", validaCaptcha);

O próximo passo agora é criar uma função. A nossa função se chamará validaCaptcha(). Esta função deverá ter:

  • Uma variável que receberá o valor digitado no input pelo usuário;
  • Uma condicional, que irá testar se: O valor digitado pelo usuário é igual a algum dos valores do objeto testeCaptcha. Se este valor digitado for igual ao valor do atributo gerado de forma aleatória, mostre com um alert: “Captcha Correto”. Senão, chame a função recaptcha(), que será explicada no próximo passo.
function validaCaptcha() {
let inputCaptcha = document.getElementById("inputCaptcha").value;
    // testeCaptcha[imgNome]: conteúdo do captcha1, 2, 3... 
    if (inputCaptcha == testeCaptcha[imgNome]) {
        alert("Captcha Correto!");
    } else {
        recaptcha();
    }
}

Para criar a função recaptcha(), precisaremos que:

  • A variável random receba um Math que gere números aleatórios de acordo com a quantidade de imagens que temos. Por exemplo, se temos 5 imagens, o random deverá gerar números aleatórios de 1 a 5.
  • A variável imgCaptcha receba a imagem que foi gerada.
  • A variável imgName receba a string que você colocou como nome das imagens + a variável random. Por isso, devemos colocar nomes idênticos nas imagens, mudando apenas seu número.
  • Adicionar na variável imgCaptcha.src o caminho da imagem + imgName + sua extensão. Por exemplo: “captcha/”+imgName+”.png”;
function recaptcha() {
    random = Math.floor(Math.random() * 4) + 1;
    imgCaptcha = document.getElementById("imagemCaptcha");
    imgNome = "captcha" + random;
    imgCaptcha.src = "img/" + imgNome + ".png";
}

Agora devemos chamar a nossa função recaptcha():

recaptcha();

Pronto, está criado o nosso verificador de captcha simples! Você pode inserí-lo dentro de uma função anônima que será chamada no momento que a tela for carregada, utilizando o addEventListener(“load”). Veja o código completo abaixo:

window.addEventListener("load", function () {

    let random;
    let imgCaptcha;
    let imgNome;

    let testeCaptcha = {
        captcha1: "jnjd5",
        captcha2: "9lup6",
        captcha3: "xt17y",
        captcha4: "iu1it",
    };

    document.getElementById("enviaCaptcha").addEventListener("click", validaCaptcha);

    function validaCaptcha() {
        let inputCaptcha = document.getElementById("inputCaptcha").value;
        // testeCaptcha[imgNome]: conteúdo do captcha1, 2, 3... 
        if (inputCaptcha == testeCaptcha[imgNome]) {
            alert("Captcha Correto!");
        } else {
            recaptcha();
        }
    }

    function recaptcha() {
        random = Math.floor(Math.random() * 4) + 1;
        imgCaptcha = document.getElementById("imagemCaptcha");
        imgNome = "captcha" + random;
        imgCaptcha.src = "img/" + imgNome + ".png";
    }
    
    recaptcha();
});

Código HTML necessário:

<!DOCTYPE html>
<html>
<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>Captcha com JavaScript</title>
</head>
<body>
    <img id="imagemCaptcha">
    <input id="inputCaptcha" type="text">
    <button id="enviaCaptcha">Enviar</button>
    <script src="scripts.js"></script>
</body>
</html>

Imagens disponíveis:

Gostou deste artigo? Comente abaixo!

Exercício Fácil: Soma de itens do vetor

Neste exercício, você terá que somar os valores de um vetor até a metade de seu tamanho e colocar a soma em um índice de um novo vetor.

Faça a soma também dos valores dos itens do vetor após a metade de seu tamanho. Coloque a soma em um índice do novo vetor.

Exemplo:

let vetor = [10, 20, 30, 40, 50, 60, 70, 80, 90];

Neste exemplo, temos um vetor de tamanho 9. Sabemos que a metade de 9 é 4.5, logo, devemos pegar todos os valores contidos em cada elemento que seja menor que a metade do tamanho do vetor. Neste caso, teremos a soma dos valores 10 + 20 + 30 + 40, que resulta em: 100.

O valor obtido, 100, deverá ser inserido na primeira posição de um novo vetor, que deverá ser criado.

let novoVetor = [];

Partindo para a próxima etapa do nosso exercício, devemos realizar a soma dos valores nos elementos restantes. Para isso, você deve realizar a soma dos elementos e inserir o resultado no índice do novo vetor. A soma dos elementos deve ser 50 + 60 + 70 + 80 + 90, que resulta em: 35.

O valor obtido, 350, deverá ser inserido na segunda posição do nosso novo vetor, que foi criado anteriormente.

O seu resultado deverá ser algo parecido como:

novoVetor = [100, 350];

Utilize o console.log() para mostrar o seus resultados.

DICA:

Para chegar no resultado correto, utilize o vetor.length -1 na sua condicional.

Você pode realizar este exercício da maneira que lhe convém, mas aconselhamos a utilizar uma estrutura condicional dentro de seu loop de repetição. Mas nada impede de você utilizar suas próprias maneiras para resolução deste exercício.

Você pode realizar a nossa resolução do exercício abaixo:

let vetor = [10, 20, 30, 40, 50, 60, 70, 80, 90];

let novo = [0, 0];

for (let indice = 0; indice < vetor.length; indice++) {
           
    if (indice < ((vetor.length-1) / 2)){
        novo[0] += vetor[indice];
           
    } else {
        novo[1] += vetor[indice];
    }
            
}
console.log(novo);

Gostou deste exercício? Comente o seu resultado e tire suas dúvidas!

 

Conheça o BigInt, a nova implementação do ECMAScript 2020

BigInt é um objeto nativo do JavaScript que fornece um modelo de representação de números inteiros maiores que , que é o maior número que o JavaScript consegue representar, com exatidão, utilizando o tipo primitivo Number.

Sintaxe:

A sintaxe do BigInt é:

BigInt(valor);

Onde:

  • valor: é o valor numérico do objeto que irá ser criado. Este pode ser uma string ou um número inteiro.

É importante salientar que o BigInt() não é usado com o operador new.

O BigInt é criado com a simples acrescentação de um “n” ao final de um inteiro literal – 10n – ou chamando a função BigInt();

const theBiggestInt = 9007199254740991n;

const alsoHuge = BigInt(9007199254740991);
// 9007199254740991n

const hugeString = BigInt("9007199254740991");
// 9007199254740991n

const hugeHex = BigInt("0x1fffffffffffff");
// 9007199254740991n

const hugeBin = BigInt("0b11111111111111111111111111111111111111111111111111111");
// 9007199254740991n

O BigInt difere-se do Number em alguns assuntos importantes. Por exemplo:

  • Ele não pode ser usado com métodos no objeto Math;
  • Ele não pode ser misturado em operações ou qualquer instância de Number. Eles devem ser manipulados com o mesmo tipo.
  • A precisão de BigInt pode ser perdida com a conversão de valores para Number.

Se você quiser realizar alguns testes, você pode:

  • Testando com typeof:
typeof 1n === 'bigint'; // true

typeof BigInt('1') === 'bigint'; // true
  • Se estiver envolvido em um Object, o BigInt será considerado como um tipo normal de “object”:
typeof Object(1n) === 'object'; // true

Você também pode realizar operações com BigInt ou com BigInt envolvido em objeto:

const antigoMaximoInt = BigInt(Number.MAX_SAFE_INTEGER);
// 9007199254740991

const maximoMaisUm = antigoMaximoInt + 1n;
// 9007199254740992n

const oFuturo= antigoMaximoInt + 2n;
// 9007199254740993n, isso funciona agora!

const multiplicando = antigoMaximoInt * 2n;
// 18014398509481982n

const subtraindo = multiplicando – 10n;
// 18014398509481972n

const modulo = multiplicando % 10n;
// 2n

const bigN = 2n ** 54n;
// 18014398509481984n

bigN * -1n
// –18014398509481984n

Observação:

O operador / também funciona. No entanto, se os números forem BigIntS e não BigDecimalS, a operação será arredondada para zero, o que não nos trará nenhum valor fracional.

const divisao = 4n / 2n;
// 2n

const arredondado = 5n / 2n;
// 2n, e não 2.5n

É importante salientar que o BigInt não é estritamente igual a um Number, mas eles podem ser comparados normalmente.

0n === 0;
// false

0n == 0;
// true

1n < 2;
// true

2n > 1;
// true

2 > 2;
// false

2n > 2;
// false

2n >= 2;
// true

O BigInt se comporta como um número quando é convertido em um booleano, e também pode ser usado com operadores lógicos , também dentro de uma estrutura condicional.

if (0n) {
    console.log("Olá, você está dentro do IF");
} else {
    console.log("Olá, você está dentro do ELSE");
}

0n || 12n;
// 12n

0n && 12n;
// 0n

Boolean(0n);
//  false

!0n;
// true

Propriedades:

BigInt.prototype;

Permite a adição de propriedades a um objeto BigInt. Todas as instâncias BigInt são herdadas do BigInt.prototype. O objeto de protótipo do construtor BigInt pode ser modificado para afetar todas as instâncias do BigInt.

Gostou deste artigo? Deixe seu comentário abaixo!

Array Methods: Conheça os métodos de vetores.

Neste artigo, irei mostrar alguns dos métodos para manipulação de vetores mais utilizados no JavaScript. Existem outros métodos que serão abordados em próximos artigos.

concat():

Une dois ou mais vetores e retorna uma cópia dos vetores unidos.

Sintaxe:
0045vetor1.concat(vetor2, vetor3, ..., vetorX);
Exemplo:
let meninas = ["Cecilia", "Luana"];
let meninos = ["Emilio", "Tobias", "Leonardo"];
let adulto = ["Roberta"];
let pessoas = meninas.concat(meninos, adulto); 
console.log(pessoas);

copyWithin():

Copia elementos do vetor dentro do vetor, para e de posições especificadas. Este método nunca adicionará mais itens ao vetor. Importante: este método sobrescreve o vetor original.

Sintaxe:
vetor.copyWithin(alvo, inicio, fim);
Exemplo:
let fruits = ["Banana", "Orange", "Apple", "Mango", "Kiwi", "Papaya"];
fruits.copyWithin(2,0,2);
// ["Banana", "Orange", "Banana", "Orange", "Kiwi", "Papaya"]

entries():

Retorna um objeto Array Iterator com pares de chave/valor. Para cada item no vetor original, o novo objeto de iteração conterá um vetor com o índice como chave e o valor do item como valor.

Sintaxe:
vetor.entries();
Exemplo:
let fruits = ["Banana", "Orange", "Apple", "Mango"];
let f = fruits.entries();
for (x of f) {
    console.log(x);
}
// [0, "Banana"]
// [1, "Orange"]
// [2, "Apple"]
// [3, "Mango"]

filter():

Cria um novo vetor com todos os elementos de um vetor que passam no teste.

Sintaxe:
vetor.filter( function(valorAtual, index, vet), thisValue);
Onde:
  • function(valorAtual, index, vet): é uma função que irá ser executada para cada elemento no vetor. Possui os argumentos: valorAtual, index e vet.
  • thisValue: um parâmetro opcional. É Um valor a ser passado para a função a ser usado como seu valor “this”. Se este parâmetro estiver vazio, o valor “undefined” será passado como seu valor “this”.
Exemplo:
let idades = [32, 33, 16, 40];
function verificaAdulto(idade) {
  return idade >= 18;
}
console.log(idades.filter(verificaAdulto));
// [32, 33, 40]

map():

O método map() cria um novo vetor com os resultados da chamada de uma função para cada elemento do vetor. Ele chama a função fornecida uma vezpara cada elemento em um vetor, em ordem.

Sintaxe:
vetor.map(function(function(valorAtual, index, vet), thisValue);
Onde:
  • function(valorAtual, index, vet): Uma função a ser executada para cada elemento na matriz. Argumentos de função: valorAtual, index, vet.
  • thisValue: um parâmetro opcional. É Um valor a ser passado para a função a ser usado como seu valor “this”. Se este parâmetro estiver vazio, o valor “undefined” será passado como seu valor “this”.
Exemplo:
let numbers = [4, 9, 16, 25];
console.log(numbers.map(Math.sqrt));
// [2, 3, 4, 5]

sort():

O método sort() classifica os itens de um vetor. A ordem de classificação pode ser alfabética, numérica e crescente ou decrescente. Por padrão, o sort() classifica os valores por ordem alfabética e crescente. Isso funciona bem para sequencias de caracteres. No entanto, se os números forem classificados como sequencias de caracteres, “25” será maior que “100”, porque “2” será maior que “1”. Por esse motivo, o método sort() produzirá um resultado incorreto ao classificar números.

Sintaxe:
vetor.sort(funcaoComparacao);
Onde:
  • funcaoComparacao: Opcional, é uma função que define uma ordem de classificação alternativa. Esta função deverá retornar um valor negativo, zero, ou positivo, dependendo dos argumentos, como:

function (a, b) {return a-b}.

Quando comparamos 40 e 100, o método sort() chama a função de comparação function(40, 100). A função irá calcular 40 – 100 e retornará -60 (um valor negativo). A função sort lerá que 40 é um valor menor que 100.

Exemplo:
let fruits = ["Banana", "Orange", "Apple", "Mango"];
console.log(fruits.sort());
// ["Apple", "Banana", "Mango", "Orange"]

reduce():

O método reduce() reduz o vetor para um único valor; Ele executa uma função fornecida para cada valor do vetor (da esquerda para a direita). O valor de retorno da função é armazenado em um acumulador (resultado / total).

Sintaxe:
vetor.reduce(function(total, valorAtual, indiceAtual, vet), valorInicial);
Onde:
  • function(total, valorAtual, indiceAtual, vet): É uma função a ser executada para cada elemento no vetor.
  • valorInicial: Opcional, um valor a ser passado para a função como o valor inicial.
Exemplo:
let numbers = [175, 50, 25];
function myFunc(total, num) {
  return total - num;
}
console.log(numbers.reduce(myFunc));
// 100

join():

O método join() retorna o vetor como uma sequência. Os elementos serão separados por um separador especificado. O separador padrão é a vírgula (,). Este método não altera o vetor original.

Sintaxe:
vetor.join(separador);

O separador pode ser omitido, e será usado por padrão a vírgula (,).

Exemplo:
let fruits = ["Banana", "Orange", "Apple", "Mango"];
console.log(fruits.join(" and "));
// Banana and Orange and Apple and Mango

slice()

O método slice() retorna os elementos selecionados em um vetor, como um novo objeto de vetor. Seleciona os elementos que começam no argumento inicial especificado e terminam no, mas não incluem, o argumento final especificado.

Sintaxe:
vetor.slice(inicio, fim);
let fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
let citrus = fruits.slice(1, 3);
console.log(citrus);
// ["Orange", "Lemon"]

Gostou deste artigo? Comente abaixo outros métodos de vetores JavaScript!

JavaScript Básico: Break e Continue

 

Você já conhece o break e continue e suas utilidades? Conheça neste artigo:

BREAK:

O comando “break” serve para encerrar a leitura. O break é um comando que podemos utilizar quando queremos parar/encerrar o laço de repetição na hora. A instrução break interrompe o laço e continua executando o código após o loop (se houver).

Exemplo:

let carros = ["BMW", "Volvo", "Saab", "Ford"];

list: {
    console.log(carros[0]);
    console.log(carros[1]);
    break list;
    console.log(carros[2]);
    console.log(carros[3]);
}

CONTINUE:

Com este comando, é possível iniciar a próxima repetição do loop. A instrução continue interrompe uma iteração (no laço de repetição), se uma condição específica ocorrer, e continua com a próxima iteração no laço de repetição.

for (let i = 1; i < 10; i++) {
    if (i === 3) {
        continue;
    }
    console.log("O número atual é: " + i);
}

Com a instrução continue, você poderá utilizá-la para apenas ignorar  uma iteração de loop.

A instrução break pode ser utilizada para pular de um loop ou de um switch. Ela pode ser usada para pular qualquer bloco de código.

Exercício 1:

Crie um laço de repetição FOR. Este laço deverá começar a iterar no número 1. Enquanto o índice for menor que 10, o laço deverá continuar iterando.

Com o laço criado, cria um estrutura condicional que, utilizando o comando break, pare a iteração quando ela alcançar o valor 5. Caso esta condição seja atendida, mostre os números utilizando o console.log.

Exercício 2:

Crie um vetor que contenha os seguintes nomes: “André”, “Ana Paula”, “Júlio”, “Marcela”, “Rubem”. Utilize o laço de repetição FOR para percorrer esta lista. Quando a leitura for igual a “Júlio”, utilize o comando continue. Ele irá exibir todos os outros nomes deste vetor. Utilize o console.log para logar os dados no console.

Gostou deste artigo? Comente abaixo!

Conheça a CryptoCoinJS, uma biblioteca JavaScript para Criptomoedas.

CryptoCoinJS é um projeto JavaScript que ajuda você a interagir com diversas criptomoedas existentes na atualidade, como o famoso Bitcoin, Litecoin, Dogecoin, entre muitas outras. A maioria dos módulos é totalmente compatível com o seu navegador e com o Node.js. Naturalmente, os módulos que fazem interface diretamente com os nós de pares não serão executados no navegador.

Princípios da biblioteca:

Acreditando na filosofia Node.js e UNIX – a idéia de criar pequenos componentes que fazem uma coisa e fazem bem. Escrever software dessa maneira permite que os indivíduos usem e contribuam com muito mais eficácia do que escrevendo uma biblioteca monolítica. O CryptoCoinJS acredita que as pessoas são mais importantes que o código e, portanto, é fundamental escrever um código que seja fácil de ler, fácil de documentar cada módulo com a API e exemplos, e esse código é o inimigo 1 2.

Escrever testes é uma das melhores maneiras de comunicar expectativas entre desenvolvedores. Se a documentação é uma maneira de se comunicar para o consumidor do seu módulo, os testes são uma maneira de se comunicar entre os desenvolvedores.

Plataformas:

O CryptoCoinJS está focado no Node.js e no navegador usando o Browserify. Não há suporte a navegadores herdados, ou seja, se o seu navegador não suporta ECMAScript 5 (2009 – 2010) e não suporta window.crypto.getRandomValues​​(), alguns dos módulos podem não funcionar.

Começando:

O CryptoCoinJS é escrito em JavaScript puro e pode ser usado no servidor (Node.js) e no cliente (navegador moderno> 2010).

A primeira e provavelmente a mais óbvia é que você precisará de um editor de texto. Sublime Text , Github Atom ou Vim farão uma boa escolha.

O Node.js é executado no Windows, Mac OS X ou Linux. É muito fácil de instalar, basta acessar nodejs.org/download e executar o instalador para sua plataforma de escolha. O Node.js agrupa o npm que, estranhamente, não representa o Node.j Package Manager, apesar de ser seu único objetivo.

Continue lendo “Conheça a CryptoCoinJS, uma biblioteca JavaScript para Criptomoedas.”