Criando Ping Pong com JavaScript parte 1

Olá, neste artigo replicaremos o jogo Ping Pong usando JavaScript, utilizando o elemento canvas do HTML.

Mostraremos a facilidade de criar um jogo simples e que utiliza uma certa inteligência artificial para replicar o jogo Ping Pong, utilizando a máquina como adversário. Para isso, utilizaremos JavaScript puro para criar os elementos do jogo e suas ações. O canvas renderizará o jogo.

Vamos começar!

Para começar, precisamos de um arquivo chamado index.html, e chamaremos o arquivo scripts.js que será o responsável pelas ações do jogo:

<!DOCTYPE html>
<html lang="pt-br">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Ping Pong</title>
    <script src="scripts.js"></script>
</head>
<body>
</body>
</html>

E no nosso scripts.js, começaremos adicionando o método requestAnimationFrame. Ele funciona de maneira semelhante ao método setTimeout, trazendo uma chamada de retorno a aproximadamente 60 frames por segundo. Ele torna-se melhor que o método setTimeout pois o navegador pode realizar otimizações na chamada. Mas, caso não haja suporte, utilizaremos o método setTimeout para realizar este retorno de 60 fps.

let animacao = window.requestAnimationFrame || function(callback){
    window.setTimeout(callback, 1000/60);
}

Renderizando:

Agora, criaremos nosso elemento canvas dinamicamente com JavaScipt. Utilizaremos uma altura de 600 e largura de 400. Este será o tamanho de nossa tela de jogo. Também utilizaremos o contexto, que será “2d”:

let canvas = document.createElement("canvas");
let width = 400;
let height = 600;
canvas.width = width;
canvas.height = height;
let contexto = canvas.getContext("2d");

E quando a página for carregada, anexaremos o nosso elemento canvas ao body do HTML e usaremos o método animacao, criado anteriormente, chamando uma função chamada step.

window.onload = function(){
    document.body.appendChild(canvas);
    animacao(step);
};

A função step será responsável por realizar três coisas:

  • Atualizar todos os objetos;
  • Renderizar os objetos;
  • Utilizar a recursão, chamando a função step novamente.
let step = function(){
    atualizar();
    renderizar();
    animacao(step);
};

Para começar exibindo algo na tela, vamos implementar a função atualizar como não operacional, e na nossa função renderizar, vamos definir o plano de fundo do nosso jogo, e utilizaremos os métodos fillStyle e fillRect que são fornecidos pelo contexto. A cor definida é o SlateBlue, com código hexadecimal #836FFF.

let renderizar = function(){
    contexto.fillStyle = "#836FFF";
    contexto.fillRect(0, 0, width, height);
}

E nossa saída será algo assim:

Gostou deste artigo? Comente abaixo e aguarde a sequência!

Referências: https://thoughtbot.com/blog/pong-clone-in-javascript

Google: guia de como gerar dados estruturados usando JS

Recentemente, o Google publicou uma diretriz de desenvolvedor na página de desenvolvedores do Google. Este documento fornece uma visão sobre como criar dados estruturados utilizando JavaScript e implementá-los no site, ou fazê-los corretamente para que possa trazer benefícios na pesquisa do Google. Este novo guia, descreve métodos para adicionar dados estruturados dinamicamente a um site usando JavaScript. Atualmente, o uso de JavaScript é essencial para criar um site com funcionalidade aprimorada. As novas dicas do guia de desenvolvimento da Google serão especialmente valiosas para especialistas de SEO e desenvolvedores Web.

Atualmente, existem muitas maneiras de gerar dados estruturados com JavaScript, mas as mais utilizadas são:

O gerenciador de tags do google é utilizado para gerar JSON-LD dinamicamente. Ele é uma plataforma que permite o gerenciamento de tags no seu site sem editar o código. Para gerar dados estruturados com o Gerenciador de Tas do Google, você precisa:

  • Configure e instale o Gerenciador de tags do Google ao seu site;
  • Adicionar uma tag HTML personalizada ao contêiner;
  • Cole o bloco de dados estruturado desejado no conteúdo da tag;
  • Instale o contêiner conforme mostrado na seção Instalar o Gerenciador de tags do Google no menu de administração do contêiner;
  • Para adicionar a tag ao seu site, publique seu contêiner na interface do Gerenciador de tags do Google e, por fim:
  • Teste a sua implementação.

