JavaScript Básico: For

Você sabe utilizar o laço de repetição FOR em JavaScript?

O For é um dos laços de repetições que tem a função de executar uma instrução “x” determinada quantia de vezes. Com ele, podemos:

  • Percorrer listas inteiras
  • Acessar e alterar valores nestas listas
  • Descobrir o valor e índice de cada elemento contido nas listas
  • Entre outras funções.

Existem vários tipos de laços de repetição, mas eles realizam a mesma coisa: repetir uma determinada ação. Neste artigo veremos exclusivamente o laço FOR.

O laço FOR é repetido até que uma condição seja especificada. Por exemplo:

Iniciar a contagem de elementos de um vetor, começando no índice zero até o último índice (este vetor contém um total 5 índices):

let vetor = [0, 1, 2, 3, 4];
for (let indice = 0; indice <= 4; indice++){
    console.log(vetor[indice]);
}
// 1
// 2
// 3
// 4

Sintaxe:

for ([inicialização]; [condição]; [expressão final]){
    declaração;
}

Onde:

  • Inicialização: é uma expressão ou declaração de variáveis. É usada para iniciar o contador de variáveis.
  • Condição: é a expressão que será avaliada antes da iteração do loop. Se esta expressão for TRUE, a declaração será executada. É um teste de condição. Enquanto a condição for atendida, o seu código será executado.
  • Expressão final: é validada ao final de cada iteração que acontece no laço FOR. Utilizada para incrementar ou atualizar a variável. Um exemplo prático é a varredura de elementos que vimos no exemplo acima.
  • Declaração: é o trecho de código que será executado caso a condição seja verdadeira.

Exercício 1:

Crie um algoritmo usando o for que leia uma lista. Mostre no console apenas os números pares. Esta lista deve ser assim: [1, 2, 3, 4, 5, 6, 7, 8, 9];

Exercício 2:

Utilizando a lista do exercício anterior, crie um algoritmo que mostre de maneira decrescente os elementos desta lista.

Resolva estes exercícios para melhor aprendizado!

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

Curso Grátis de JavaScript by MundoJS

logo

Nosso primeiro curso de JavaScript está no ar, segue o link:

Instrodução ao JavaScript

Esperamos que gostem e nos mande uma mensagem aqui no site se você tiver alguma dúvida ou sugestão.
Para quem é o curso: Todo mundo, por favor se inscrevam… kkk

Descrição

O curso é para iniciantes no mundo da programação. Ele ensinará o conteúdo do primeiro semestre de algoritmos da maioria das faculdades, mas de uma forma mais sucinta para você não perder tempo. Conforme tivermos chance, iremos adicionar mais exercícios relevantes e ir atualizando qualquer problema que vocês nos informarem.

Neste curso você aprenderá os fundamentos de JavaScript necessários para entender os algoritmos criados com a linguagem. Você não precisa ter qualquer conhecimento técnico e se já souber o básico de algoritmos, terá bastante facilidade em entender todo o conteúdo.

Ao término dele você saberá mais sobre

  • Variáveis
  • Tipos de dados
  • If/Else
  • Switch
  • For
  • For Of
  • While
  • Do While

Como é grátis, convidamos todos a se inscreverem e nos darem sua opinião.

Bons estudos!!

Novidades no ECMAScript 2019 (ES2019)/ES10

A versão 72 do Chrome lançou alguns novos recursos interessantes do ES10:

.Flat():

O método flat() cria um novo vetor recursivamente com todos os elementos do sub-vetor concatenados nele até a profundidade especificada.

let vetor = [1, 2, 3, [4, 5, 6, [7, 8, 9, [10, 11, 12]]]];

vetor.flat();
// (7) [1, 2, 3, 4, 5, 6, Array(4)]

vetor.flat().flat();
// (10) [1, 2, 3, 4, 5, 6, 7, 8, 9, Array(3)]

vetor.flat().flat().flat();
//(12) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

vetor.flat(Infinity);
//(12) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

.flatMap():

O método flatMap() primeiramente mapeia cada elemento do vetor usando uma função e mapeamente para, em seguida, nivelar o resultado em um novo array. O flatMap é bastante útil, pois mescla um mapa seguido por um flat de profundidade 1 em um método mais eficiente.

