Exercício – Rotacionando vetor

Um vetor é um conjunto de dados que pode armazenar vários dados em apenas um lugar. Por exemplo, em um vetor, podemos armazenar uma lista de itens de, por exemplo, uma lista de compras.

Uma lista de compras armazenada em um vetor seria algo como:

let listaDeCompras = ["arroz", "massa", "carne", "alface"];

Um vetor também pode ser criado vazio e, depois, utilizando métodos de inserção, podemos inserir itens neste vetor.

let vetor = [];

Podemos inserir no vetor utilizando o método push(), e remover itens usando o método pop().

O método push() adiciona um valor ao fim do vetor, e o método pop() remove o elemento do final do vetor. Também temos outros métodos, por exemplo:

  • unshift(): adiciona um elemento na primeira posição do vetor;
  • shift(): remove o elemento na primeira posição do vetor.

Entre outros métodos. Você pode verificar os outros métodos em: https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Array

Exercício:

Neste exercício, criaremos uma função que rotaciona o nosso vetor. Levaremos em consideração as letras do alfabeto, de A a E.

let vetorAlfabeto = ["A", "B", "C", "D", "E"];

O que queremos que aconteça é: rotacionar o vetor a quantidade de vezes indicada. Essa quantidade será representada pela letra Q.

Caso o valor apresentado por Q for 1, o array deverá rotacionar um elemento:

["E", "A", "B", "C", "D"]

Para realizar esse exercício, você precisará:

  • Criar uma função rotacao(), que receberá dois parâmetros. O vetor e a quantidade (V, Q);
  • Adicione um índice para percorrer o vetor;
  • Caso o vetor passado por parâmetro for um vetor vazio, retorne um vetor vazio.

Solução:

Você pode fazer o download da solução aqui:

[download id=”4138″]

Você sabe o que significa NPM?

O NPM, ou Node Package Manager, é um repositório online com a finalidade de publicação de projetos NodeJS de código aberto. Podemos utilizar o npm como um utilitário de linhas de comando, interagindo com os repositórios e instalando os seus pacotes. Isso auxilia diretamente na instalação, controle de gerenciamento de versão e dependências dos projetos. Existem muitos aplicativos e bibliotecas publicados no npm, com novidades sendo adicionadas todos os dias. Você pode pesquisar essas bibliotecas e dependências em: https://npmjs.org.

Para instalar uma biblioteca, você só precisará executar o comando:

npm install nome_do_pacote

Assim que estiver instalado, você pode verificar a existência da biblioteca ou dependência na pasta node_modules e você usa o comando require() para adicioná-lo à sua página.

Para adicionar algo globalmente, você pode adicionar o comando -g à sintaxe. Isso instalará o programa em um local, e adicionará um link a ele, permitindo a utilização do programa no console, como qualquer outra ferramenta CLI.

Como um gerenciador de dependências, você possuirá um arquivo package.json no seu projeto nodejs. Executando o comando:

npm install

Utilizando esse comando na pasta raiz do seu projeto, assim o npm instalará todas as dependências que são listadas no arquivo package.json. Depois de executar este comando, você pode verificar na pasta node_modules que todas as dependências que são especificadas no package.json estarão instaladas.

home

Com o comando home, você pode abrir o site da biblioteca que você está tentando instalar. O site será aberto no seu navegador padrão. Por exemplo, utilizaremos o React Native como exemplo:

npm home react-native

Após executar este comando, a página de documentação do React Native no GitHub será aberta!

init

O comando init nos permite iniciar um arquivo package.json. Na criação deste arquivo, são feitas diversas perguntas. Mas você também pode pular todo o questionário adicionando um -y ao comando!

npm init -y

Lista de pacotes

Podemos verificar a lista de pacotes instalados no nosso projeto utilizando o comando:

npm ls --depth 0

E também podemos verificar quais são as bibliotecas ou dependências instaladas globalmente na nossa máquina utilizando o comando:

npm ls -g --depth 0

Gostou deste artigo? Comente abaixo e compartilhe com os seus amigos!

Referências:

Referências: https://nodejs.org/en/knowledge/getting-started/npm/what-is-npm/

Exercício – Maior espaço entre letras