E a outra maneira de gerar dados estruturados é usando JavaScript para gerar todos os dados estruturados ou adicionar mais informações de dados renderizados no servidor. De qualquer forma, o Google Search pode entender e processar dados estruturados disponíveis no DOM ao renderizar a página. Para saber como o Google Search processa o JavaScript, consulte o guia básico de JavaScript aqui.

Para isso, você precisa:

  • Encontrar o tipo de dado estruturado em que você está interessado;
  • Editar o HTML do seu site para incluir um snippet JavaScript.
  • Testar sua implementação com o Rich Results Tests.

Gostou deste artigo? Comente abaixo!

Referências:

https://codeburst.io/javascript-news-and-updates-april-2020-98ab1ba67418

https://developers.google.com/search/docs/guides/javascript-seo-basics

JAMStack, o que é?

Construir um aplicativo que seja flexível, iterável e construído em um curto espaço de tempo pode realmente ser desafiador. Soluções em cloud como AWS, Azure e GPC fornecem aplicativos Web escaláveis com custo baixo e em poucas semanas.

Escolhendo um banco de dados, movendo o código do aplicativo para soluções em contâiner como o Docker, implantando funções de Back-End e alterações de código. Assim é o que acontece no desenvolvimento de aplicativos atualmente. Com o JAMSTACK, sites e aplicativos rápidos e seguros são entregues pré-renderizando arquivos e servindo-os diratemente de uma CDN, onde o requisito de gerenciar ou executar servidores Web são removidos.

O Jamstak não é sobre tecnologia específicas. É uma nova maneira de criar sites e aplicativos, oferecendo melhor desempenho, segurança e custo de dimensionamento e uma melhor experiência do desenvolvedor. Sites pré-renderizados podem ser aprimorados com JavaScript e os crescentes recursos de navegadores e serviços disponíveis via APIs. O Jamstack é a junção de JavaScript, APIs e Marcação.

Você provavelmente já trabalhou em um site Jamstack, utilizando Jekyll, Next, Gtasby, entre outros gerenciadores de site estático.
Quando você utiliza um CMS, não está utilizando Jamstack. Por exemplo, se estiver utilizando WordPress, Drupal, Joomla, um aplicativo Web executado por servidor que depende de algum idioma back-end ou um aplicativo de página única que utiliza renderização isomórfica para criar visualizações no servidor em tempo de execução.

Benefícios:

Maior segurança:

Com os processos do lado de servidor abstraídos nas APIs de microsserviço, as áreas de superfície para ataques são reduzidas.

Escala mais barata e fácil:

Quando sua implantação equivale uma pilha de arquivos que podem ser veiculados em qualquer lugar, o dimensionamento é uma questão de veicular esses arquivos em mais locais. As CDNs são perfeitas para isso e incluem dimensionamento em todos os seus planos.

Melhor Experiência do Desenvolvedor:

O baixo acoplamento e separação de controles permitem um desenvolvimento e depuração mais direcionados, e a seleção crescente de opções de CMD para geradores de sites remove a necessidade de manter uma pilha separada de conteúdo e marketing.

Gostou desta notícia? Comente abaixo.

Criando jogo Snake em JavaScript e Canvas

Hoje criaremos um jogo Snake utilizando HTML5 e JavaScript.

Para isso, criaremos um arquivo HTML que servirá de base para nosso jogo. Crie um arquivo chamado index.html e insira o código:

<!DOCTYPE html>
<html lang="pt-br">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Jogo Snake</title>

</head>
<body>
        <script src="scripts.js"></script>
</body>
</html>

Dentro do nosso elemento body, adicionaremos um elemento canvas:

<canvas id="canvas" width="400" height="400"></canvas>

E agora, adicionaremos o JavaScript:

Agora que temos o Canvas adicionado, adicionaremos o JavaScript. Crie um arquivo chamado scripts.js, e nele, adicionaremos a lógica do nosso jogo. O nosso arquivo irá renderizar o canvas e os elementos do jogo.

Primeiro, precisamos definir o que acontece quando o window.onload é chamado. Precisamos obter o elemento Canvas e adicionar um evento de pressionar teclas. Esse evento faz o canvas se redesenhar com a nova posição da cobra e onde o alimento aparecerá.

let canvas;
let ctx;

window.onload = function(){
    canvas = document.getElementById("canvas");
    ctx = canvas.getContext("2d");
    document.addEventListener("keydown", keyDownEvent);
    let x = 8;
    setInterval(desenharJogo, 1000 / x);
};

Tratamento das teclas:

Precisamos definir o que a nossa função keyDownEvent chamada no addEventListener faz. Para isso, utilizaremos keyCodes, que representam o que cada seta do teclado faz:

function keyDownEvent(event){
    // nextX e nextY representam as direções que a cobra irá percorrer
    // nos eixos X e Y, respectivamente
    switch(event.keyCode){
        case 37:
            nextX = -1;
            nextY = 0;
            break;
        case 38:
            nextX = 0;
            nextY = -1;
            break;
        case 39:
            nextX = 1;
            nextY = 0;
            break;
        case 40:
            nextX = 0;
            nextY = 1;
            break;
    }
}

O nextX e nextY representam a direção em que a cobra se desloca.

Serpente:

Vamos definir as variáveis que serão utilizadas para criar a serpente.

let defaultTamanhoCauda = 3;
let tamanhoCauda = defaultTamanhoCauda;
let caminhoCobra = [];
let cobraEixoX = cobraEixoY = 10;

Definimos um tamanho inicial da serpente como 3. A cada vez que ela ingerir o alimento, será incrementado em 1 esse valor. O caminho que a serpente percorrerá é uma matriz de posições X e Y, onde cobraEixoX e cobraEixoY serão a posição inicial da cobra.

Tela do jogo:

Criaremos a tela onde o jogo funcionará. É uma grade 20×20, que corresponde à largura e altura da tela.

//Criação da tela de jogo
let tamanhoTela = tamanhoCaminho = 20;
let nextX = nextY = 0;

Comida:

Criaremos a comida, que ficará em uma posição X e Y:

//Criação da comida
let appleX = (appleY = 15);

Atualizando o jogo:

Toda vez que chamamos a função, movemos a cobra em alguma próxima posição, e também verificar se a serpente não está fora dos limites do jogo e redefinir a posição para ela sair do outro lado. Essas verificações estarão dentro de uma função chamada desenharJogo():

 

function desenharJogo(){
    cobraEixoX += nextX;
    cobraEixoY += nextY;

    if (cobraEixoX < 0){
        cobraEixoX = tamanhoTela -1;
    }
    
    if (cobraEixoX > tamanhoTela - 1){
        cobraEixoX = 0;
    }
    
    if (cobraEixoY < 0){
        cobraEixoY = tamanhoTela -1;
    }
    
    if (cobraEixoY > tamanhoTela - 1){
        cobraEixoY = 0;
    }

}

Verificaremos se a cobra mordeu o alimento. Se isso acontecer, precisamos aumentar o tamanho da cauda da serpente e calcular uma nova posição:

//Se a cobra comer o alimento
    if (cobraEixoX == appleX && cobraEixoY == appleY){
        tamanhoCauda++;
        appleX = Math.floor(Math.random() * tamanhoTela);
        appleY = Math.floor(Math.random() * tamanhoTela);
    }

Agora, pintaremos o fundo do jogo de preto. Desenharemos a dobra, devemos também verificar se a cobra morde o próprio rabo, e também precisamos redefinir o tamanho da cauda para o tamanho inicial.

ctx.fillStyle = "black";
    ctx.fillRect(0, 0, canvas.width, canvas.height);

    ctx.fillStyle = "green";
    for (let i = 0; i < caminhoCobra.length; i++){
        ctx.fillRect(
            caminhoCobra[i].x * tamanhoCaminho,
            caminhoCobra[i].y * tamanhoCaminho,
            tamanhoCaminho,
            tamanhoCaminho
        );
        if (caminhoCobra[i].x == cobraEixoX && caminhoCobra[i].y == cobraEixoY){
            tamanhoCauda = defaultTamanhoCauda;
        }
    }

