Exercício fácil: DOM – Leitura

Neste exercício, armazenaremos elementos HTML em variáveis JavaScript! Para fazer isso, você pode usar o document.getElementById(), document.querySelector(), entre outros.

Exercício:

Crie as seguintes variáveis:

– titulo : conterá a primeira tag h1;

– descricao : conterá a tag com id = descricao;

– listaItens : conterá todas as tags com classe = itens;

Utilize o seguinte HTML como base para o seu exercício:

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Document</title>
</head>
<body>
    <h1>Titulo</h1>
    <p>subtítulo</p>
    <br/>
    <p id="descricao">Uma lista de itens</p>
    <br/>
    <ul>
        <li>Seus itens</li>
        <ol>
            <li class="itens">Livro</li>
            <li class="itens">Caneta</li>
            <li class="itens">Telefone</li>
            <li class="itens">Carteira</li>
        </ol>
        <li>Outros Itens</li>
        <ol>
            <li>N/A</li>
        </ol>
    </ul>
</body>
</html>
Dicas importantes:
  • Use a conotação (“.elemento”) para capturar por classe;
  • Use a conotação (“#elemento”) para capturar por ID;
  • Crie suas variáveis em um arquivo scripts.js;
  • Chame o seu arquivos scripts.js no seu arquivo index.html.
Confira o seu resultado:
let titulo = document.querySelector("h1");
let descricao = document.querySelector("#descricao");
let listaItens = document.querySelectorAll(".itens");

Gostou deste exercício? Teve dificuldade? Realizou de maneira diferente? Comente abaixo!

Exercício fácil: Multiplicando o Vetor

A função abaixo receberá 2 parâmetros, um vetor com apenas valores numéricos e um número.

Faça com que ela multiplique cada item do vetor pelo segundo parâmetro apenas se o item do vetor for maior que 5. Após isso, ela deve retornar o novo vetor.

Exemplo:

  • calcularVetor([1,5,10, 20], 2) retornará [2, 5, 20, 40] pois só 10 e 20 são maiores que 5.
  • calcularVetor([1,3,4, 5], 10) retornará [1, 3, 4, 5] pois nenhum é maior que 5.
  • calcularVetor([15, 20, 25, 30], 3) retornará [45, 60, 75, 90].

Utilize esta estrutura para realizar o exercício:

function calcularVetor(vetor, numero){
    //Seu código aqui
}

Continue lendo “Exercício fácil: Multiplicando o Vetor”

Richard Feldman e o futuro da web.

Richard Feldman, na ReactiveConf em Praga, fez algumas previsões sobre o futuro da Web até 2025. Ele afirma que aposta em prever as evoluções de tecnologias atuais, como TypeScript e WebAssembly.

Apesar de o TypeScript estar evoluindo gradativamente, ainda há muitas reclamações em relação à sua verbosidade, que afeta a legibilidade do código-fonte. Mas Feldman afirma que o TypeScript será a escolha mais comum entre os desenvolvedores de projetos comerciais.

Com relação ao WebAssembly, Feldman sustenta que o futuro não seja guiado pelo WebAssembly por conta de seu desempenho aprimorado. Ele acredita que o WebAssembly permitirá a concorrência com as lojas e instaladores de apps.

Com relação ao gerenciamento de pacotes, Feldman afirma que o npm continuará relevante, mas que até o final de 2025, ocorrerá algum incidente de segurança, infectando pelo menos um pacote malicioso e afetando muitos desenvolvedores.

Feldman acredita que as linguagens de compilação para o JavaScript estarão crescendo, mas nenhuma de modo tão rápido quanto o TypeScript.

Fonte: https://www.infoq.com/news/2019/11/reactiveconf-2019-web-prediction/

Gostou desta notícia? Comente abaixo!

Stealthy Tool detecta Malware em JavaScript

Uma nova ferramenta de código aberto chamada VisibleV8 permite que os usuários rastreiem e registrem o comportamento dos programas JavaScript sem alertar os sites que os executam.

A ferramenta é executada no navegador Chrome e foi projetada para detectar programas maliciosos capazes de escapar dos sistemas de detecção de Malware existentes.

“Quando você acessa a maioria dos sites, seu navegador começa a executar os programas JavaScript do site imediatamente – e você tem pouca ou nenhuma ideia do que esse JavaScript está fazendo”, diz o co-autor Alexandros Kapravelos, professor assistente de ciência da computação na Universidade Estadual da Carolina do Norte.

“Os sistemas de detecção de Malware avançados de última geração dependem de fazer alterações no código JavaScript para ver como o código está sendo executado. Mas essa abordagem é facilmente detectada, permitindo que programas de Malware alterem seu comportamento, a fim de evitar serem identificados como maliciosos ”, diz ele.

“O VisibleV8 é executado no próprio navegador, registrando como o JavaScript é executado; não interage com o código e, como resultado, é muito mais difícil de detectar. “

O VisibleV8 salva todos os dados sobre como um site está usando JavaScript, criando um “perfil de comportamento” para o site. Os pesquisadores podem usar esse perfil e todos os dados de suporte para identificar sites mal-intencionados e as várias maneiras pelas quais o JavaScript pode comprometer navegadores da web e informações do usuário. Como o VisibleV8 consiste em apenas 600 linhas de código, dentre os milhões de linhas de código no Chrome, a ferramenta de software é relativamente fácil de manter atualizada. Essa é uma consideração importante, pois o Google atualiza o código do Chrome aproximadamente a cada seis semanas. O VisibleV8 também pode direcionar os comportamentos maliciosos mais prováveis ​​sem prejudicar o desempenho do navegador.

Apple A13 supera Snapdragon 855 Plus em desempenho

A empresa AnandTech testou o Apple A13 e observou que ele supera o Snapdragon 855 e 855 Plus na pontuação de CPU, chip gráfico e aprendizado de máquina na maior parte dos benchmarks. Além disso, ele se aproxima da performance de processadores da Intel e AMD para desktop.

Como funcionam os testes?

Os testes Speedometer 2.0, JetStream 2 e WebXPRT 3 são rodados no navegador e medem, de formas diferentes, a capacidade de resposta de aplicações web. O WebXPRT se concentra no desempenho em HTML5 e JavaScript, enquanto o JetStream foca em JS e Web Assembly.

E, para medir a performance de inteligência artificial e aprendizado de máquina (ML), existe um benchmark chamado AIMark. O iPhone 11 Pro supera os concorrentes em três dos quatro testes; o Galaxy S10+ com Snapdragon 855 sai na frente em um deles.

No entanto, o S10+ com Exynos 9820 — primeiro chip da Samsung com engine de processamento neural — costuma ficar atrás do Snapdragon 855 e até mesmo de seu antecessor, o Snapdragon 845.

O site utilizou dois testes de comparação (maior é melhor):

  • SPECint2006: 52,82 pontos (Apple A13), 54,28 (Intel Core 9900K), 49,02 (AMD Ryzen 3900X)
  • SPECfp2006: 65,27 pontos (Apple A12), 75,15 (Intel Core 9900K), 73,66 (AMD Ryzen 3900X)

O A13 Bionic teve uma melhora de 20% no desempenho do CPU se comparado ao A12 da geração passada, presente no iPhone XS e XR. Nos benchmarks WebXPRT e Speedometer, o novo chip Apple A13 atinge o dobro da pontuação do Asus ROG Phone II com Snapdragon 855 Plus.

Nos testes de chip gráfico, o A13 Bionic também fica em primeiro lugar na maioria das vezes. Em diferentes testes do GFXBench, o iPhone 11 Pro e Pro Max têm desempenho maior que o Asus ROG Phone II com Snapdragon 855 Plus, enquanto o iPhone 11 supera também o OnePlus 7 Pro com Snapdragon 855.

Isso leva em conta a pontuação máxima e o desempenho sustentado, isto é, atingido após rodar uma série de renderizações por 10 a 15 minutos. Em algum momento, o sistema-em-um-chip é obrigado a reduzir a velocidade para controlar a temperatura e não derreter.

Em outro benchmark, o 3DMark Slingshot 3.1, o iPhone 11 atinge uma pontuação máxima maior que os concorrentes, mas não consegue sustentá-la, perdendo para o ROG Phone II e OnePlus 7 Pro.

AnandTech explica que isso ocorre porque a Apple não deixa seus celulares chegarem a temperaturas tão altas quanto nos Androids; a traseira do iPhone 11, 11 Pro e Pro Max não passou de 41°C.

Você pode conferir mais detalhes dos testes nos seguintes link:

the-apple-iphone-11-pro-and-max-review pt1

the-apple-iphone-11-pro-and-max-review pt2

Fonte: https://tecnoblog.net/311312/iphone-11-apple-a13-supera-snapdragon-855-testes-desempenho/

Versão do Electron 7.0.0 disponível!

O Electron 7.0.0 foi lançado! Ele inclui atualizações para o Chromium 78, V8 7.8 e Node.js 12.8.1. Foi adicionado uma versão do Window on Arm 64, métodos IPC mais rápidos, uma nova API nativeTheme, entre outros.

A equipe do Electron está animada com o anúncio do lançamento do Electron 7.0.0! Você pode instalá-lo com o npm via npm install electron ou fazer o download no site de lançamentos.

O lançamento está repleto de atualizações, correções e novos recursos.

Mudanças notáveis da atualização:

  • Stack Upgrades:

  • Adicionada versão do Windows on Arm (64 bits);
  • Adicionados ipcRenderer.invoke() e ipcMain.handle() para solicitações/estilo assíncronos de resposta para IPC. Estes são fortemente recomendados no módulo remoto;
  • Adicionada API nativeTheme para ler e responder a alterações no tema e esquema de cores do sistema operacional;
  • Mudou para um novo gerador de definições de TypeScript. As definições resultantes são mais precisas. Portanto, se sua compilação TypeScript falhar, essa é a causa provável.

Consulte as notas de versão 7.0.0 para obter uma lista mais longa de alterações.

Breaking Changes:

Mais informações sobre essas e futuras alterações podem ser encontradas na página Alterações planejadas de interrupção.

  • APIs descontinuadas removidas:
    • Versões de funções baseadas em retorno de chamada que agora usam o Promises;
    • setHighlightMode() (macOS);
    • enableMixedSandbox();
    • getApplicationMenu();
    • setApplicationMenu();
    • querySystemIdleState();
    • querySystemIdleTime();
    • setIsolatedWorldContentSecutiryPolicy();
    • setIsolatedWorldHumanReadableName(),
    • setIsolatedWorldSecurityOrigin().
  • clearAuthCache() não permite mais filtrar as entradas de cache limpas.
  • As interfaces nativas no macOS (menus, caixas de diálogo etc.) agora correspondem automaticamente à configuração do modo escuro na máquina do usuário.
  • Atualizado o módulo electron para usar @electron/get. A versão mínima do node suportado agora é o Node 8.
  • O arquivo electron.asar não existe mais. Quaisquer scripts de empacotamento que dependem de sua existência devem ser atualizados.

Fim do suporte para 4.x.y:

O Electron 4.x.y atingiu o fim do suporte de acordo com a política de suporte doprojeto. Os desenvolvedores e aplicativos são incentivados a atualizar para uma versão mais recente do Electron.

Programa de comentários sobre o APP:

Os projetos que participam deste programa testam os betas de Electron em seus aplicativos, e, em troca, os novos bugs encontrados são priorizados na versão estável.

O que vem por aí:

No curto prazo, a equipe continua a se concentrar em acompanhar o desenvolvimento dos principais componentes que compões o Electron, incluindo Chromium, Node e V8. O plano é lançar novas versões principais do Electron com novas versões desses componentes. O cronograma experimental 8.0.0 mapeia datas importantes no ciclo de vida de desenvolvimento do Electron 8. Consulte o documento do controle de versão para obter informações detalhadas sobre o controle de versão do Electron. Para mais informações, consulte o documento Breaking Changes.

Para mais informações veja o post original no link abaixo:
fonte: https://electronjs.org/blog/electron-7-0

Criando App em 3 minutos

 

No artigo de hoje, criaremos um APK para android rapidamente utilizando HTML, CSS e JavaScript.

Vamos Começar!

Primeiramente, criaremos um novo projeto em branco. Neste projeto, você deve criar um arquivo HTML. O nosso será index.html e terá esta estrutura:

<!DOCTYPE html>
<html lang="pt-br">
<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>App em 4 Minutos</title>
</head>
<body>
    
</body>
</html>

Podemos inserir um h1:

<h1>Olá Mundo</h1>

E também um botão:

<button>Clique aqui</button>

Após isso, adicionaremos um script JavaScript na página. Esse script adicionará uma função ao ser clicado o button, que irá disparar um alert.

document.querySelector("button").addEventListener("click", () =>{
    alert("Olá MundoJS!!!!!");
})

Na tag head, inserimos um css:

h1{
    font-size: 20px;
}

button{
    width: 100%;
    padding-top: 5px;
    padding-bottom: 10px;
}

Próximo passo:

Acessando o site http://build.phonegap.com, crie o seu login e acesse. Existem duas opções: open-source, onde você pode deixar seu app e códigos abertos para a comunidade, e a opção privada. Você pode utilizar o Pull do seu repositório GitHub e também pode adicionar um arquivo .zip com seus códigos.

Faremos o upload do nosso arquivo .zip. Feito o upload, adicionamos apenas uma descrição simples do aplicativo criado. Com esses poucos passos, criamos um arquivo .apk para android!

Depois disso, é só baixar o seu aplicativo clicando no botão Source! Você também pode acessá-lo diretamente do seu celular, utilizando o mesmo link da URL!

Baixando do celular, será necessário instalar o aplicativo .apk e realizar as permissões necessárias.

Confira as imagens:

E o APP criado:

O Adobe PhoneGap Build é um cloud service para compilar aplicativos PhoneGap. Ele fornece uma maneira dos usuários criarem aplicativos móveis utilizando HTML, CSS e JavaScript. Os aplicativos podem ser distribuídos em várias lojas de aplicativos, como Play Store, Apple iOS App Store, entre outros; E instalados no dispositivo do usuário final como qualquer outro aplicativo nativo. Ele oferece:

  • Compilação e assinatura gerenciadas (sem SDKs);
  • Várias plataformas suportadas;
  • Ciclo de desenvolvimento mais rápido;

Você pode ler toda a documentação do Adobe PhoneGap em: docs.phonegap.com/

Gostou deste Artigo? Deixe seu comentário abaixo!

Exercício Fácil: Do…While

Você pode executar o mesmo código várias vezes usando o loop while.

O loop Do..While executa primeiro o código dentro do loop, para depois executar o “while” com a condição especificada. Veja este exemplo:

let nossoArray = [];
let i = 0;

do {
  nossoArray.push(i);
  i++;
} while (i < 5);

Este loop retornará um vetor com resultado : [0, 1, 2, 3, 4]. Ele difere do loop while normal que possui a condição especificada no início do loop.

Este é um loop while normal que executará enquanto a variável i for menor que 5:

let nossoArray = [];
let i = 0;

while (i < 5){
  nossoArray.push(i);
  i++;
}

Observe que inicializamos o valor de i como 5. Quando executamos a próxima linha, notamos que i não é menor que 5. Portanto, não executamos o código dentro do loop. O resultado disso é que o vetor terminará com nada sendo adicionado a ele, portanto continuará vazio.

Agora, façamos o mesmo com o do…while:

let nossoArray = [];
let i = 5;

do {
  nossoArray.push(i);
  i++;
} while (i < 5);

Nesse caso, inicializamos o valor de i como 5, assim como no exemplo anterior. Quando chegamos à proxima linha, não há verificação do valor de i. Portanto, vamospara o código dentro do loop e executamos. Adicionaremos um elemento ao vetor e incrementaremos antes de chegar à verificação da condição. Então, quando verificamos se i < 5, vemos que agora i é 6, que falha na verificação da condicional. Então, saímos do loop e terminamos. O valor de retorno será [5]. O do…while garante que o código dentro do loop seja executado pelo menos uma vez.

EXERCÍCIO:

Altere o loop while no código para um loop do…while, para que adicione o número 10 para meuVetor e o i será 11 quando seu código finalizar.

REQUISITOS:

  • Você deve usar um loop do…while para este exercício;
  • meuVetor deve ser igual a [10];
  • i deve ser igual a 11.

Você pode visualizar o resultado no código abaixo:

let meuArray = [];
let i = 10;

// Altera o código apartir desta linha
do {
  meuArray.push(i);
  i++;
} while (i < 11) ;

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

JavaScript: Campos privados, classes estáticas e mais

Embora as classes estejam disponíveis para o JavaScript desde o ES2015, elas não incluem campos e métodos privados. Esses recursos foram descartados durante o release inicial devido a divergências no comitê do TC39. Três rascunhos de especificações pretendem levar esses recursos às classes JavaScript em um futuro próximo.

Depois que essas especificações forem formalmente aceitas, os campos e métodos privados poderão ser definidos usando o sinal de hash ‘#’. A decisão de usar o sinal de hash em vez do sublinhado mais tradicional ‘_’ foi tomada para evitar alterações nas bibliotecas existentes, que atualmente marcam os campos privados dessa maneira.

Isso pode parecer contra intuitivo, no entanto, apesar das bibliotecas marcarem campos ou métodos como privados usando o sublinhado, os desenvolvedores de sinal ainda os usam. Transformar essas variáveis em variáveis verdadeiramente privadas pode interromper vários aplicativos e, portanto, retardar a adaptação das novas especificações.

O problema pode ser demonstrado por uma anedota do React, que teve que recorrer a alguns nomes de variáveis bastante contundentes para impedir que os desenvolvedores os usassem (apesar de serem marcados como privados), como ‘_SECRET_DOM_DO_NOT_USE_ORYOU_WILL_BE_FIRED’. (Lê-se _DOM_SECRETO_NAO_USE_OU_VOCE_SERA_DEMITIDO ).

Cada uma das 3 propostas do TC39 aborda um aspecto diferente de campos e métodos privados nas classes. No entanto, deve ser seguro tratá-los como uma única proposta, pois provavelmente serão adicionados ao JavaScript ao mesmo tempo. As propostas são:

Declaração de campos da classe

Atualmente não é possível definir campos (variáveis) direto na classe. Ao invés disso, os desenvolvedores precisam fazê-lo diretamente no construtor da classe.

class Counter { 
  constructor() { 
    this.xValue = 0; 
  } 
}

A proposta pretende adicionar esta habilidade para escrever os campos diretamente na definição da classe.

class Counter { 
  xValue = 0;
  #yValue = 0;
  constructor() { }
}

Criação de métodos privados e de getter e setters privados para as classes.

Esta proposta pretende permitir a adição de métodos privados e o uso de getter e setter privados.

class Counter { 
  get #x() { return #xValue; } 
  set #x(value) { }

  #clicked() { } 
}

Funcionalidades de classes estáticas (static).

Esta proposta define como será implementado a funcionalidade de campos e métodos estáticos, podendo ser públicos ou privados.

class CustomDate { 
  static public() = {} 
  static #private() = {} 
}

Para mais informações veja o post original no link abaixo:

Fonte: https://www.infoq.com/news/2019/10/javascript-private-class-fields/