Um binary gap é uma sequência de bits consecutivos do mesmo valor (1 ou 0) que são circundados por bits de valores opostos. Por exemplo, o número 14512 (11100010110000) tem duas lacunas binárias 0, uma de comprimento 3 e outra de comprimento 1.

Portanto, o comprimento máximo de um intervalo binário (binary gap) é o comprimento do intervalo mais longo dentro da representação binária do número.

O número 9, tem representação binária 1001, contendo uma binary gap de tamanho 2. O número 529 possui uma representação binária 1000010001 e possui duas gap’s: uma com comprimento 4 e outra com comprimento 3.

Exercício

Construa uma função que, dado uma string, retorna o tamanho do seu maior intervalo entre as letras. Caso não existam intervalos entre as letras A e B, retorne 0.

Para realizar este exercício, você vai precisar:

  • Construir uma função chamada lacuna, que receberá como parâmetro uma String.
  • Iterar a string;
  • Encontrar o primeiro valor A no binário adicionado;
  • Encontrar a quantidade de B entre A.

Você pode fazer o download da solução aqui:

[download id=”4132″]

Nova versão – MOBX 6

O MobX é uma biblioteca responsável por gerenciamento de estado simples e escalável. Aplica este gerenciamento e escalonamento de forma transparente a programação reativa funcional.

O MobX já possui 5 anos. Já foi adotado por empresas como Microsoft(Outlook), Netflix, Amazon e E.A. Games (Battlefield). Ele possui a mesma filosofia desde o início. Se algo pode ser derivado pelo estado do aplicativo, será derivado automaticamente.

Em contraste a isso, o ecossistema JavaScript mudou significativamente ao longo dos anos. No entanto, propostas do JavaScript como observables, Object.observe e decorators nunca foram materializados. O MobX 6 é uma versão que não traz muitos novos recursos, mas sim uma consolidação em consideração ao estado atual do JavaScript.

Adeus Decorators!

Usar decorators não é mais regra no MobX. Quando começou, o MobX era um projeto do TypeScript e utilizava decorators. Atualmente, as implementações experimentais do decorator são incompatíveis com a proposta de campos de classe que logo será padronizada. As implementações de decorator legado (Babel) e experimental (TypeScript) não serão capazes de interceptar inicializações de campos de classe. Mas como ficará o MobX depois dos decorators?

Em vez de usar decorator nos membros durante a definição de classe, os membros da instância precisam  ser anotados no construtor, usando o utilitário makeObservable.

import {observable, computed, action, makeObservable} from "mobx"

// Antes:
class TodoStore {
    @observable
    todos: Todo[] = []

    @computed
    get unfinishedTodoCount() {
        return this.todos.filter(todo => !todo.done).length
    }

    @action
    addTodo(todo: Todo) {
        this.todos.push(todo)
    }
}

// Depois:
class TodoStore {
    todos: Todo[] = []

    constructor() {
        makeObservable(this, {
            todos: observable,
            unfinishedTodoCount: computed,
            addTodo: action
        })
    }

    get unfinishedTodoCount() {
        return this.todos.filter(todo => !todo.done).length
    }

    addTodo(todo: Todo) {
        this.todos.push(todo)
    }
}

O makeObservable não requer configurações de compilação sofisticadas. Migrar uma base de código que use diversos decorators para makeObservable pode ser um desafio. O MobX vem com um mod de código para fazer isso automaticamente. Utilizando o comando:

npm mobx-undecorate

Utilizando este comando, todos os decorators da pasta de origem serão reescritos automaticamente! Depois, atualize sua configuração TypeScript/Babel e estará tudo pronto para prosseguir.

Documentação nova!

Com a retirada da norma de utilização de decorators, a documentação foi revisada e reestruturada, sendo mais curta, com menor repetição e discutindo melhor os cenários comuns.

Suporte a navegador aprimorado

O MobX 6 suporta mais mecanismos JavaScript que o MobX 5. O 5 exigia suporte de proxy, tornando-o inadequado para Internet Explorer e React Native, por isso, o Mobx 4 era mantido ativamente. No entanto, o MobX 6 substitui os dois. Ele ainda exigirá Proxies, mas será possível cancelar o uso do Proxy caso precise oferecer suporte a mecanismos mais antigos.

