TypeScript: Named Parameters

Em uma das últimas atualizações do core do TypeScript, a equipe de desenvolvimento fez refactoring em uma funcionalidade chamada Named Parameters.

Para ficar mais claro como funciona essa funcionalidade, imagine o seguinte cenário: “Você tem uma model com algumas propriedades string, number … e precisa passar dados para ela:

function rolandGarros(
    typeMatch?: number,
    typeLabel?: string,
    round?: number,
    roundLabel?: string,
    courtName?: string,
    durationInMinutes?: number
) {
    return console.log(typeMatch, typeLabel, round, roundLabel, courtName, durationInMinutes);
};

Chamando a função rolandGarros:

rolandGarros(3, 'Draws', 1, 'First Round', 'Philippe-Chatrier Court', 10)

Nesse cenário é muito comum um dev passar o valor de uma propriedade no lugar da outra. Para resolver isso nós podemos utilizar o Named Parameters.

Veja abaixo como ficaria a nossa função:

function rolandGarros(
{ typeMatch, typeLabel, round, roundLabel, courtName, durationInMinutes }: { typeMatch?: number; typeLabel?: string; round?: number; roundLabel?: string; courtName?: string; durationInMinutes?: number; } = {}) {
    return console.log(typeMatch, typeLabel, round, roundLabel, courtName, durationInMinutes);
};

E como nós podemos fazer uma chamada:

rolandGarros({ typeMatch: 3, typeLabel: ‘Draws’, round: 1, roundLabel: ‘First Round’, courtName: ‘Philippe-Chatrier Court’, durationInMinutes: 10 })

Note que dessa forma nós podemos passar o nome da propriedade junto com o seu valor, dessa forma fica bem mais simples de olharmos e passar o valor de cada um dos parâmetros da nossa function.

E agora, como o TypeScript 3.4 ajuda nessa conversão?

A pedido de um dev da comunidade, o pessoal adicionou a funcionalidade “Convert parameters to destructured object“, onde com apenas um click ele já altera a nossa função e os locais onde nós estamos chamado ela. Abaixo você tem um vídeo demonstrando esse passo:

Bem legal né?

Essa é uma das funcionalidades que eu acredito ajudar muito no nosso dia dia.

Espero que tenham gostado e até o próximo artigo pessoal 😉

Diferenças entre innerHTML, innerText e textContent.

Você conhece a diferença entre innerText, textContent e innerHTML?

São utilizados na manipulação do DOM (Document Object Model). Cada uma destas propriedades retorna algo, e descobriremos o que elas retornam neste artigo.

Diferenças:

Utilizando o exemplo a seguir, criaremos as propriedades:

<!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>Exemplo innerHTML, innerText e textContent</title>
</head>
<body>
    <!-- Criando um parágrafo com formatação CSS inline nos textos -->
    <p id="textoHtml">
        <span style="display: none">Hakuna</span><strong>Matata</strong>
        <span style="visibility: hidden;">Mundo</span>
        <span>JS</span>
    </p>

    <script src="main.js"></script>
</body>
</html>

innerHTML:

Utilizado na manipulação do DOM, o innerHTML retorna todo o texto e o html que existem no elemento. Ele retorna todo o html existente, retornando também às tags, e não somente o texto.

// Criando uma variável que irá buscar o elemento HTML pelo Id
let exemploInner = document.getElementById("textoHtml");
        
console.log("------ USANDO innerHTML ------");
console.log(exemploInner.innerHTML);

Importante:

O innerHTML pode ser usado para inserção de tags, textos e imagens em uma página web, gerando um risco de segurança. Parecido com um cross-site scripting, mas inofensivo, pois o HTML5 especifica que uma tag <script> inserida via innerHTML em uma página web não deve ser executada. Entretanto, existem formas de executar JavaScript sem usar <script>, portanto, ainda há um risco de segurança ao utilizar o innerHTML. Por esta razão, recomenda-se não utilizar o innerHTML para inserção de texto puro.

innerText:

Já o innerText retorna apenas o texto. Ele ignora todas as tags HTML que estão dentro do elemento, mas ainda assim, “entende” o css do elemento, retornando apenas textos visíveis. Utiliza-se quando queremos buscar apenas o texto visível disponível no elemento.

console.log("------ USANDO innerText ------");
console.log(exemploInner.innerText);

textContent:

