Como remover o Required de uma Tag com JavaScript

[download id=”239″]

Esta é uma forma fácil e rápida de remover o atributo required sem a necessidade de importar bibliotecas com o JQuery ou qualquer outra. Normalmente não existe motivo para remove-lo, ou em muitos casos este tipo de validação é feita no back-end, mas veremos um jeito simples e que permitirá o post de um form quando um condição ocorrer.

O código

Como mencionado anteriormente, utilizaremos um form abaixo para testarmos nosso exemplo:

<form method="post" style="border:1px solid black; padding:10px;">
  <label>Nome:</label>
  <input type="text" id="name" required/>
  <br/>
  <label>Telefone:</label>
  <input type="text" id="requiredInput" required/>
  <br/>
  <input type="submit"/>
</form>

Se você rodar o código acima e não adicionar nenhum valor no campo telefone, o form será impedido de enviar os dados pois o campo é obrigatório. Agora, após um tempo tornou-se necessário que certas pessoas não precisem enviar o telefone delas pois já são clientes, ou funcionários (mundo imaginário, você cria o motivo). Em nosso exemplo qualquer pessoa que se chamar “Pedro Silva” não precisará colocar o número de telefone. A função javascript que a acompanha pode ser bem simples quanto o código abaixo

function removeRequired() {
  if( document.getElementById("name").value === "Pedro Silva"){
    document.getElementById("requiredInput").removeAttribute("required");
  }
}

Tendo nossa condição definida, podemos começar a vincular o nosso código. Neste caso é importante lembrar que não adianta colocar o evento dentro do onsubmit do form, pois a validação ocorre antes disto. O melhor local que achei para fazê-lo é no onclick do próprio input utilizar para enviar este form.

<input onclick="removeRequired()" type="submit"/>

Conclusão

Como vocês podem ver, é fácil e rápido remover o required das tags html. O difícil é achar artigos em português que falem de como fazê-lo. Acredito que essa tarefa é tão simples que realmente não vale o peso de uma biblioteca para implementar essa funcionalidade, mas se você já a está usando para outras coisas e ela reduz ainda mais a complexidades, então ela é provavelmente o jeito mais correto do que o mencionado aqui.

Como fazer Captcha com JavaScript

[download id=”227″]

O Captcha (Completely Automated Public Turing test to tell Computers and Humans Apart) é uma ferramenta utilizada para combater spam utilizando um método chamado de teste de Turing reverso. Normalmente o servidor pede ao usuário que termine um teste que não pode ser completado por um computador e por isso assume-se que quem respondeu corretamente é um humano.

Nesse artigo/tutorial veremos como fazer 2 “captchas” simples e rápidos usando apenas o JavaScript puro ao invés efetua-lo pelo servidor. A vantagem de fazê-lo assim é a de podermos manter o controle no front-end e fornecer uma proteção básica e rápida. Por outro lado, o código estará exposto para “não robôs” contorna-lo. Vale o julgamento de cada um para saber se este controle é o suficiente.

Soma de números aleatórios

Um jeito fácil de fazer um teste é fornecer 2 números aleatórios e pedir para o usuário digitar a resposta completa.

  • Primeiro precisamos do html que será usado no exemplo:
<form id="formContato">
   <p id="teste"></p>
   <input id="valida" type="text" />
   <input type="submit" value="Enviar" />
   <p id="mensagem"></p>
</form>
  • Agora criamos as variáveis para o cálculo e a reposta. Neste exemplo, criaremos 2 números aleatórios de 0 a 9 e vamos soma-los. Mas você poder fazer qualquer faixa e operação
var num1 = Math.floor(Math.random() * 10);
var num2 = Math.floor(Math.random() * 10);
var resposta = num1 + num2;
  •  Adicionamos um evento para que, ao carregar a página, seja capturado o parágrafo que fará a pergunta do teste e utilizamos as variáveis para gerar uma pergunta diferente cada vez que a página recarrega:
window.onload = function () {
   document.getElementById("teste").innerHTML = "qual a soma de " + num1 + " + " + num2 + "?";
}}
  • Dentro da função anterior, adicionaremos um evento ao ser feito o submit do formulário para conferirmos se a resposta está correta. Caso esteja, a submissão dele ocorre normalmente, senão trancamos o envio e mostramos uma mensagem na tela
document.getElementById("formContato").onsubmit = function (e) {
  if (document.getElementById("valida").value != resposta) {
    document.getElementById("mensagem").innerHTML = "A soma está errada!";
    e.preventDefault();
  }
}

Com isso temos todo o código necessário para fazer nosso captcha funcionar, execute a página e faça o teste você mesmo.

Teste x Valor

A segunda alternativa é um pouco mais complexa, mas ainda assim muito simples de implementar. Ela pode ser utilizada para mostrar uma imagem, dados complexos, etc… e um valor que corresponde a resposta correta.

  • Neste exemplo vamos tentar utilizar o máximo possível da lógica anterior para evitar complicar algo desnecessário. O form de antes será reutilizado exatamente como era e a lógica será novamente implementada dentro da função do evento window.onload
  • Vamos então adicionar as 2 variáveis que precisaremos. A Primeira será um vetor contendo objetos com 2 propriedades, teste e valor. A segunda é um gerador aleatório de índice.
window.onload = function () {
  var vetor = [
    { teste: "BBbananaAA", valor: "banana" },
    { teste: "AAabacaxiII", valor: "abacaxi" },
    { teste: "BBtomateAA", valor: "tomate" },
    { teste: "BBkiwiAA", valor: "kiwi" },
    { teste: "BBmelaoAA", valor: "melao" }
  ];
  var indice = Math.floor(Math.random() * 100) % 5;
}

Note que a propriedade teste do vetor é possível utilizar o caminho de uma imagem, uma pergunta, uma data, qualquer coisa. O importante é que o que for colocado no teste precisa ter uma reposta correspondente e a tag onde ele será inserido talvez precise ser trocada ou tratada (ex.: se for uma imagem, trocar para img com o src sendo definido pelo caminho da imagem).

  • Utilizando o gerador aleatório de índice, buscamos um item dentro do vetor e o exibimos para ser o teste. Lembrando que aqui meu vetor tem 5 itens, você provavelmente terá um vetor maior, então ajuste o gerador de acordo com a necessidade
document.getElementById("teste").innerHTML = "Qual a palavra formada pelas letras minusculas do texto " + vetor[indice].teste + "?";
  • Por último temos novamente o teste antes de efetuar o submit do formulário que irá conferir se a resposta é igual ao valor do objeto naquela mesma posição do vetor. Com isso saberemos se podemos deixar o formulário ser enviado ou se precisamos bloqueá-lo
document.getElementById("formContato").onsubmit = function (e) {
  if (document.getElementById("valida").value != vetor[indice].valor) {
    document.getElementById("mensagem").innerHTML = "Resposta Errada";
    e.preventDefault();
  }
}

Conclusão

Como você pode ver, criar um controle de captcha pode ser bem simples e ajudará a evitar e-mails spam, pessoas clicando em enviar sem parar e outros incômodos básicos. Claro que existem outros jeitos de fazer a mesma coisa usando bibliotecas prontas ou técnicas de programação diferentes, mas acredito que a forma apresentada ajude a todos, principalmente os iniciantes.

 

Diferença de className, classList e setAttribute

A linguagem JavaScript nos permite manipular elementos HTML de diversas formas e algumas vezes precisamos montar componentes “on the fly” pois eles dependem de atualizações vindas de fontes externas, ações do usuário ou que o banco de dados finalmente termine de processar algum calculo monstruoso que aquele cliente disse ser fundamental.

Quando isso acontece, precisamos trabalhar para criar elementos que além de uteis sejam bonitos e com isso vem as implementações de CSS. Agora você que a passou por isso pode ter se deparado com a possibilidade de usar os métodos

  • Classname
  • Classlist.add
  • Setattribute

A performance