Você pode verificar mais novidades em:

Gostou desta notícia? Comente abaixo!

Referência: https://michel.codes/blogs/mobx6

NativeScript 7.0 – Lançamento

A versão 7.0 do NativeScript é um passo decisivo para o framework, pois alinha-se com os padrões do JavaScript moderno, trazendo consistência para a stack. O NativeScript 7.0 fornece uma capacidade de atualizações mais eficientes com as mudanças no ecossistema JavaScript, reinando em uma varredura holística sobre o gerenciamento do código aberto em torno do framework.

Para instalar o NativeScript via npm:

npm i -g nativescript

O NativeScript possui novos aliases cli:

  • ns – O novo padrão;
  • nsc – “Compilador NativeScript”;
  • tns – funciona por razões históricas.

O novo comando clean garante que os arquivos de projeto sejam limpos quando necessário. Você pode usar o comando:

ns clean

Você precisa verificar se os plug-ins dos seus projetos possuem compatibilidade com o NativeScript 7 antes de migrar. Você também deve olhar o guia de referência para importação para nivelar quaisquer informações que seu projeto possa utilizar.

Com a segmentação do es2017 e posteriores, é permitido um código mais rápido e com melhor desempenho. O motor v8 usado no NativeScript sempre teve suporte de ponta para o ES mais recente.

Vários pacotes do npm também foram definidos, incluindo plug-ins para ajudar a esclarecer o que é compatívelcom NativeScript 7.

@NativeClass() decorator

Necessário apenas se você estiver usando TypeScript e estendendo uma classe nativa. Se você estiver usando JavaScript puro, use a função .extend().

Um dos recursos mais atraentes do NativeScript é estender as classes nativas diretamente no JavaScript. Mas o JavaScript não sabe como estender uma classe nativa por conta própria. No ES2017, extends é suportado nativamente e, portanto, deixa de fora o __extends necessário para os tempos de execução e esta é uma oportunidade perfeita pra usar o decorator.

nsconfig.json -> nativescript.config.ts

Há muito tempo existe uma key nativescript na raiz de qualquer aplicativo package.json, para gerenciar as id’s do pacote de aplicações e versões de runtime. Havia também outro package.json embutido no diretório src que continha sinalizadores de runtime. Também existia um arquivo chamado nsconfig.json, que continha outras configurações de aplicativo. Agora, no NativeScript 7, isso tudo é consolidade em um único arquivo nativescript.config.ts!

engine v8 iOS

No NativeScript 7.0, a runtime padrão do iOS usa o mesmo mecanismo v8, ajudando a melhorar a manutenção em tempos de execução.

Para conhecer mais novidades sobre o NativeScript 7, acesse a página de novidades.

Referências: https://nativescript.org/blog/nativescript-7-announcement/

Gostou desta notícia? Comente abaixo!

O que são React Components & Props

Componentes são como funções que retornam elementos HTML.

Os componentes são partes independentes e reutilizáveis de código. Eles possuem o mesmo propósito que as funções JavaScript, mas trabalham de forma isolada e retornam elementos HTML por uma função render.

Eles possuem dois tipos, chamados Componentes de Classes e Componentes de Funções.

Function Components

Um Function Component nada mais é do que uma função JavaScript que retorna um elemento JSX (leia este artigo se você não conhece JSX).

Por exemplo:

import React from 'react';

function ThisComponent(){
    const component = 'Olá Mundo! Eu sou um Componente!';
    return <h1>{component}</h1>;
}

export default ThisComponent;

Se você quer renderizar um React Component dentro de uma Function Component, você pode definir outro componente e renderizá-lo com HTML utilizando JSX:

import React from 'react';

function App(){
    return <ThisComponent />;
}

function ThisComponent(){
    const component = 'Olá Mundo! Eu sou um Componente!';
    return <h1>{component}</h1>;
}

export default App;

Deste modo, você tem um Componente Filho. Você consegue decidir como e onde renderizar um componente.

Class Component

Quando criamos um componente React, o nome do componente deve iniciar com uma letra maiúscula. Ao criar um Class Component, precisamos incluir o extends React.Component, pois este componente cria uma herança para o React.Component, criando um acesso às funções do React Component.