O textContent funciona de forma muito semelhante ao innerText, porém, retornando todo o conteúdo de texto, incluindo o texto oculto pelo css, bem como as quebras de linha (\n). Utilizamos o textContent quando queremos buscar todo o texto disponível no elemento.

console.log("------ USANDO textContent ------");
console.log(exemploInner.textContent);

Gostou deste artigo? Compartilhe com seus amigos e comente abaixo!

Node.js: monitorando APIs RESTful com o Application Insights

Dando continuidade aos meus artigos sobre Node.js no Azure, hoje eu irei demonstrar como monitorar uma API RESTful desenvolvida em node com TypeScript, utilizando o Application Insights.

Para aqueles que estão tendo o seu primeiro contanto com Application Insights nesse artigo, ele é um serviço de monitoramento de aplicações do Azure.

Com ele nós conseguimos medir a performance das nossas aplicações, extrair métricas de acesso por um range de tempo, detectar falhas … etc.

A ideia desse artigo será demonstrar como monitorar uma API RESTful desenvolvida em Node.js com TypeScript. Para isso, eu irei utilizar um gerador de APIs que eu desenvolvi utilizando essas tecnologias.

Caso tenha interesse em utilizar esse mesmo projeto, segue o seu link no portal NPM gerador-ts-api, e um vídeo passando alguns detalhes sobre essa estrutura:

Com o projeto OK, para os próximos passos será necessário ter uma conta no Azure. Caso você ainda não tenha uma, a Microsoft tem um programa chamado Visual Studio Dev Essentials que disponibiliza alguns benefícios como: créditos para serem utilizados no Azure, Visual Studio, acesso grátis por um período na Pluralsight… etc.

Caso tenha interesse em saber um pouco mais sobre esse programa, eu recomendo a leitura do seguinte artigo: Visual Studio Dev Essentials (Free).

Com o projeto criado e a sua subscription OK, vamos agora criar um novo serviço no Azure para monitorar a nossa aplicação. Para isso, acesse a sua conta, vá até-> Create resource -> Devops -> Application Insights e clique no botão Create.

Na próxima tela será necessário informar os dados da sua aplicação como: Nome, Resource Group … etc. Abaixo você tem uma imagem demonstrando como eu preenchi essa etapa para um evento presencial aqui em SP:

Clique em Create e aguarde a tela informando que o seu deploy está completo. Abaixo você tem uma imagem demonstrando essa etapa:

Agora clique no botão Go to resource -> vá até Overview e copie a sua instrumental Key:

Essa chave que irá vincular a nossa aplicação ao serviço no Azure.

Com a Key criada, vamos agora adicionar ela na nossa aplicação. Para isso, abra o seu projeto e siga os passos abaixo:

O primeiro passo será importar a biblioteca do applicationinsights para o nosso projeto. Para isso, abra um terminal, navegue até o seu projeto e execute o comando abaixo:

npm i applicationinsights --save

E no caso de estar seguindo esse passos em um projeto com TypeScript:

npm i @types/applicationinsights --save-dev

Agora abra o arquivo de inicialização do seu projeto, chame a biblioteca importada no passo anterior, em seguida inicialize ela com a sua instrumental Key:

const appInsights = require('applicationinsights'); 

appInsights.setup('<instrumentation_key>').start();

Caso esteja seguindo esses passos em um projeto gerado pelo o gerador-api-ts acima, basta abrir o arquivo startUp.ts e adicionar as linhas abaixo nele:

import * as appInsights from 'applicationinsights';
 // no inicio do arquivo
appInsights.setup('<instrumentation_key>').start();
 // no método middler

Monitorando a aplicação

Agora para que possamos monitorar a nossa aplicação, será necessário executar ela e abrir o serviço no Azure. Como eu estou utilizando a API gerado com o gerador mencionado acima, basta executar o comando npm run compile para gerar o dist do projeto e npm start para subir a aplicação.

Com o projeto rodando, vamos simular uma falha, uma chamada a uma rota/endpoint que não existe como por exemplo http://localhost:3050/api/v1/news.

Depois de alguns segundos acessando o portal conseguimos pegar o erro na chamada:

Como eu passei no inicio do artigo, nós podemos pegar métricas de acesso, performance … etc da nossa aplicação. Abaixo você tem um print demonstrando a performance da aplicação que eu estou utilizando nesse artigo:

Caso você tenha interesse em ver como retirar as outras métricas, como esse serviço funciona mais a fundo, eu recomendo a leitura do seguinte link na documentação da Microsoft: App-insights-overview.