E pintaremos a maçã:

ctx.fillStyle = "red";
    ctx.fillRect(appleX * tamanhoCaminho, appleY * tamanhoCaminho, tamanhoCaminho, tamanhoCaminho);

E, no final, verificaremos se o caminho da cobra excede o tamanho da cauda. Caso isso aconteça, mudaremos as últimas posições para fora da trilha.

caminhoCobra.push({
        x:cobraEixoX,
        y:cobraEixoY
    });
    while (caminhoCobra.length > tamanhoCauda){
        caminhoCobra.shift(); }

E com isso, terminamos o nosso jogo!

O código está disponível para download aqui:

[download id=”3784″]

Conheça o Semantic UI

O Semantic UI é um framework de desenvolvimento web que auxilia o desenvolvedor a criar sites e sistemas web bonitos e responsivos de maneira rápida e intuitiva.

Ele trata palavras e classes como conceitos permutáveis. As classes utilizam a sintaxe de idiomas naturais, com relações substantivo/modificador, ordem de palavras e pluralidade para vincular conceitos intuitivamente.

O Semantic utiliza o JavaScript de forma simples, utilizando chamadas simples que acionam as funcionalidades. Qualquer decisão arbitrária em um componente é incluída como configuração que pode ser modificada pelos desenvolvedores.

Semantic UI também possui uma depuração simplificada, pois o registro de desempenho permite rastrear os gargalos sem procurar nos rastreamentos da stack.

Ele vem equipado com um sistema de herança intuitivo e variáveis temáticas de ato nível que permitem ao desenvolvedor possuir uma total liberdade de projeto, desenvolvendo uma interface de usuário uma vez e implantando com o mesmo código em qualquer lugar.

É projetado para ser dimensionado responsivamente, pois as variações de design que são incorporadas aos elementos permitem que você escolha como o conteúdo será ajustado, tanto para tablet como para celular.

Também possui integrações com as bibliotecas mais utilizadas na atualidade: React, Angular, Meteor e Ember, entre muitas outra que ajudam a organizar a UI ao lado da lógica do app.

INSTALAÇÃO:

Você pode utilizar o Gulp para instalar o Semantic UI no seu projeto com Node.js:

npm install -g gulp
npm install semantic-ui --save
cd semantic/
gulp build

Ou pode adicioná-lo diretamente no seu arquivo HTML:

<link rel="stylesheet" type="text/css" href="semantic/dist/semantic.min.css">
<script
  src="https://code.jquery.com/jquery-3.1.1.min.js"
  integrity="sha256-hVVnYaiADRTO2PzUGmuLJr8BLUSjGIZsDYGmIJLv2b8="
  crossorigin="anonymous"></script>
<script src="semantic/dist/semantic.min.js"></script>

Alguns elementos importantes do Semantic UI são:

Buttons:

Podemos facilmente criar buttons estilizados com apenas uma linha de HTML:

<button class="ui button active">Button</button>

Ou botões animados:

<div class="ui animated button" tabindex="0">
  <div class="visible content">Próximo</div>
  <div class="hidden content">
    <i class="right arrow icon"></i>
  </div>
</div>

Ícones:

Podemos adicionar ícones facilmente ao projeto:

<i class="american sign language interpreting icon"></i>
<i class="assistive listening systems icon"></i>
<i class="audio description icon"></i>
<i class="blind icon"></i>
<i class="braille icon"></i>

Listas:

<div class="ui list">
  <div class="item">Maçã</div>
  <div class="item">Peras</div>
  <div class="item">Laranjas</div>
</div>

Você pode verificar mais elementos diretamente no site: https://semantic-ui.com/

Gostou deste artigo? Comente abaixo!

Referências: https://semantic-ui.com/introduction/getting-started.html

Conheça o Deno, uma runtime JavaScript

