Tag: Programação

Publicado em

O Google adiciona noções SEO JavaScript ao seu guia do desenvolvedor

Recentemente, o Google adicionou uma seção básica de SEO do JavaScript ao guia do desenvolvedor da Rede de Pesquisa. A nova seção tem como objetivo fornecer aos iniciantes uma visão geral de como o Googlebot processa o JavaScript. Isto inclui descrições gerais de como o Google processa JavaScript, além de algumas práticas recomendadas.

Além de uma visão geral de como o Googlebot rastreia, processa e indexa aplicativos da Web JavaScript, o guia também fornece dicas básicas, acompanhadas de links para recursos mais detalhados das funcionalidade de indexação Google, como as seguintes:

  • Como descrever sua página com títulos e snippets exclusivos: O JavaScript permite que os SEOs definam ou alterem títulos e meta descrições.
  • Como escrever código compatível: Os desenvolvedores devem estar cientes das limitações da API e do JavaScript do Googlebot.
  • Códigos de status HTTP importantes: Os códigos de status informam ao Googlebot que uma página foi movida ou que ela não deve ser rastreada ou indexada.
  • Informações sobre a tag meta-robôs: O Google afirma que o uso do JavaScript para remover ou alterar a metatag do robô pode não funcionar da maneira esperada, explicando: “O Googlebot ignora a renderização e a execução do JavaScript se a tag de meta-robôs contiver inicialmente ‘noindex’. Se você quiser usar JavaScript para alterar o conteúdo da metatag do robô, não defina o valor da metatag como “noindex”.
  • Corrigindo imagens e conteúdo carregado com lazy load: O Google recomenda o uso de lazy load para aumentar o desempenho e diminuir os custos de largura de banda.

Por que devemos nos importar. O JavaScript é uma ferramenta poderosa para desenvolvedores e pode melhorar a experiência do usuário. Entender como o Googlebot processa seus aplicativos da web com JavaScript pode ajudar você a torná-los mais detectáveis, o que pode aumentar sua visibilidade orgânica e atrair mais tráfego para seu site.

 

 

 

 

Publicado em

Exercício Fácil: Validando Triângulos.

Triângulos são polígonos que possuem três lados. Como qualquer outra figura geométrica, os triângulos possuem alguns elementos, que são:

  • Lados: São segmentos de reta que se encontram nas suas extremidades. Todo triângulo é uma figura geométrica que possui três lados. Os triângulos podem ser definidos de três formas diferentes.
  • Vértices: Os vértices são os pontos de encontro entre os lados.
  • Ângulos internos: Na união dos lados de um triângulo, se forma um ângulo. Os triângulos possuem três ângulos internos. Os vértices e os lados destes ângulos são, respectivamente, os vértices e os lados do triângulo.

Neste exercício, você deverá criar uma função para validar se os valores passados como parâmetro formam um triângulo equilátero, escaleno ou isósceles.

Requisitos:

Para realizar este exercício, você deverá ter conhecimento sobre:

  • Condicionais;
  • Comparadores.

Como realizar:

Crie uma função chamada validarForma(). Esta função deverá receber três parâmetros: a, b, c.

Dentro da função, utilizando condicionais e comparadores, verifique se:

  • Todos os lados são iguais, o triângulo será equilátero;
  • Se todos os lados forem diferentes, será escaleno;
  • Se nenhuma das duas condições anteriores for atendida, será isósceles.

Faça o download de uma das possíveis soluções para este exercício:

[download id=”2831″]

Gostou deste exercício? Resolveu de forma diferente? Mostre o seu resultado nos comentários!

Publicado em

Exercício Fácil: Switch

Você conhece a condicional Switch?

Ela serve para avaliar uma expressão. Combinando o valor desta expressão para a utilização de um case, as instruções associadas ao case serão executadas. O switch executa um código de acordo com diversos resultados possíveis. Ele é uma excelente alternativa para a execução de códigos com muitas comparações.

Por exemplo, podemos ter uma média escolar. Temos como dados de entrada a nota média de cada aluno. Dentro do switch, teremos vários cases (casos). Caso a nota for maior ou igual a sete, o aluno estará aprovado. Caso seja entre cinco e sete, o aluno estará em recuperação e se a nota for menor que cinco, o aluno está reprovado. Utilizando este exemplo conceitual, conseguimos aplicar na prática o uso do switch/case.

Sintaxe:

let variavel = valor;

switch (variavel) {
    case valor:
        instrução;
  break;
    default;
  instrução;
}

Onde:

  • variável: é a expressão que será avaliada;
  • valor: condição que deverá ser verificada para execução das instruções;
  • instrução: trecho de código que será executado quando a condição for especificada;
  • break: serve para encerrar a leitura do switch. Sem este comando, o código do case abaixo será executado na sequência.
  • default: executará quando nenhum case corresponder ao valor especificado.

Observação:

O switch compara valores utilizando ===. Portanto, os valores comparados devem ser do mesmo tipo de dado.

Exercício 1:

Crie uma variável chamada “fruta”. Esta variável deve receber uma string com o nome de uma fruta. Após, crie uma estrutura condicional switch que receba esta variável e que possua três casos: caso maçã, retorne no console: “Não vendemos esta fruta aqui”. Caso kiwi, retorne: “Estamos com escassez de kiwis” e caso melancia, retorne: “Aqui está, são 3 reais o quilo”. Teste com estas três opções e verifique o console do seu navegador. Crie também um default, que retornará uma mensagem de erro no console.

Exercício 2:

Um homem decidiu ir à uma revenda comprar um carro. Ele deseja comprar um carro hatch, e a revenda possui, além de carros hatch, sedans, motocicletas e caminhonetes. Utilizando uma estrutura switch/case, caso o comprador queira o hatch, retorne: “Compra efetuada com sucesso”. Nas outras opções, retorne: “Tem certeza que não prefere este modelo?”. Caso seja especificado um modelo que não está disponível, retorne no console: “Não trabalhamos com este tipo de automóvel aqui”.

Resolva estes exercícios para melhor aprendizado!

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

Publicado em

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!

Publicado em

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”

Publicado em

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!

Publicado em

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”

Publicado em

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:”

Publicado em

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!