Bom era isso pessoal, espero que tenham gostado e até um próximo artigo galera 😉

JavaScript Básico 17 – Projeto Calculadora (Parte 3)

Neste artigo, serão disponibilizados e explicados os códigos utilizados na parte três do nosso projeto de calculadora. Caso ainda não tenha visto as partes 1 e 2 do projeto da Calculadora, acesse e obtenha o HTML e CSS necessários para a criação do layout desta calculadora: JavaScript Básico 15 – Projeto Calculadora (Parte 1), JavaScript Básico 16 – Projeto Calculadora (Parte 2)

Dentro do nosso projeto, podemos começar criando uma função de soma, que irá receber dois valores como parâmetros e irá somá-los:

// Função que soma dois valores
function somarValores(valor1, valor2){
    return valor1 + valor2;
}

Após isso, criaremos uma função de subtração, que irá subtrair o segundo valor do primeiro valor:

// Função que subtrai o segundo valor do primeiro
function subtrairValores(valor1, valor2){
    return valor1 - valor2;
}

Criadas essas duas funções, podemos criar também uma função para multiplicar valores:

// Função que multiplica dois valores
function multiplcarValores(valor1, valor2){
    return valor1 * valor2;
}

Para criar a função de divisão, devemos:

  • Criar uma estrutura condicional;
  • Se o segundo valor for zero, retornar uma mensagem de erro.
// Função que divide o primeiro valor pelo segundo
function dividirValores(valor1, valor2){
    if(valor2 == 0){
        return "Erro, divisão por zero!";
    }else{
        return valor1 / valor2;
    }
}

 

Realizada a criação das funções, precisamos criar uma função específica para limpar os dados do input e os objetos de cálculo.

// Limpa todos os dados do input e objeto de calculo
function limparDados(){
    inputResultado.value = "";

    calculo.primeiroValor = 0;
    calculo.segundoValor = 0;
    calculo.funcaoParaCalcular = null;
}

Está gostando deste projeto? Deixe o seu comentário!
Bons estudos!

Calculadora (Parte 4)

Conheça o Phaser.JS, uma biblioteca de criação de jogos JavaScript

Você conhece a biblioteca Phaser.JS para criação de jogos em JavaScript?

Phaser é uma biblioteca para criação de jogos que foi idealizada pela Photon Storm. Com ela, podemos criar jogos que rodam tanto em ambiente mobile quanto desktops. Ela roda nos principais navegadores atuais de desktop. Em dispositivos móveis, é suportado no Chrome mobile, no navegador Safari (no IOS5 para cima). Acesse a biblioteca: phaser.io

Principais recursos:

O Phaser não utiliza nenhuma prática interna de orientação a objeto, não possui heranças de código e componentes. Mas você pode alterar as funções do Phaser.

Para renderização de gráficos, o Phaser utiliza o Pixi.js. Nos jogos, se o navegador suportar WebGL, o usuário terá uma melhor experiência. Os jogos em HTML5 caminham para o futuro de WebGL disponível em dispositivos móveis. Para isso acontecer, é apenas uma questão de tempo.

O carregamento do Phaser suporta:

  1. Imagens;

  2. Sprite Sheets;

  3. Texture Atlases;

  4. Arquivos de áudio;

  5. Arquivos de dados;

  6. Arquivos JavaScript;

  7. Tilemaps;

  8. Fontes Bitmap.

Áudio:

Com a WebAudio API, podemos ter uma integração apropriada de áudio, com múltiplas rotas, canais e os mais variados tipos de efeitos.

Inputs:

Multi-Touch, Keyboard, Pointer e Mouse: O Phaser suporta os mais variados tipos de inputs, como toques na tela, cliques de mouse, teclas pressionadas, entre outros.

Continue lendo “Conheça o Phaser.JS, uma biblioteca de criação de jogos JavaScript”

JavaScript Básico 16 – Projeto Calculadora (Parte 2)

Neste artigo, serão disponibilizados e explicados os códigos utilizados na parte dois do nosso projeto de calculadora. Caso ainda não tenha visto a Parte 1 do projeto da Calculadora, acesse e obtenha o HTML e CSS necessários para a criação do layout desta calculadora: JavaScript Básico 15 – Projeto Calculadora (Parte 1)

Dentro de nosso projeto, precisamos criar uma variável para mostrar os elementos no nosso display.

// Criando uma variável para capturar o elemento
// do HTML pelo Id. Este elemento mostrará os valores no display.
let inputResultado = document.getElementById("inputDisplayResultado");