let vetor = [1, 2, 3, 4, 5];

vetor.map(x => [x, x*2]);
// (5) [Array(2), Array(2), Array(2), Array(2), Array(2)]
// 0: (2) [1, 2]
// 1: (2) [2, 4]
// 2: (2) [3, 6]
// 3: (2) [4, 8]
// 4: (2) [5, 10]

vetor.flatMap(v=>[v, v*2]);
// (10) [1, 2, 2, 4, 3, 6, 4, 8, 5, 10]

Object.fromEntries():

O método Object.fromEntries() transforma uma lista de pares de valores-chave em um objeto.

Exemplo 1:

let obj = {
    chave1:'valor1',
    chave2:'valor2',
    chave3:'valor3'
}    

let entries = Object.entries(obj);

console.log(entries);
// (3) [Array(2), Array(2), Array(2)]0: (2) ["chave1", "valor1"]1: (2) ["chave2", "valor2"]2: (2) ["chave3", "valor3"]

let fromEntries = Object.fromEntries(entries);

console.log(fromEntries);
// {chave1: "valor1", chave2: "valor2", chave3: "valor3"}

Exemplo 2:

let entries  = new Map([
    ['nome', 'ben'],
    ['idade', 25]
]);    

Object.fromEntries(entries);
// {nome: "ben", idade: 25}

String.trimStart() & String.trimEnd():

O método trimStart() remove espaços em branco do início de uma string. O método trimEnd() remove espaços em branco do final de uma string.

let olaMundo = "     Olá Mundo!     ";

console.log(JSON.stringify(olaMundo.trimEnd()));
// "     Olá Mundo!"

console.log(JSON.stringify(olaMundo.trimStart()));
// "Olá Mundo!     "

Optional Catch Binding:

Permite que os desenvolvedores usem try / catch sem criar uma ligação não utilizada. Você pode fazer uso do catch block sem um parâmetro.

try {
    throw new Error("sem erro");
} catch {
    console.log("nenhum parâmetro no catch");
}
// nenhum parâmetro no catch

Antes era obrigatório usar parâmetro no catch block:

try {
    throw new Error ("Algum erro aleatório");
} catch(e) {
    console.log(e);
}    
// Error: Algum erro aleatório

Continue lendo “Novidades no ECMAScript 2019 (ES2019)/ES10”

QUnit.js: um framework para testes de unidade JavaScript.

Você sabe o que é o QUnit?

O QUnit é um framework para testes de unidade JavaScript poderoso e fácil de usar. É utilizado para testes em projetos jQuery, jQuery UI e jQuery Mobile e é capaz de testar qualquer código JavaScript genérico.

O QUnit foi originalmente desenvolvido por John Resig como parte do jQuery. Em 2008, ele recebeu sua própria home page, nome e documentação da API, permitindo que outras pessoas a utilizem para os testes. Anteriormente, o QUnit ainda dependia de jQuery, mas em 2009 isto foi corrigido, e agora o QUnit é executado de forma completamente autônoma. Os métodos de asserção do QUnit seguem a especificação CommonJS Unit Testing, que foi até certo ponto influenciada pelo QUnit.

Como começar?

Uma configuração mínima para um teste do QUnit:

<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width">
  <title>QUnit Example</title>
  <link rel="stylesheet" href="https://code.jquery.com/qunit/qunit-2.9.2.css">
</head>
<body>
  <div id="qunit"></div>
  <div id="qunit-fixture"></div>
  <script src="https://code.jquery.com/qunit/qunit-2.9.2.js"></script>
  <script src="tests.js"></script>
</body>
</html>

E o conteúdo do tests.js:

QUnit.test( "hello test", function( assert ) {
  assert.ok( 1 == "1", "Passed!" );
});

No node:

Instale o QUnit globalmente para poder usar o CLI:

$ npm install -g qunit

Crie arquivos de teste em um test directory e execute:

$ qunit

Você deve ver algo como:

TAP version 13
ok 1 Module > Test #1
ok 2 Module > Test #2
1..2
# pass 2
# skip 0
# todo 0
# fail 0