O Deno é uma runtime simples, moderna e segura para JavaScript e TypeScript que utiliza o V8 e é construída em Rust.

Idealizado por Ryan Dahl, o criador do Node.js, o Deno é uma implementação totalmente nova, e não um novo fork do node.

A proposta do Deno é prover uma ferramenta standalone, ou seja, permite a criação de uma rápida solução para funcionalidades complexas, sendo sua abordagem a de um único arquivo executável.

  • O Deno é seguro por padrão. Não há acesso a arquivos, redes ou ambientes, a menos que seja explicitamente ativado;
  • Possui suporte ao TypeScript;
  • Envia apenas um único arquivo executável;
  • Possui utilitários embutidos, como um inspetor de dependências e um formatador de código;
  • Possui um conjunto de módulos padrão revisados que garantem o funcionamento com o Deno.

Como Instalar:

Para instalá-lo, você precisará usar os instaladores abaixo ou fazer o download de um binário da versão.

PowerShell (Windows)

iwr https://deno.land/x/install/install.ps1 -useb | iex

Shell (Max, Linux)

curl -fsSL https://deno.land/x/install/install.sh | sh

Chocolatey (Windows)

choco install deno

Iniciando com Deno:

Você pode tentar executar um programa simples dos próprios exemplos do Deno:

deno run https://deno.land/std/examples/welcome.ts

Ou realizar algo mais complexo:

import { serve } from "https://deno.land/std@0.54.0/http/server.ts";
const s = serve({ port: 8000 });
console.log("http://localhost:8000/");
for await (const req of s) {
  req.respond({ body: "Olá Mundo\n" });
}

Você encontra instruções mais detalhadas no manual.

Documentação da Runtime:

A documentação básica da runtime do Deno é encontrada em: doc.deno.land. O Deno vem com um manual que contém explicações detalhadas sobre as funções complexas da runtime, uma introdução aos conceitos nos quais o Deno foi construído e como incorporar o Deno no seu próprio aplicativo. Junto à runtime, também é oferecida uma lista de módulos padrão que são revisados pela equipe principal do Deno. O Deno também pode importar módulos a partir de qualquer localização na web, como o GitHub, Cnd, entre outros. O deno.land também oferece um serviço de hospedagem pública simples para módulos ES que funcionam com o Deno.

Gostou desta notícia? Comente abaixo!

MERN stack, o que é?

Você já ouviu falar no termo MERN stack?

Por definição, MERN significa:

  • (M) MongoDB;
  • (E) ExpressJs;
  • (R) React;
  • (N) Node.js;

Ou seja, é chamado de MERN stack o profissional que domina todas essas quatro tecnologias. É uma stack que permite a criação de sites/sistemas completos (back-end e front-end) utilizando JavaScript no lado do Cliente e lado do Servidor. Com isso, o desenvolvedor fica apto a criar sites/sistemas completos, sem precisar conhecer outra tecnologia ou utilizar outra habilidade. O MERN stack representa uma aliança das tecnologias mais poderosas do mercado, pois oferece a possibilidade de dominar a parte de algoritmos e lógica utilizada no back-end, juntamente com os componentes de design, UX e animações que o front-end é responsável. Isso traz uma competência para apenas um desenvolvedor, onde, normalmente, seriam exigidos dois.

Atualmente, com a alta utilização do JavaScript, o MERN stack é um dos profissionais mais requisitados no mercado.

E quais são as tecnologias utilizadas?

  • MongoDB: É um banco de dados não-relacional. É utilizado na MERN stack pois os dados são manipulados no formato JSON.
  • Node.js: O Node.js trabalha com JavaScript, ou seja, um desenvolvedor que conheça bem a linguagem JavaScript não terá dificuldades em aprender Node.js.
  • Express.js: Um middleware dedicado ao gerenciamento de apps web complexos, é usado para criação de API REST. A API REST corresponde a um site que recuperará dados por meio de solicitações HTTP.
  • React.js: Responsável pelo front-end, é uma biblioteca JavaScript desenvolvida e utilizada pelo Facebook. Responsável por fazer, de maneira extremamente rápida, animações, uploads e transições.