Após isso, criaremos um objeto com os dados e a função para calcular.

// Objeto para mantermos controle dos dados e funcão para calcular.
let calculo = {
    primeiroValor: 0,
    segundoValor: 0,
    funcaoParaCalular: null
}

Utilizando o window.addEventListener, ao carregar a janela, inicializaremos todos os métodos e variáveis criados:

// Ao carregar a janela, inicializa os métodos e variaveis
window.addEventListener("load", function () {
    atribuirEventos();
})

Agora, precisamos de uma função para a inserção de números na tela. Para isso:

  • Utilizaremos o inputResultado.value para exibir os valores preenchidos pelo usuário no display.
  • Se este valor não for um número, ele será substituído pelo próximo número clicado.
  • Se o valor for zero, também será substituído pelo próximo número clicado.
  • Se o valor for diferente de zero e for um número, a calculadora adicionará este número ao input, para que as operações sejam realizadas.
// Adiciona o número na tela
function inserirNumero() {
    // Se o valor na tela não for um número,
    // substitui pelo número/valor do botão
    if (isNaN(inputResultado.value)) {
        inputResultado.value = event.target.textContent;
        // Senão, adiciona o texto junto com o existente
    } else {
        // Se o valor na tela for zero, substitui o valor na tela pelo número clicado
        if (inputResultado.value == 0) {
            inputResultado.value = event.target.textContent;
        // Senão adiciona o número ao input para criar digitos maiores que 0
        } else {
            inputResultado.value += event.target.textContent;
        }
    }
}

Adicionaremos a função inserirNumero no evento de click de cada um dos botões de números da calculadora, para que, assim que clicados, o valor do respectivo botão apareça na tela do usuário.

//Atribui os eventos a todos os botões da calculadora
function atribuirEventos() {
    //Atribui eventos aos números
    document.getElementById("btnValor0").addEventListener("click", inserirNumero);
    document.getElementById("btnValor1").addEventListener("click", inserirNumero);
    document.getElementById("btnValor2").addEventListener("click", inserirNumero);
    document.getElementById("btnValor3").addEventListener("click", inserirNumero);
    document.getElementById("btnValor4").addEventListener("click", inserirNumero);
    document.getElementById("btnValor5").addEventListener("click", inserirNumero);
    document.getElementById("btnValor6").addEventListener("click", inserirNumero);
    document.getElementById("btnValor7").addEventListener("click", inserirNumero);
    document.getElementById("btnValor8").addEventListener("click", inserirNumero);
    document.getElementById("btnValor9").addEventListener("click", inserirNumero);
}

Está gostando deste projeto? Deixe o seu comentário!
Bons estudos!

Calculadora (Parte 3)

Angular 8.0

Veja nesse artigo as principais novidades dessa nova versão do Angular.

Já faz um tempo que eu estou brincando com essa versão do Angular em RC. Eu atualizei o meu ambiente para essa versão para testar a nova versão do TypeScript e indo já indo para primeira novidade do Angular 8, nesse update nós podemos trabalhar com o TS na versão 3.4 😉

Caso você não tenha visto nada dessa nova versão do TS 3.4, eu recomendo a leitura dos seguintes links abaixo:

E indo para a próxima novidade, nessa versão foi removido o pacote @angular/http. Esse pacote estava deprecated desde de a versão 5.0, desde de essa versão nós deveríamos estar utilizando o pacote @angular/common/http.

Novidades nos Forms

markAllAsTouched

Nessa versão foi adicionado um novo método dentro da class AbstractControl chamado markAllAsTouched. Esse método é parecido com o markAsTouched das versões anteriores, a diferença é que esse método marca todos controles do nosso form como touched.

Sintaxe

form.markAllAsTouched();

Caso você tenha interesse em saber mais sobre AbstractControl, eu recomendo a leitura do seguinte do seguinte link: Angular-AbstractControl.

clear

Para o pessoal que já trabalha com o Angular a um tempo, com certeza já deve ter feito algo como no exemplo abaixo para limpar um form.

while (formArray.length) {
  formArray.removeAt(0);
}

Nessa versão nós podemos utilizar o .clear() para limpar todos elementos de uma só vez 😉

Sintaxe

formArray.clear()

Rotas

Nessa versão foi adicionado uma nova sintaxe para declaração de rotas com lazy-loading.

Agora ao invés de declaramos assim:

loadChildren: './news/news.module#NewsModule'