E é isso! Enquanto o QUnit procura por arquivos de teste “test”, você também pode coloca-los em qualquer lugar e, em seguida, especificar caminhos de arquivo ou expressões glob:

$ qunit 'tests/*-test.js'

Para ver as opções adicionais suportadas, basta executar:

$ qunit --help

No npm:

npm install --save-dev qunit

Para testar os recursos mais recentes e correções de bugs no QUnit, uma versão gerada automaticamente a partir do último commit para o repositório QUnit Git também está disponível para uso:

Para mais informações sobre o framework, acesse o site principal do QUnit no link: qunitjs.com/

Gostou deste artigo? Comente abaixo!

React avançado — Utilizando “props.children” como função de primeira classe

O coração do React são componentes. Você pode aninhar esses componentes do mesmo modo que você aninha tags HTML, o que torna tudo mais fácil quando escrevemos JSX, afinal, lembra muito o bom e velho HTML.

Quando eu comecei com React, eu pensei “Basta usar props.children e pronto. Eu sei tudo sobre o objeto .children”. Te digo, como eu estava errado! 🙂

Como estamos trabalhando com JavaScript, nós podemos mudar o .children. Nós podemos passar propriedades para ele, decidir se queremos que ele renderize algo ou não, usá-lo do jeito que quisermos. Vamos mergulhar no poder do .children em React!

Abaixo, segue os tópicos que iremos abortar nesse artigo:

Tabela de conteúdo:

  • Elementos filhos
  • Tudo pode ser um elemento filho
  • Função como elemento filho
  • Manipulando .children
  • Usando loops em .children
  • Contando .children
  • Convertendo .children em um array
  • Permitir apenas um elemento filho
  • Editando .children
  • Mudando as propriedades dos elementos filhos
  • Clonando imutavelmente os elementos filhos
  • É isso aí!

Elementos filhos

Vamos dizer que temos um componente , que contém componentes como elementos filhos. Usamos da seguinte maneira:

<Grid>
  <Row />
  <Row />
  <Row />
</Grid>

Demo: http://www.webpackbin.com/Ekg_vyjPz

Esses três componentes Row são passados para o Grid como props.children. Usando um container como expressão (expression container, termo técnico do JSX para os colchetes), componentes pais podem renderizar os elementos filhos:

class Fullstop extends React.Component {
  render() {
    return <h1>Hello world!</h1>
  }
}

Não importa quantos elementos filhos você passe, ele sempre irá renderizar “Hello world!”, e nada mais.

Nota: O h1 no exemplo acima (assim como todas as tags HTML primitivas), está renderizando seu elemento filho, nesse caso, o nó de texto “Hello world!”

Continue lendo “React avançado — Utilizando “props.children” como função de primeira classe”

React Native simplifica o desenvolvimento de aplicativos:

Há um número crescente de aplicativos incríveis e populares nas lojas de aplicativos que foram criadas com React Native, estes incluem: Facebook Ads Manager, Facebook Messenger, AirBnB, Bloomber, UberEats, Discord e Instagram.

O crescimento de aplicativos para dispositivos móveis.

A Statista, que é uma provedora de dados de mercado e consumidores, prevê que os aplicativos móveis gerarão receita global de aproximadamente US$ 189 bilhões até o ano 2020. O desenvolvimento de aplicativos móveis está aumentando à medida que aumenta a necessidade de aplicativos que ajudarão a simplificar a vida e o trabalho.

Com a crescente demanda por aplicativos, os desenvolvedores estão procurando modos de facilitar o trabalho. Ao mesmo tempo, as empresas exigem que seus aplicativos estejam disponíveis em todas as plataformas: Web, iOS, Android, entre outras. Este é um desafio, pois os desenvolvedores têm que projetar e desenvolver a mesma coisa para três plataformas diferentes.

Três aplicativos pelo preço de um.

Com React Native, eles não precisam mais criar três aplicações diferentes para Web,Android e iOS. Um aplicativo será executado em todas as três plataformas. É uma estrutura rápida e fácil baseada, em JavaScript usada para criar aplicativos nativos. Também é apoiado pelo Facebook com amplo apoio e contribuição da comunidade, bem como tutoriais e materiais de aprendizagem.

Isso torna extremamente fácil começar a usar o React Native. Também é fácil fazer a transição de nativo para reagir e vice-versa e isso pode ser feito a qualquer momento sem esforço, porque o React Native alinha-se às convenções da plataforma nativa. Mais importante, pode-se mudar de React Native para totalmente nativo com muito pouco esforço.

O CEO da BlueGrass Digital, Nick Durrant, diz que é definitivamente muito mais barato, fácil e rápido desenvolver aplicativos móveis no React Native:

“O React Native permite uma única base de código JavaScript para todas as plataformas. Isso facilita a manutenção do aplicativo com o mesmo processo de desenvolvimento para todas as plataformas e a reutilização do mesmo código. Isso significa menos recursos, não há necessidade de equipes de desenvolvimento separadas. ”

Continue lendo “React Native simplifica o desenvolvimento de aplicativos:”

Como fazer: Relógio com JavaScript

Aprenda neste artigo como fazer um relógio mostrando a sua hora atual, atualizando em tempo real as horas, minutos e segundos.

Date():

Objetos Date() são baseados no valor de tempo que é o número em milissegundos desde 1º de Janeiro de 1970 (UTC).  O UTC (Também conhecido como Greenwich Mean Time, GMT), refere-se ao tempo como definido pelo Padrão de Tempo Mundial (World Time Standard). O Objeto Date também suporta métodos de tempos locais. O tempo local é o tempo conhecido pelo computador onde o JavaScript é executado.

Neste nosso exemplo, criaremos uma função que irá retornar o tempo de nossa máquina.

Vamos ao código:

Primeiro, criaremos uma tag h3 que irá receber os valores de nossa função. Esta tag mostrará as horas, os minutos e os segundos.

<!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>Relógio</title>
</head>
<body>
    <h3 id="hora"></h3>
    <script>
    </script>
</body>
</html>

Criado este campo de input, iremos criar uma função setInterval. Esta função irá executar uma função anônima que, utilizando o método Date(), getHours(), getMinutes(), retornará as horas, minutos e segundos atuais diretamente para a página HTML, utilizando o textContent.

setInterval(function(){
    
    let novaHora = new Date();
    // getHours trará a hora
    // geMinutes trará os minutos
    // getSeconds trará os segundos
    let hora = novaHora.getHours();
    let minuto = novaHora.getMinutes();
    let segundo = novaHora.getSeconds();

    // Chamamos a função zero para que ela retorne a concatenação
    // com os minutos e segundos
    minuto = zero(minuto);
    segundo = zero(segundo);

    // Com o textContent, iremos inserir as horas, minutos e segundos
    // no nosso elemento HTML
    document.getElementById('hora').textContent = hora+':'+minuto+':'+segundo;
},1000)

Para mostrar as horas no formato padrão (00:00:00), criaremos uma função denominada zero(x) que retornará uma concatenação de um ‘0’ em frente à X, com a condição de x ser menor que 10.

// A function zero concatena a string (número) 0 em frente aos números
// mantendo o zero na frente dos números menores que 10. Exemplo:
// 21:05:01
// 21:05:02
// e assim, sucessivamente
function zero(x) {
    if (x < 10) {
        x = '0' + x;
    } return x;
}

Gostou deste artigo? Deixe seu comentário abaixo!

Exercício fácil: Sequência de Fibonacci

Você conhece a Sequência de Fibonacci?

A Sequência de Fibonacci é uma sucessão de números. Esta sucessão obedece um padrão onde cada elemento subsequente é o resultado da soma dos dois elementos anteriores.

Ela pode ser definida pela seguinte fórmula:

Assim, teremos:

Fibonacci (0) = 0,

Fibonacci (1) = 1,

Fibonacci (2) = Fibonacci (0) + Fibonacci (1) =1,

Fibonacci (3) = Fibonacci (1) + Fibonacci (2) = 2,

Fibonacci (4) = Fibonacci (2) + Fibonacci (3) = 3,

Fibonacci (5) = Fibonacci (3) + Fibonacci (4)= 5,