Assim como a MERN stack, também temos a MEAN stack onde o React não é utilizado, mas sim o Angular, alterando somente a biblioteca/framework utilizado no Front-end. Utilizando o Vue.js, teremos o MEVN stack, ou seja, são muitas as opções para quem quer dominar Front e Back-end utilizando JavaScript!.

Dominando essas tecnologias, você é um desenvolvedor MERN/MEAN/MEVN stack!

Gostou deste artigo? Comente abaixo!

Referências:

 

UPDATE e DELETE simples com MongoDB + NodeJS

Dando sequência ao CRUD com MongoDB e NodeJS, no artigo anterior foram mostrados os métodos CREATE e READ. Neste artigo, demonstrarei como fazer um UPDATE e DELETE básicos.

UPDATE

Você pode utilizar o método updateOne() para atualizar um documento na sua coleção, passando como parâmetro o objeto a ser atualizado. O segundo parâmetro é o objeto que define os novos valores do documento.

Se a consulta encontra mais de um registro, somente a primeira ocorrência será atualizada.

Para realizar este update, vamos salvar o nosso valor a ser alterado em uma variável chamada valorAntigo e, também, adicionar os novos valores em outra variável, chamada valorNovo. Feito isso, vamos passar essas duas variáveis como parâmetro do nosso método updateOne().

const MongoClient = require('mongodb').MongoClient;
const url = "mongodb://localhost:27017/mydb";

MongoClient.connect(url, function (err, db) {
    if (err) throw err;
    let dbo = db.db("mydb");
    let valorAntigo = {
        name: 'Usuario 1'
    };
    let valorNovo = { 
        $set: {
            name: 'Usuario Novo', endereco: 'Rua Nova' 
        } 
    };
    dbo.collection("clientes").updateOne(valorAntigo, valorNovo, function (err, res){
        if (err) throw err;
        console.log('Documento atualizado');
        db.close(); 
    });
});

Executando o arquivo, teremos uma mensagem no terminal, dizendo: “Documento atualizado”.

Podemos também apenas alterar um valor específico. Para isso, passamos à variável valorNovo apenas o novo valor do campo.

Você pode atualizar diversos campos utilizando o método updateMany().

Para verificar o seu documento atualizado, utilize o método find().

DELETE

Para excluirmos um documento, usamos o método deleteOne(), que especifica o documento a ser excluído. Devemos passar como parâmetro o campo do registro a ser excluído. Por exemplo, excluiremos o nosso “Usuario Novo”.

const MongoClient = require('mongodb').MongoClient;
const url = "mongodb://localhost:27017/mydb";

MongoClient.connect(url, function (err, db){
    if (err) throw err;
    let dbo = db.db('mydb');
    let excluirDocumento = { name: 'Usuario Novo' };
    dbo.collection('clientes').deleteOne(excluirDocumento, function(err, obj){
        if (err) throw err;
        console.log("1 documento deletado");
        db.close();
    });
});

E você deverá ver no seu terminal a mensagem: “1 documento deletado”.

Você pode utilizar o método deleteMany() para deletar múltiplos documentos.

Verifique, utilizando o método find(), que o seu registro está vazio.

Gostou deste artigo? Comente abaixo!

CREATE e READ simples com MongoDB + NodeJS

Neste artigo criarei um CREATE e READ básico utilizando MongoDB e Node.js. Caso você não conheça o MongoDB, recomendo a leitura deste artigo que explica como realizar as operações CREATE, READ, UPDATE e DELETE no shell do MongoDB.

O MongoDB é um NoSQL. Com o Node.js, iremos acessar o banco de dados usando o node. Crie uma pasta chamada crud_mongo e abra-a no code. Abra o terminal do code para prosseguir com o artigo.

Precisamos instalar o driver oficial do MongoDB. Utilizando o NPM, vamos baixar o pacote do Mongo.

npm install mongodb

Pronto. Agora temos o pacote instalado na nossa aplicação. Com isso, já é possível manipular bases de dados do MongoDB com o Nodejs.

CRIANDO A BASE DE DADOS