Criando um Class Component, precisamos do método render() para retornar HTML. Por exemplo:

class Pessoa extends React.Component {
    render(){
        return <h1>Olá, eu sou uma Pessoa!</h1>;
    }
}

Agora você tem um componente chamado Pessoa que retorna um elemento H1. Para usar este componente na aplicação, é só utilizar a sintaxe:

ReactDOM.render(<Pessoa />, document.getElementById('root'));

E esse componente será renderizado na sua página, no elemento root!

Component Constructor:

Se existe uma função construtora (constructor()) no seu componente, a função será chamada quando o componente for iniciado. O construtor será onde você irá iniciar as propriedades dos seus componentes.

No React, utilizamos um objeto chamado state para criar nossas propriedades de componentes. Utilize também o super() para utilizar os métodos herdados pela função construtora pai e também para obter acesso à todas as funções do método React.Component. Por exemplo, criaremos um componente Pessoa, com um estado de humor:

class Pessoa extends React.Component {
    constructor(){
        super();
        this.state = {humor: 'Bem humorada!'};
    }
    render(){
        return <h1>Olá, eu sou uma Pessoa {this.state.humor}</h1>;
    }
}

ReactDOM.render(<Pessoa />, document.getElementById('root'));

E temos a saída:

Olá, eu sou uma Pessoa Bem humorada!

Props:

Podemos também utilizar props para adicionar propriedades de componentes.

As props são como argumentos de funções, e você pode enviá-las para os componentes como atributos:

class Pessoa extends React.Component {
    render(){
        return <h1>Olá, eu sou uma Pessoa {this.props.humor}</h1>;
    }
}

ReactDOM.render(<Pessoa humor="Bem humorada!"/>, document.getElementById('root'));

E com isso, obtemos o nosso resultado:

Olá, eu sou uma Pessoa Bem humorada!

Gostou deste artigo? Comente abaixo!

Referências:

Tornando o código mais rápido usando Sets JavaScript

Muitos desenvolvedores limitam-se a utilização de objetos globais básicos, como strings, objetos, números, arrays e booleanos. Na maioria das vezes, isso realmente é tudo que você precisa mas, para tornar o código mais eficiente, nem sempre isso é todo o necessário.

Para isso, existem os Sets JavaScript, que tornam o seu código mais rápido a medida que ele é escalonado. O uso de sets traz resultados que seriam impossíveis de obter somente com arrays.

E como os sets são diferentes?

Bom, os arrays são coleções de dados indexados, ou seja, cada valor dos dados em um array é ordenado por um índice. Por exemplo:

let mainArray = [a, b, c, d];
console.log(mainArray.indexOf(a));
// 0
console.log(mainArray.indexOf(c));
// 2

Já os Sets são coleções codificadas. Não usam índices, mas ordenam os seus dados utilizando chaves. Seus elementos são iteráveis na ordem de inserção e não podem conter dados duplicados, ou seja, cada conjunto de dados deve ser único.

E quais são os benefícios?

  • Utilizar métodos como indexOf() ou includes() para verificar a existência de um elemento em um array é muito lento;
  • Nos Sets, você pode excluir o elemento pelo seu valor. Em um array, você pode utilizar o splice com base no índice do elemento, tornando-o lento pela dependência de índices;
  • É mais rápido adicionar elementos aos Sets do que adicionar elementos em um array utilizando metodos como push() ou unshift();
  • Um Set pode armazenar NaN;
  • Sets armazenam apenas valores únicos. Se você não pode trabalhar com duplicatas, esta é uma vantagem.

O quão mais rápido são os Sets?

Os métodos que o array utiliza possuem uma complexidade de tempo linear de O (N), ou seja, o tempo de execução necessário aumenta conforme aumenta o tamanho dos dados. Mas métodos que utilizam Sets para manipulações como inserção, exclusão e pesquisa possuem uma complexidade de tempo  O (1), e isso significa que o tempo de execução não varia, pois o tamanho dos dados não influencia no tempo de execução dos métodos.

Teste:

Realizando um teste, vamos criar um array e um set com um milhão de entradas cada:

let newArray = [], newSet = new Set(), n = 1000000;

for (let i = 0; i < n; i++){
    newArray.push(i);
    newSet.add(i);
}

Agora, pesquisaremos o número 425123 no array e no set:

let result; 
console.time('Array');
result = newArray.indexOf(425123) !== -1;
console.timeEnd('Array');

console.time('Set');
result = newSet.has(425123);
console.timeEnd('Set');

E a saída foi:

// Array: 1.201ms
// Set: 0.029ms

Gostaram deste artigo? Comente abaixo!

Referência: https://medium.com/@bretcameron/how-to-make-your-code-faster-using-javascript-sets-b432457a4a77

ECMAScript 2020: algumas novidades

Com as novas implementações do ECMAScript, temos novos recursos para melhorar o desempenho de nosso código e velocidade de codificação. Além de melhorias na sintaxe, temos novos operadores e novas implantações para facilitar o desenvolvimento com JavaScript. Caso você ainda não conheça algumas dessas implementações, o MundoJS possui um curso com as principais implementações do ECMAScript 2019 e 2020, e pode ser adquirido aqui.

Agora, conheceremos mais algumas implementações do ECMA2020:

Nullish Coalescing:

O Nullish coalescing adiciona a capacidade de verificar valores nulos em vez de valores falsey.

No JavaScript, alguns valores são falsey, como strings vazias, o 0, undefined, null, false, NaN, entre outros. Mas você pode querer verificar se a variável é null, ou seja, undefined ou null, pois é normal uma variável ter uma string vazia ou valor falso. Neste caso, você pode usar o novo operador Nullish Coalescing (??).

Em comparação a:

Como podemos ver, o operador || sempre retornará ‘Algum valor verdadeiro’, enquanto o operador ?? poderá retornar um valor não-nulo.

globalThis:

Se você escreveu código JS que pode ser usado no NodeJs, no navegador e dentro de web-workers, você pode ter dificuldade em obter o objeto global. Isso ocorre porque é utilizado window para os navegadores, global para o Node e self para web-workers. Se houver mais runtimes, também haverá objetos globais diferentes para eles. Neste caso, você teria que ter a sua própria implementação de detecção de runtime e, após isso, usar o objeto global correto. O ES2020 traz o globalThis, que sempre se refere ao objeto global, não importando onde o código será executado:

Module Namespace Exports:

Com módulos JavaScript, é possível utilizar a seguinte sintaxe:

import * as utilidades from './utilidades.mjs'

E agora, também podemos exportar código:

export * as utilidades from './utilidades.mjs'

E isso é o equivalente a:

import * as utilidades from './utilidades.mjs'
export { utilidades }

Well defined for-in order:

A especificação do ECMAScript não especificava em qual order o for-in deveria executar. Agora, isso está oficialmente padronizado no ES2020, pois os navegadores implantaram uma ordem de execução consistente.

import.meta:

O objeto import.meta foi criado pela implementação do ECMAScript com um prototype null.

Considere um módulo chamado modulo.js:

<script type="module" src="modulo.js"></script>

Agora, você pode acessar as meta-informações sobre o módulo utilizando apenas o import.meta:

console.log(import.meta)

Isso retornará um objeto com uma propriedade url que indicará a URL do nosso módulo. Isso é bom para saber o que obteremos em scripts externos ou descobrir a URL de documentos que estão contidos em nossos scripts internos.

Gostou deste artigo? Comente abaixo!

Novidades Vue v3.0.0 “One Piece”

O Vue.js está lançando a versão 3.0.0 denominada One Piece. Esta versão fornece um desempenho aprimorado, menor tamanho de pacotes, uma melhor integração do TypeScript e novas APIs para lidar com casos de uso em uma grande escala, com base sólida para iterações futuras de longo prazo do framework.

O 3.0 representa mais de 2 anos de desenvolvimento. o Vue é um projeto criado para a comunidade e sustentado pela mesma. Tem uma missão de ser simples, acessível para que qualquer pessoa possa aprendê-la rapidamente. Conforme o crescimento da base de usuários, a estrutura também cresceu em escopo, adaptando-se às demandas crescentes, evoluindo para o chamado “Framework Progressivo”.

Módulos internos em camadas