Nós declaramos com o import:

loadChildren: () => import('./races/races.module').then(m => m.RacesModule)

Essa sintaxe com import() já é utilizada nas versões anteriores do TypeScript.

Ivy

Essa sem dúvidas foi uma das atualizações mais esperadas. Eu estou escrevendo um artigo focando nele, mas caso esse seja o seu primeiro contato com ele, o Ivy é o novo compilador do Angular 😉

Bom galera, esse foi um post rápido com foco em alguns dos updates dessa nova versão.

Referências

alligator.io

Node.js: importando dados de um arquivo .csv para o mongoDB

Quem nunca precisou abrir arquivo para importar o seus dados para uma base de dados? Esse é um processo simples que ajuda muito outras equipes como de RH, Financeiro … etc.

Hoje eu irei demonstrar como importar dados de um arquivo .csv com algumas das batalhas que ocorreram na serie GOT (Game of Thrones), utilizando o Node.js e uma base de dados mongoDB.

Para pular a etapa de criação de um novo projeto eu irei utilizar a versão final desse artigo. Caso tenha interesse em clonar esse projeto, segue o seu link no meu GitHub: node-csv-mongodb.

O projeto está bem simples, abaixo você tem uma breve explicação de cada um dos arquivos utilizados.

Analisando ela nós temos:

  • config/db: arquivo de conexão com a nossa base de dados
  • models/battles.js: model contendo os campos do arquivo .csv
  • repository/battleRepository: arquivo de mapeamento da model com a collection do banco de dados
  • battles.csv: arquivo contendo algumas das batalhas que ocorreram na série GOT
  • index.js: nós iremos explorar esse arquivo melhor, mas por hora ele é o responsável por abrir o arquivo .csv e importar os dados para o nosso banco de dados

Abra o projeto no seu editor de textos preferido, em seguida adicione a sua string de conexão no arquivo db.js. Com essa etapa OK, vamos analisar o arquivo index.js:

const db = require('./config/db');
const battleRepository = require('./repository/battleRepository');

const csv = require('csv-parser');
const fs = require('fs');

fs.createReadStream('./battles.csv')
    .pipe(csv())
    .on('data', (row) => {
        battleRepository.create(row);
    })
    .on('end', () => {
        console.log('CSV file successfully processed')
    });

Analisando esse trecho de código nós temos:

  • 01: estamos importando o arquivo db.js com a nossa conexão com o db
  • 02: estamos importando o nosso repository, ele será responsável pelas nossas queries.
  • 04 e 05: importando os pacotes (fs) e (csv-parser) para manipularmos o arquivo .csv
  • 07 até a 14: estamos passando o caminho do arquivo que iremos manipular -> abrindo ele -> passando os dados para o método .create do nosso repository para ele salvar os dados no db, assim que ele finalizar irá retornar a mensagem: ‘CSV file successfully processed’.

Para ficar mais clara essa etapa, comente a linha 11 do arquivo e adicione um console.log(row); no lugar, em seguida execute o comando node index.js. Abaixo você tem uma imagem demonstrando esse passo:

Note que ele passa por cada uma das linhas do arquivo e retorna cada uma deles na row. Agora descomente a linha 11 e execute o comando node index.js novamente.

Para verificar se os dados foram importados corretamente, eu irei utilizar o Robo 3T para conectar na minha base de dados. Abaixo você tem uma imagem demonstrando esse passo:

Note que todos os arquivos formam importados corretamente.

Bom, a ideia desse artigo era ser algo rápido para demonstrar como importar um arquivo .csv em um banco de dados mongoDB.

Espero que tenham gostado e até um próximo artigo pessoal.

RabbitMQ criando workers com Node.js

Introdução

Dando continuidade a minha serie de artigos sobre RabbitMQ, hoje irei apresentar uma de suas formas de implementação, os workers. Caso tenha interesse em saber um pouco mais sobre os Workers ou ler os primeiros artigos dessa série, eu recomendo a leitura dos artigos abaixo:

Para que você possa ter um melhor entendimento, eu irei criar um exemplo utilizando o Node.js e o RabbitMQ dentro de um container Docker.

O primeiro passo é ter o RabbitMQ instalado, como mencionado acima eu irei utilizar o RabbitMQ dentro de em um container Docker. Caso você ainda não tenha esse ambiente, eu recomendo a leitura do segundo link que eu passei acima, la eu demonstro como criar esse ambiente.

Criação do projeto