Para criar o banco de dados, vamos fazer uma requisição de um objeto MongoClient, especificando o URL de conexão com o endereço do localhost, a porta a ser utilizada e passando o nome da base de dados a ser criada.

const MongoClient = require('mongodb').MongoClient;
const url = "mongodb://localhost:27017/mydb";

MongoClient.connect(url, function(err, db){
    if (err) throw err;
    console.log("Banco de Dados criado!");
    db.close();
})

Execute o arquivo no seu servidor NodeJS. Você verá a mensagem: Banco de Dados Criado!

Observação: O banco de dados não é exatamente criado até que ele receba conteúdo. Vamos inserir conteúdo nesta base a seguir.

CRIANDO UMA COLEÇÃO

Para criar uma coleção na nossa base de dados, usaremos o método createCollection(). Neste médodo, passaremos o nome da coleção a ser criada.

const MongoClient = require('mongodb').MongoClient;
const url = "mongodb://localhost:27017/mydb";

MongoClient.connect(url, function (err, db) {
    if (err) throw err;
    let dbo = db.db("mydb");
    dbo.createCollection("clientes", function (err, res) {
        if (err) throw err;
        console.log("Coleção criada");
        db.close();
    });
});

E pronto, a nossa coleção foi criada!

INSERINDO DOCUMENTOS NA COLEÇÃO

Para inserir um documento (registro) na coleção, podemos utilizar o método insertOne() para registros simples, e insertMany() para registros múltiplos. Vamos realizar uma inserção de apenas um documento na nossa coleção:

const MongoClient = require('mongodb').MongoClient;
const url = "mongodb://localhost:27017/mydb";

MongoClient.connect(url, function (err, db) {
    if (err) throw err;
    let dbo = db.db("mydb");
    let myObj = {
        name: "Usuario 1",
        endereco: "Rua teste 1"
    };
    dbo.collection("clientes").insertOne(myObj, function (err, res) {
        if (err) throw err;
        console.log("Documento inserido");
        db.close();
    });
});

Se você tentar inserir documentos em uma coleção inexistente, o MongoDB criará a coleção automaticamente.

READ (find())

Para selecionar os dados de uma coleção no Mongo, podemos utilizar os métodos findOne() e find(), que seleciona um dado e todos os dados da coleção, respectivamente. Utilize o método toArray para retornar os elementos em um vetor.

const MongoClient = require('mongodb').MongoClient;
const url = "mongodb://localhost:27017/mydb";

MongoClient.connect(url, function (err, db) {
    if (err) throw err;
    let dbo = db.db("mydb");
    dbo.collection("clientes").find({}).toArray(function (err, result) {
        if (err) throw err;
        console.log(result);
        db.close();
    });
});

E nosso retorno será:

Com isso, já sabemos inserir e pesquisar dados no MongoDB utilizando o NodeJS.

Referência: https://www.w3schools.com/nodejs/nodejs_mongodb.asp

Até o próximo artigo pessoal!

Criando um Web Scraper com NodeJs

O Web Scraping é uma espécie de garimpo da internet. Esse “garimpo” envolve a extração de informações de determinado site. A ideia do Web Scraping é automatizar o trabalho usando bots, que coletam um maior número de dados em uma curta fração de tempo.

O processo de Web Scraping pode ser dividido em duas etapas principais:

  • Buscando o código-fonte HTML do site por meio de uma solicitação HTTP ou usando um navegador Headless;

  • Analisando os dados brutos para extrair apenas as informações de seu interesse.

Para realização deste tutorial, será necessário o Node.js na versão 8.x ou posterior e npm instalados no seu computador.

Vamos começar!

Crie uma pasta chamado scraper e inicie com o code. Abra o terminal do code e execute o comando:

npm init -y

Esse comando inicializará o projeto com um arquivo “package.json”. Deixe-o com seus padrões.

Agora, instalaremos as dependências que utilizaremos para criar o Web Scraper:

npm install axios cheerio puppeteer –save

O que cada dependência faz?

  • Axios: é um cliente HTTP baseado em Promises para Node.js;

  • Cheerio: implementação do jQuery para o Node.js. O Cheerio facilita a seleção, edição e exibição de elementos DOM;

  • Puppeteer: uma biblioteca Node.js para controlar o Chrome ou Chromium.