Mas qual é o melhor? Vale a pena ter um método para definir classes e um para definir atributos? Tendo isso em vista, resolvi pesquisar para saber qual seria a melhor opção. Segundo o site https://measurethat.net/Benchmarks/Show/54/0/classname-vs-setattribute-vs-classlist, alguém já havia se perguntado o mesmo. Eles fizeram o seguinte teste que rodei no Chrome, Edge e Firefox:

<div id="foo"></div>

className

var element = document.getElementById("foo");
var i = 1000;
while (i--) {
    element.className = "bar";
}

setAttribute

var element = document.getElementById("foo");
var i = 1000;
while (i--) {
    element.setAttribute("class", "bar");
}
classList
var element = document.getElementById("foo");
var i = 1000;
while (i--) {
    element.classList.add("bar");
}

Resultado em operações por segundo

Chrome

Firefox

Edge

Na prática

Mesmo sendo bem claro, o teste acima não é um absoluto, devemos levar em consideração outros fatores como manipulação, funcionalidades e boas práticas.

  1. className: Permite a manipulação das classes no formato string, nesse caso tendo uma string com todas as classes escritas dentro e permitindo a manipulação dos dados neste formato. Por ser uma funcionalidade antiga, é utilizado por diversos navegadores
  2. setAttribute: O set atribute simplesmente faz isso, define o valor dentro de um atributo. Existe o getAttribute que permite visualizar este valor, mas a manipulação é limitada a isso.
  3. classList: Coloca as classes dentro de uma lista para serem manipuladas de forma ordenada através de diversos métodos específicos. A nível de funcionalidade é a mais prática, mas além de ter uma performance inferior, não foi implementada em navegadores mais antigos.

Conclusão

Acredito que o className e o classList sejam os melhores candidatos. Se você precisa de performance e está apenas definindo e apagando classes, utilize o className. Agora se você tem um sistema que precisa procurar por classes dentro da tag ou adicionar apenas se não existe, poupe o esforço de criar uma lógica para isso e utilize o classList.

Como criar a tag para uma string

Essa é uma dica rápida para ajudar você a criar a tag HTML <a> com base em um link digitado dentro de uma string. Há alguns dias atrás tive esta duvida pois precisava ajudar a criar o link para as mensagens de texto que os clientes colocavam dentro de um sistema que estamos desenvolvendo. Então precisávamos fazer com que uma frase como:


Confira o site www.mundojs.com.br para mais informações, ou acesse nossa fanpage https://www.facebook.com/mundojs/ para receber mais noticias


Exibisse em tela da com os hiperlinks da seguinte forma:


Veja o site www.mundojs.com.br para mais informações, ou acesse nossa fanpage https://www.facebook.com/mundojs/ para receber mais noticias


Depois de pesquisar bastante por um solução que fosse A) inteligente e B) Eficiente, encotrei a seguinte função regex

function urlify(text) {
    let urlRegex = /(https?:\/\/[^\s]+)/g;
    return text.replace(urlRegex, function(url) {
        return '<a href="' + url + '">' + url + '</a>';
    })
    /* ou de forma mais resumida */
    /* return text.replace(urlRegex, '<a href="$1">$1</a>') */
}

let text = "Confira o site www.mundojs.com.br para mais informações, ou acesse nossa fanpage https://www.facebook.com/mundojs/ para receber mais noticias";
let html = urlify(text);

Com ela você poderá passar qualquer strings que você receberá seus links adaptados para que em uma pagina HTMl possa exibi-los corretamente.

Resultado da Enquete

Introdução

Com base na resposta da enquete, planejaremos o mês de dezembro de acordo para que você leitor tenha o material que precisa. Segue abaixo o gráfico dos resultados:

Como você pode ver, exemplos com código saiu em primeiro lugar disparado do segundo e terceiro. Por isso, nas próximas semanas iremos focar em artigos com exemplos e download de código fonte. Para não focarmos em apenas uma coisa, iremos publicar vídeos e novidades, mas em uma frequência bem mais baixa que a dos artigos.

Caso você queira publicar um artigo seu, entre em contato conosco pela nossa fanpage ou pelo website para que possamos publicar seu trabalho.

Criando bibliotecas com TypeScript

O objetivo desse post será a demonstração através de alguns passos de como podemos criar de uma biblioteca com TypeScript e publicarmos ela no portal NPM.

Primeiro passo: Inicialização do projeto

Nosso primeiro passo será a criação de um novo diretório, para esse artigo nós criamos um com o nome ts-library, navegue até o seu diretório via CMD e execute o comando npm init -y.

O comando a cima irá criar um arquivo chamado package.json, esse será o primeiro arquivo que nós precisamos editar. Para isso, iremos precisa de em um editor de textos, nesse artigo nós iremos utilizar o VS Code (Visual Studio Code).

Com o VS aberto, agora nós precisamos atualizar o nosso arquivo package.json:

{
    "name": "typescript-library",
    "version": "1.0.0",
    "description": "",
    "scripts": {
        "test": "echo \"Error: no test specified\" && exit 1"
    },
    "keywords": [],
    "author": "",
    "license": "ISC",
    "main": "dist/index.js",
    "types": "dist/index.d.ts"
}
  • name: deve ser o nome da sua biblioteca;
  • version: a versão atual do seu código;
  • types: local do nosso arquivo de type definition, para quem ainda não conhece segue o link de um artigo sobre esse tema Type Definitions.

Segundo passo: Configurando TypeScript

Agora nós precisamos criar o nosso arquivo de configurações do TypeScript. Para isso, crie um novo arquivo chamado tsconfig.json na raiz do seu projeto.

{
    "compilerOptions": {
        "module": "commonjs",
        "target": "es5",
        "declaration": true,
        "outDir": "./dist"
    },
    "include": [
        "src/**/*"
    ]
}

Passando pelo nosso arquivo a cima nós temos:

  • target: a versão do ecmascript que nós estamos utilizando.
  • declaration: nós deixamos como true para que ele gere o nosso arquivo de types.
  • include: local onde ele deve varrer para achar os nossos arquivos .ts.

Terceiro passo: Criação da biblioteca

Para esse passo nós iremos criar uma biblioteca para pegar o valor de um parâmetro passado pelo URL, algo bem simples somente para que possamos ver esse fluxo.

export namespace GetUrl {
    export function params(url) {

    var queryString = url ? url.split('?')[1] : window.location.search.slice(1);


    var obj = {};

    if (queryString) {
        queryString = queryString.split('#')[0];
        var arr = queryString.split('&');

        for (var i = 0; i < arr.length; i++) {

        var a = arr[i].split('=');
        var paramNum = undefined;
        var paramName = a[0].replace(/\[\d*\]/, function (v) {
            paramNum = v.slice(1, -1);
            return '';
        });

        var paramValue = typeof (a[1]) === 'undefined' ? true : a[1];
        paramName = paramName.toLowerCase();
        paramValue = paramValue.toLowerCase();
        if (obj[paramName]) {

            if (typeof obj[paramName] === 'string') {
            obj[paramName] = [obj[paramName]];
            }

            if (typeof paramNum === 'undefined') {
            obj[paramName].push(paramValue);
            }
            else {
            obj[paramName][paramNum] = paramValue;
            }
        } else {
            obj[paramName] = paramValue;
        }
    }
}
    return obj;
}}

O trecho de código a cima foi retirado do site. A baixo tem uma explicação de como eles recomendam a sua utilização.

getAllUrlParams().product; // 'shirt' 
getAllUrlParams().color; // 'blue' 
getAllUrlParams().newuser; // true 
getAllUrlParams().nonexistent; // undefined 
getAllUrlParams('http://test.com/?a=abc').a; // 'abc'

Quarto passo: Criação do arquivo main

Para que possamos exportar a nossa biblioteca para o NPM, nós precisamos criar o arquivo que nós definimos no passo dois desse artigo na tag main. Para isso, crie na raiz do seu projeto um arquivo chamado index.ts e dentro dele importe o sua biblioteca.

import { GetUrl } from "./geturl-params";

Quinto passo: Publicando no NPM

Para essa etapa, nós iremos precisar de uma conta no portal NPM, caso ainda não tenha basta clicar no link e criar uma. Com o seu usuário e senha do em mãos, digite no seu terminal npm login e insira as suas credenciais, em seguida execute o comando npm publish, para que possamos verificar se o o nosso pacote foi publicado com sucesso, basta acessar o portal NPM no seu perfil.

Para quem tiver interesse em como ficou a versão final do código demonstrado nesse artigo, segue seu link no GitHub.

Conheça a W3.JS

Introdução

Muitos de nós conhecemos o site da w3schools que aparece em 80% das buscas de informações se tratando de HTML, CSS, Bootstrap, JavaScript, Jquery e outras tecnologias dos quais eles fornecem diversas páginas com conteúdo didático gratuito. Apesar de não ser novidade, muitas pessoas não sabem que eles criaram o W3.CSS e o W3.JS que são duas bibliotecas disponíveis para o público. A primeira tenta fornecer funcionalidades similares ao Bootstrap, que não está no escopo do que veremos, e a segunda fornece diversas pequenas funcionalidades que facilitam a interatividade das páginas mantendo tudo em HTML e no front-end.

Funcionalidades

Dentre as funcionalidades da biblioteca, podemos mencionar os controles de visualização:

  • w3.hide, w3.show, w3.toggleShow: Respectivamente oculta, exibe ou alterna a visualização de um elemento HTML
<h2>Teste</h2>
                                
<button onclick="w3.hide('h2')">Hide</button>
<button onclick="w3.show('h2')">Show</button>
<button onclick="w3.toggleShow('h2')">Toggle</button>
  • w3.removeClass, w3.addClass, w3.toggleClass: Respectivamente remove, adiciona ou alterna a existência de uma classe CSS em um elemento HTML. O toggle também permite alternar entre 2 classes ao invés de simplesmente remover/adicionar uma.
<p id="London" class="class1">City</p>
                                
<style>
    .marked{
        text-decoration: underline;
    }
    .class1{
        color: black;
    }
    .class2{
        color: red;
    }
</style>

<button onclick="w3.addClass('#London','marked')">Add Class</button>
<button onclick="w3.removeClass('#London','marked')">Remove Class</button>
<button onclick="w3.toggleClass('#London','marked')">Toggle</button>
<button onclick="w3.toggleClass('#London','class1','class2')">Toggle</button>
  • w3.addStyle: Adiciona a propriedade style a um elemento HTML.
<input oninput="w3.filterHTML('#id01', 'li', this.value)">
<ul id="#id01">
    <li>Afonso</li>
    <li>Bruna</li>
    <li>Carlos</li>
    <li>Diego</li>
    <li>Emma</li>
</ul>
  • w3.sortHTML: Ordena um grupo de elementos HTML:
<button onclick="w3.sortHTML('#id01', 'li')">Sort</button>
<ul id="#id01">
    <li>Emma</li>
    <li>Afonso</li>
    <li>Diego</li>
    <li>Carlos</li>
    <li>Bruna</li>
</ul>
  • w3.slideshow: exibe elementos sequencialmente, um por vez.
<img class="nature" src="img_fjords.jpg"/> 
<img class="nature" src="img_mountains.jpg"/> 
<img class="nature" src="img_nature.jpg"/>

<script> 
    w3.slideshow(".nature"); 
</script>
  • w3.displayObject: Exibe os dados de um objeto JavaScript no HTML
<div id="id01"> {{firstName}} {{lastName}} </div> 
<script> 
    var myObject = { "firstName": "John", "lastName": "Doe" }; 
    w3.displayObject("id01", myObject); 
</script>
  • w3.includeHTML: Inclui um trecho de código HTML externo na página/componente atual.
<div w3-include-html="arquivoExterno.html"></div>
<script>
    w3.includeHTML();
</script>
  • w3.getHttpObject: Lê um arquivo do servidor
w3.getHttpObject("customers.js", funcaoExecutadaAposGet());

Vantagens e Desvantagens

Vantagens:

  • Bem mais leve que muitas outras bibliotecas
  • A maioria das funcionalidades é fácil de implementar
  • Curva de aprendizado pequena

Desvantagens:

  • Poucas funcionalidades disponíveis.
  • Não há muito material fora do site deles
  • A utilização em projetos grandes é inexistente.

Conclusão

Além de ser leve e fácil de aprender, a biblioteca W3 permite que seu projeto tenha diversas funcionalidades essenciais em um ambiente simples e de alta customização. Se você tiver um bom conhecimento dos métodos nativos do JavaScript e combinar essa biblioteca com eles, poderá manipular o DOM e trabalhar com templates e dados dinâmicos sem muitos problemas. Por outro lado, se não for bem planejado, seu projeto poderá acabar com pelo menos 2 bibliotecas que terão funcionalidade semelhantes ou você despenderá muito tempo fazendo customizações e implementações para manter um ambiente que não atende todas as necessidades do seu sistema.

Angular: Criação de Pipes

Introdução

Para quem ainda não conhece as pipes do Angular, elas são uma maneira elegante de realizarmos transformações no nosso front-end. Com ela nos podemos criar funções ou filtros (como ela é chamado no inglês), que podem ser utilizadas em qualquer parte do template do nosso projeto. Para que você possa ter um entendimento melhor, irei criar um exemplo de uma pipe que nos auxilie com o problema “unsafe” de URL’s externas.

Criação do projeto

Para esse artigo, eu não irei abordar os passos para criação de um projeto, irei partir de um já criado com Angular cli. Caso ainda não tenha o Angular Cli instalado e queira saber mais sobre esse passo, segue link de um artigo onde eu demonstro esse tema Angular Cli Scaffold. Para quem tiver interesse, eu irei disponibilizar o link do projeto que utilizaremos no final desse artigo.

Pipes

O Angular já nos prove algumas pipes para utilização como: date, uppercase, lowercase … etc mas na maioria das vezes nós precisamos de algo mais complexo. Para que possamos criar a nossa pipe, nos iremos utilizar o command line do Angular cli. Para isso, execute o comando abaixo no seu terminal/CMD.

ng generate pipe [name]

Nesse artigo eu dei o nome de Safe. Esse comando irá gerar um novo arquivo chamado safe.pipe.ts. Vamos atualizar ele com o seguinte código:

import { Pipe, PipeTransform } from '@angular/core';
/*Carregando o pacote DomSanitizer, ele auxilia com o Cross Site Scripting Security.*/
import { DomSanitizer } from "@angular/platform-browser";

@Pipe({
    name: 'safe'
})

export class SafePipe implements PipeTransform {
    /*Injetando o DomSanitizer no nosso componente.*/
    constructor(private _sanitizer: DomSanitizer) { }

    /*Criando um método que recebe uma URL, em seguida nós retornamos ele passando pelo método bypassSecurityTrustResourceUrl, dessa forma a nossa aplicação passa a acreditar (remover o erro unsafe) da nossa console.*/
    transform(url) {
        return this._sanitizer.bypassSecurityTrustResourceUrl(url);
    }
}

Caso você queria entender melhor a classe DomSanitizer, segue um link para sua documentação oficial DomSanitizer Docs.

Testando

Para que possamos testar a nossa Pipe, iremos utilizar o Iframe de vídeos do Youtube. Para isso, iremos atualizar o nosso AppComponent com os códigos abaixo:

app.component.html

<iframe width="500" height="400" [src]="video | safe"></iframe>

app.component.html

export class AppComponent {
    title = 'app';
    video: string = "https://www.youtube.com/embed/Ckom3gf57Yw"
}

Bom, com isso nos finalizamos esse post, caso tenha interesse na versão final do projeto, segue o seu link no GitHub.

Qual conteúdo JavaScript é mais importante para você?

Estamos efetuando uma enquete para saber o rumo que iremos tomar como nosso site. Atualmente o MundoJS possui poucos colaboradores e por isso queremos ajudar os leitores naquilo que importa mais.

Isso não quer dizer que o blog, artigos ou cursos irão parar. É apenas para nos preparamos e melhorarmos o conteúdo das sessões que mais interessam para a maioria.

Onde Votar?

Para votar, acesse o link: Qual conteúdo JavaScript é mais importante para você?

A votação ficará aberta até o dia 30/11/2017 e o resultado, caso tenhamos uma quantidade decente de votos, será anunciado exclusivamente em nossa Fanpage no Facebook

Saiba Mais

Caso você esteja interessado em contribuir, entre em contato conosco pelo nosso formulário aqui no site informando como você gostaria de participar. Nosso foco é aumentar a quantidade de informação disponível em Português sobre o JavaScript ou seus Frameworks e bibliotecas, então se você tem um projeto, artigo ou vídeo que gostaria de publicar conosco, basta entrem em contato.

Fundamentos de JavaScript e DOM que você precisa aprender

Com o aumento continuo do desenvolvimeno de dispositivos móveis híbridos utilizando principalmente HTML e JS como tecnologia na criação de telas e lógica. Está cada vez maior a tendência de colocar o máximo possível de processamento na máquina do cliente e com isso vieram diversas novas tecnologias e atualizações que todo desenvolvedor Front-end precisa se atualizar.

Antes de tentar conseguir aquele emprego utilizando JavaScript, você precisa tentar garantir que possui um bom entendimento dos seguintes fundamentos:

  • ES6: A versão atual do JavaScript é o ES2016 (conhecido como ES7), mas muitos desenvolvedores ainda não aprenderam a utilizar corretamente o ES6. É a hora de aprender os fundamentos: funções Arrow, rest/spread, parâmetros default(padrões), desestruturação, etc…
  • Closures: Aprenda como as funções JavaScript se comportam
  • Funções e Funções puras: Você provavelmente acredita que tem um bom entendimento de funções, mas o JavaScript tem alguns truques na manga. E você precisará aprender sobre funções puras antes de começar com programação funcional.
  • Básicos de programação funcional: Programação funcional produz programas compostos por funções matemáticas que evitam estados compartilhados e dados mutáveis. Já existem diversos Apps desenvolvidos em JavaScript que dependem bastante da programação funcional e por isso é importante ter um bom entendimento do básico desta técnica.
  • Métodos nativos: Aprenda sobre os métodos que que acompanham a linguagem e oferecem formas de manipular os tipos de dados básicos (vetores, objetos, strings e números).
  • Callbacks: Callback é uma função normalmente passada como argumento de outra função quando um evento ocorrer, ou quando uma parte de código receber uma resposta de que estava à espera.
  • Promise: Uma promise(promessa) é uma forma de lidar com valores futuros. Quando uma função retorna uma promessa, você pode colocar call-backs usando o método “.then()” para rodar após a promessa ser resolvida. O valor resultante é então passado para a função callback.
  • Ajax e chamadas em APIs: A maioria dos Apps interessantes eventualmente terão que se comunicar pela rede. Por isso é importante saber como fazer chamadas ajax para outras APIs
  • Classes: Classes é um conceito novo no JavaScript, que precisa ser estudado em detalhes pois questões como herança pode causar problemas.
  • Generators e async/await: Estão entre as melhores formas de escrever código assíncrono que parece síncrono. Existe uma curva de aprendizado, mas após passar por ela é possível programar de uma forma fácil para outros entenderem.
  • Node: Node permite que você use JavaScript no lado servidor, isso significa que os usuários você pode utilizar a mesma linguagem (com algumas coisas que precisam ser aprendidas) no front e back-end.

Conclusão

Como você pode ver, o caminho é longo e árduo, mas não se deixe desmotivar simplesmente pelo volume de estudo necessário. Quanto mais você aprende sobre o JavaScript, mais fácil será de entender o próximo estágio. O segredo aqui está em estudar continuamente, com calma e tentar se divertir enquanto você faz isso. Vamos lá!