Fibonacci (5) = Fibonacci (4) + Fibonacci (5) = 8,

E assim, sucessivamente.

Mas onde ela pode ser aplicada?

A Sequência de Fibonacci pode ser aplicada em diversas áreas, como:

  • Análise de mercados financeiros: existem relações entre picos e vales em gráficos de flutuação da bolsa financeira, que tendem a seguir razões numéricas aproximadas com as razões de números da Sequência de Fibonacci.
  • Triângulo de Pascal: os triângulos de Pascal e Pitágoras também se relacionam com a Sequência de Fibonacci.
  • Pintura e Arte: as artes utilizavam-se da Proporção Áurea.
  • Anatomia e Homem Vitruviano: medidas e funcionamento do universo conectadas pela proporção do número de ouro.
  • Entre outras diversas aplicações…

Exercício:

Neste exercício, você deverá reproduzir a Sequência de Fibonacci utilizando um laço de repetição. Utilize o laço For ou o While pra resolver este problema.

function fibonacci(n) {
    if () {
        return;
    }

    for () {
        if () {
            return;
        }
    }
}

Crie um algoritmo que retorne o valor da Sequência de Fibonacci na posição 5, na posição 7 e na posição 13. Você deverá ter um log de saída aproximadamente neste formato:

Gostou deste Exercício? Achou fácil ou difícil? Comente os seus resultados abaixo!

Você pode baixar o código-fonte com o resultado do exercício aqui: [download id=”2730″]

 

Como remover Elementos de um Array JavaScript alterando o length

Em JavaScript, os Arrays permitem agrupar valores e iterar sobre eles. Você pode adicionar e remover elementos destes vetores de várias maneiras diferentes.

Ao invés de um método de exclusão, o Array JavaScript possui várias maneiras de limpar os valores do vetor. Você pode remover os elementos do final de um Array usando pop(), no início usando shift(), ou no meio usando splice().

Removendo elementos do final de um Array utilizando o length:

Os elementos de um Array JavaScript podem ser removidos do final de um vetor, definindo a propriedade length (tamanho do array) como um valor menor que o valor atual. Qualquer elemento que possuir o índice maior que o estipulado no novo length, será removido.

// Definindo o vetor de tamanho 6 (a partir do índice 0)
let array1 = [1, 2, 3, 4, 5, 6];
array1.length = 4; // Alterando o tamanho (length) do array
console.log(array1); // [1, 2, 3, 4] vetor alterado

Removendo elementos do início de um Array utilizando o shift():

Para remover o primeiro elemento de um Array no JavaScript, podemos utilizar o método shift(). Ele funciona de forma muito parecida com o método pop(), com a diferença que o pop() remove o último elemento, e o shift() remove o primeiro elemento do vetor. Não é necessário passar parâmetros neste método, pois o shift() irá remover apenas o primeiro elemento do vetor. Os outros elementos restantes serão realocados para seus novos índices. O elemento que estava no índice 1, será realocado para o índice 0, e assim, sucessivamente.

// Criando um vetor com 4 elementos
let array2 = ['Ana', 'Marcos', 'Paulo', 'Alexandre'];
array2.shift(); // Removerá o primeiro elemento do vetor: 'Ana'
console.log(array2); // ['Marcos', 'Paulo', 'Alexandre']

O shift() retorna o elemento que foi removido, atualiza os índices e atualiza o length do Array. Se não houver elementos ou o comprimento da matriz for 0, o método retornará undefined.

Removendo elementos do meio do Array utilizando o splice():

O método splice() é utilizado para remover elementos de determinados índices de um vetor. Será necessário passar dois parâmetros neste método. O primeiro, especifica o índice que será removido. O segundo, especifica quantos elementos a partir deste índice serão removidos.

// Criando um vetor com os elementos 
let array3 = [1, 2, 3, 4, 5, 6, 7, 8, 9];
// Crie uma variável para adicionar o método slice()
// Passe como argumentos a partir de qual índice será removido, e quantos elementos serão removidos
let remover = array3.splice(3, 3);
console.log(array3); // [1, 2, 3, 7, 8, 9]

Gostou deste artigo? Tire suas dúvidas abaixo na sessão de comentários!