Web Scrap:

Para demonstrar como fazer Web Scrap em um site utilizando o Node.js, configuraremos um script para capturar algumas informações da tabela do Campeonato Carioca de 2020 (Taça Rio). Especificamente, capturaremos os principais goleadores da competição até o momento e organizaremos os dados como um JSON.

Crie um novo arquivo na sua pasta scrapper, chamado goleadorScrap.js.

1º Passo:

Faça as requisições do axios, cheerio e coloque a url em uma constante (Vamos utilizar o site do globoesporte para fazer esse Web Scrap):

const axios = require('axios');
const cheerio = require('cheerio');
const url = 'https://globoesporte.globo.com/rj/futebol/campeonato-carioca/';

Agora, precisamos utilizar o axios para realizar a leitura do nosso HTML. O axios nos traz uma longa sequência de HTML, mas como analisar esse HTML e extrair apenas os dados que queremos? Esse é o trabalho do Cheerio. Ele nos permite utilizar os métodos jQUery para analisar o HTML e extrair informações que desejamos com ele.

Abra o link e abra as ferramentas de desenvolvedor, pressionando a tecla f12 ou clicando com o botão direito do mouse e Inspecionando. Vamos trazer os dados dos artilheiros do Campeonato Carioca. Como você pode notar, o corpo da tabela possui uma div com classe chamada “ranking-item-wrapper”, que contém as informações de cada jogador. Precisamos de um vetor para armazenar essas informações. O código ficaria assim:

const axios = require('axios');
const cheerio = require('cheerio');
const url = 'https://globoesporte.globo.com/rj/futebol/campeonato-carioca/';

axios(url).then(response => {
    const html = response.data;
    const $ = cheerio.load(html);
    const tabelaStatus = $('.ranking-item-wrapper');
    const tabelaJogador = [];
}).catch(console.error);

Os dados que queremos capturar dessa tabela são:

  • Nome do jogador: criaremos uma constante chamada nomeJogador, que receberá o texto disponível na div com classe “jogador-nome”.

  • Posição do Jogador: qual a posição do jogador. Pegue a classe “jogador-posicao” e capture o seu conteúdo de texto;

  • Número de gols: a quantidade de gols que o jogador fez. Capture o conteúdo da classe “jogador-gols”;

  • Time do jogador: o time para qual o jogador pertence. Nesse atributo, precisamos capturar o texto “alt” da tag “img”, que está aninhada a uma div com classe “jogador-escudo”.

O código ficará assim:

const nomeJogador = $(this).find('.jogador-nome').text();
const posicaoJogador = $(this).find('.jogador-posicao').text();
const numeroGols = $(this).find('.jogador-gols').text();
const timeJogador = $(this).find('.jogador-escudo > img').attr('alt');

Agora, precisamos dar um push no nosso vetor. Para isso, usaremos um .each para criar um laço de repetição, colocando em cada posição do vetor, um objeto com os dados do jogador. Feito isso, mostraremos no console os dados de cada jogador!

Este é o código completo:

const axios = require('axios');
const cheerio = require('cheerio');
const url = 'https://globoesporte.globo.com/rj/futebol/campeonato-carioca/';

axios(url).then(response => {
    const html = response.data;
    const $ = cheerio.load(html);
    const tabelaStatus = $('.ranking-item-wrapper');
    const tabelaJogador = [];

    tabelaStatus.each(function(){
        const nomeJogador = $(this).find('.jogador-nome').text();
        const posicaoJogador = $(this).find('.jogador-posicao').text();
        const numeroGols = $(this).find('.jogador-gols').text();
        const timeJogador = $(this).find('.jogador-escudo > img').attr('alt');
        tabelaJogador.push({
            nomeJogador,
            posicaoJogador,
            numeroGols,
            timeJogador
        });
    });
    console.log(tabelaJogador);
}).catch(console.error);

Faça o teste! Veja o resultado no seu terminal!

Gostou deste exemplo? Comente abaixo!