Abra um terminal no seu computador, em seguida escolha um local para criação do seu projeto. Navegue até ele via terminal e execute o comando abaixo:

npm init -y

Esse comando irá inicializar o seu projeto criando um arquivo chamado package.json. Agora vamos baixar o pacote do RabbitMQ. Para isso, execute o comando abaixo no seu terminal:

npm install amqplib --save

Com o projeto criado e a biblioteca do amqplib importada, vamos criar dois novos arquivos no nosso projeto.

O primeiro será o arquivo da nossa aplicação, para esse artigo eu irei chamar ele de app.js. Crie ele na raiz do seu projeto, em seguida atualize ele com o trecho de código abaixo:

var amqp = require('amqplib/callback_api');

amqp.connect('amqp://localhost:5672', function (err, conn) {
    conn.createChannel(function (err, ch) {
        var q = 'hello';
        var msg = 'Hello World 123!';
        ch.assertQueue(q, { durable: false });     
        ch.sendToQueue(q, new Buffer(msg));
        console.log(" [x] Sent %s", msg);
    });
    setTimeout(function () { conn.close(); process.exit(0) }, 500);
});

Analisando o código acima você tem:

Agora vamos criar os nossos Workers. Para isso, crie um novo arquivo chamado worker.js na raiz do seu projeto e atualize ele com o seguinte trecho de código:

var amqp = require('amqplib/callback_api');

amqp.connect('amqp://localhost:5672', function (err, conn) {
    conn.createChannel(function (err, ch) {
        var q = 'hello';

        ch.assertQueue(q, { durable: false });
        ch.prefetch(1);
        console.log(" [*] Waiting for messages in %s. To exit press CTRL+C", q);
        ch.consume(q, function (msg) {
            console.log(" [x] Received %s", msg.content.toString());
        }, { noAck: true });
    });
});

Analisando esse código você tem:

Testando o código

Agora para testar o nosso código, abra 3 terminais no seu computador, navegue até o seu projeto e siga os passos abaixo:

Terminal 01

Execute o comando abaixo para criar o seu primeiro worker:

node worker.js

Terminal 02

Execute o comando abaixo para criar o seu segundo worker:

node worker.js

Terminal 03

Execute o comando abaixo para criar a sua aplicação e enviar a primeira mensagem para sua fila.

Obs.: O RabbitMQ trabalha com o conceito de Round Robin, logo o worker 1 pode não ser o primeiro a consumir a sua fila

node app.js

Abaixo você tem um vídeo demonstrando esse passo:

O intuito desse artigo foi demonstrar como trabalhar com os Workers do RabbitMQ utilizando o Node.js. Caso tenha interesse em baixar o código desenvolvido nesse artigo, segue o seu link no meu GitHub: Node-RabbitMQ-Workers.

Espero que tenham gostado e até um próximo artigo pessoal.

Conheça MelonJS, a biblioteca para criação de jogos JavaScript

Você conhece a biblioteca melonJS para criação de jogos em HTML5 e JavaScript?

Conheça o MelonJS, um mecanismo de desenvolvimento de jogos em HTML5 que capacita desenvolvedores e designers a se concentrarem no conteúdo.

A biblioteca fornece uma coleção de entidades compostas e suporte para ferramentas de terceiros, dando-lhe ima combinação poderosa que pode ser usada por atacado ou fragmentada.

O melonJS possui os seguintes recursos:

  • Um novo e leve mecanismo baseado em sprites 2D;
  • Biblioteca autônoma (não depende de mais nada, exceto de um navegador compatível com HTML5);
  • Compatível com a maioria dos principais navegadores (Chrome, Safari, Firefox, Opera, IE) e dispositivos móveis;
  • Renderização rápida de Canvas e WebGL em computadores e dispositivos móveis;
  • Resolução de alta DPI e dimensionamento automático de tela;
  • Suporte de áudio HTML5 multicanal e Web Audio em dispositivos suportados;
  • Leve implementação físic, garantindo baixos requisitos de cpu;
  • Algoritmo de colisão baseado em polígono (SAT) para detecção e respostas precisas;
  • Detecção rápida de colisão de fase ampla, usando particionamento espacial;
  • Suporte a ferramentas de terceiros para definição de corpo físico (PhysicEditor, Physic Body Editor);
  • API de matemática avançada para vetor e matriz;
  • Efeitos de interpolação;

Continue lendo “Conheça MelonJS, a biblioteca para criação de jogos JavaScript”