Na versão 3.0, a nova arquitetura oferece uma melhor capacidade de manutenção, permitindo que os usuários finais reduzam a metade do tamanho do tempo de execução.

  • O compilador suporta transformações AST personalizadas;
  • O runtime principal fornece uma API de primeira classe para a criação de renderizadores personalizados, visando diferentes destinos de renderização.
  • O módulo reactivity exporta funções que fornecem acesso direto ao sistema de reatividade do Vue. Este pode ser usado como um pacote independente, emparelhando com outras soluções de modelos.

Melhorias de desempenho

O Vue 3 mostra melhorias significativas de desempenho em relação à versão 2 em termos de tamanho de pacotes. No Vue 3, foi utilizado “DOM virtual informado pelo compilador”. O compilador realiza otimizações agressivas, gerando código de função de renderização, elevando o conteúdo estático, deixando dicas de tempo de execução para tipos de vinculação, nivelando nós dinâmicos dentro de um modelo para reduzir o custo de passagem em tempo de execução.

Integração aprimorada de TypeScript

O código base do Vue v3.0.0 é escrito em TypeScript, com as definições de tipo testadas e agrupadas automaticamente, para que deste forma, estejam sempre atualizadas. A API de composição funciona muito bem com inferências desse tipo.

Próximos passos:

As próximas implementações e mudanças serão:

  • Compilação de migração;
  • Suporte IE11;
  • Integração de roteador e Vuex em novos devtools;
  • Outras melhorias na inferência de tipo de modelo no Vetur.

Você pode ver todas as novidades no github do VueJS!

Gostou desta notícia? Comente abaixo!

Referências: https://github.com/vuejs/vue-next/releases/tag/v3.0.0

O que é JSX?

Olá pessoal, neste artigo, aprenderemos o que é o JSX e quais são as suas aplicações. O JSX significa JavaScript XML e nos permite escrever HTML no React, tornando fácil a sua adição. Com o JSX, podemos escrever os elementos HTML dentro do JavaScript e adicioná-los ao DOM sem utilizar métodos como createElement() ou appendChild(). o JSX é uma alternativa para escrevermos nosso código que mescla a estrutura do DOM com a lógica da aplicação.

São necessários transpiladores (pré-processadores) como o Babel. Basicamente, com o JSX você escreve estruturas HTML/XML do mesmo modo que escreve o código JavaScript, então, o transpilador transformará essas expressões em código JavaScript. Ou seja, ao invés de colocar o JavaScript no HTML, colocamos o HTML no JavaScript.

O JSX fornece uma sintaxe concisa e familiar para definir uma estrutura de árvore com atributos que não requerem o aprendizado de uma linguagem de templates ou abandonar o JavaScript e o JSX é fácil de ler e escrever. Vejamos um exemplo:

const element = <h1>Olá Mundo!</h1>

ReactDOM.render{
    element, 
    document.getElementById('root')
};

Neste exemplo, declaramos a variável element e a usamos dentro do JSX, renderizando-a com ReactDOM.render().

Se fosse escrever o mesmo exemplo anterior sem o JSX, seria algo como:

const element = React.createElement('h1, {}, 'Olá Mundo!');
ReactDOM.render(element, document.getElementById('root'));

Veja, se não utilizamos JSX, precisamos do método createElement para criarmos o nosso elemento <h1> utiliando o React. Com o JSX, eliminamos a necessidade de utilizar este método, simplificando a sintaxe do nosso código.

O JSX também é uma expressão!

Podemos utilizar expressões em JSX, transformando-se em chamadas normais de funções que retornam objetos JavaScript. Por exemplo:

function formatName(user) {
    return user.firstName + ' ' + user.lastName;
}

const user = {
    firstName: 'Nome',
    lastName: 'Sobrenome'
};

function greeting(user){
    if (user) {
        return <h1>Olá, {formatName(user)}!</h1>;
    }
    return <h1>Olá, anônimo!</h1>;
}

Ou seja, você pode utilizar o JSX dentro de estruturas condicionais e laços de repetição, atribuí-los a variáveis, aceitá-los como argumentos e retorná-los de funções!

Gostou deste artigo? Comente abaixo!

Referências: