Curso Grátis de JavaScript by MundoJS

logo

Nosso primeiro curso de JavaScript está no ar, segue o link:

Instrodução ao JavaScript

Esperamos que gostem e nos mande uma mensagem aqui no site se você tiver alguma dúvida ou sugestão.
Para quem é o curso: Todo mundo, por favor se inscrevam… kkk

Descrição

O curso é para iniciantes no mundo da programação. Ele ensinará o conteúdo do primeiro semestre de algoritmos da maioria das faculdades, mas de uma forma mais sucinta para você não perder tempo. Conforme tivermos chance, iremos adicionar mais exercícios relevantes e ir atualizando qualquer problema que vocês nos informarem.

Neste curso você aprenderá os fundamentos de JavaScript necessários para entender os algoritmos criados com a linguagem. Você não precisa ter qualquer conhecimento técnico e se já souber o básico de algoritmos, terá bastante facilidade em entender todo o conteúdo.

Ao término dele você saberá mais sobre

  • Variáveis
  • Tipos de dados
  • If/Else
  • Switch
  • For
  • For Of
  • While
  • Do While

Como é grátis, convidamos todos a se inscreverem e nos darem sua opinião.

Bons estudos!!

Novidades no ECMAScript 2019 (ES2019)/ES10

A versão 72 do Chrome lançou alguns novos recursos interessantes do ES10:

.Flat():

O método flat() cria um novo vetor recursivamente com todos os elementos do sub-vetor concatenados nele até a profundidade especificada.

let vetor = [1, 2, 3, [4, 5, 6, [7, 8, 9, [10, 11, 12]]]];

vetor.flat();
// (7) [1, 2, 3, 4, 5, 6, Array(4)]

vetor.flat().flat();
// (10) [1, 2, 3, 4, 5, 6, 7, 8, 9, Array(3)]

vetor.flat().flat().flat();
//(12) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

vetor.flat(Infinity);
//(12) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

.flatMap():

O método flatMap() primeiramente mapeia cada elemento do vetor usando uma função e mapeamente para, em seguida, nivelar o resultado em um novo array. O flatMap é bastante útil, pois mescla um mapa seguido por um flat de profundidade 1 em um método mais eficiente.

let vetor = [1, 2, 3, 4, 5];

vetor.map(x => [x, x*2]);
// (5) [Array(2), Array(2), Array(2), Array(2), Array(2)]
// 0: (2) [1, 2]
// 1: (2) [2, 4]
// 2: (2) [3, 6]
// 3: (2) [4, 8]
// 4: (2) [5, 10]

vetor.flatMap(v=>[v, v*2]);
// (10) [1, 2, 2, 4, 3, 6, 4, 8, 5, 10]

Object.fromEntries():

O método Object.fromEntries() transforma uma lista de pares de valores-chave em um objeto.

Exemplo 1:

let obj = {
    chave1:'valor1',
    chave2:'valor2',
    chave3:'valor3'
}    

let entries = Object.entries(obj);

console.log(entries);
// (3) [Array(2), Array(2), Array(2)]0: (2) ["chave1", "valor1"]1: (2) ["chave2", "valor2"]2: (2) ["chave3", "valor3"]

let fromEntries = Object.fromEntries(entries);

console.log(fromEntries);
// {chave1: "valor1", chave2: "valor2", chave3: "valor3"}

Exemplo 2:

let entries  = new Map([
    ['nome', 'ben'],
    ['idade', 25]
]);    

Object.fromEntries(entries);
// {nome: "ben", idade: 25}

String.trimStart() & String.trimEnd():

O método trimStart() remove espaços em branco do início de uma string. O método trimEnd() remove espaços em branco do final de uma string.

let olaMundo = "     Olá Mundo!     ";

console.log(JSON.stringify(olaMundo.trimEnd()));
// "     Olá Mundo!"

console.log(JSON.stringify(olaMundo.trimStart()));
// "Olá Mundo!     "

Optional Catch Binding:

Permite que os desenvolvedores usem try / catch sem criar uma ligação não utilizada. Você pode fazer uso do catch block sem um parâmetro.

try {
    throw new Error("sem erro");
} catch {
    console.log("nenhum parâmetro no catch");
}
// nenhum parâmetro no catch

Antes era obrigatório usar parâmetro no catch block:

try {
    throw new Error ("Algum erro aleatório");
} catch(e) {
    console.log(e);
}    
// Error: Algum erro aleatório

Continue lendo “Novidades no ECMAScript 2019 (ES2019)/ES10”

QUnit.js: um framework para testes de unidade JavaScript.

Você sabe o que é o QUnit?

O QUnit é um framework para testes de unidade JavaScript poderoso e fácil de usar. É utilizado para testes em projetos jQuery, jQuery UI e jQuery Mobile e é capaz de testar qualquer código JavaScript genérico.

O QUnit foi originalmente desenvolvido por John Resig como parte do jQuery. Em 2008, ele recebeu sua própria home page, nome e documentação da API, permitindo que outras pessoas a utilizem para os testes. Anteriormente, o QUnit ainda dependia de jQuery, mas em 2009 isto foi corrigido, e agora o QUnit é executado de forma completamente autônoma. Os métodos de asserção do QUnit seguem a especificação CommonJS Unit Testing, que foi até certo ponto influenciada pelo QUnit.

Como começar?

Uma configuração mínima para um teste do QUnit:

<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width">
  <title>QUnit Example</title>
  <link rel="stylesheet" href="https://code.jquery.com/qunit/qunit-2.9.2.css">
</head>
<body>
  <div id="qunit"></div>
  <div id="qunit-fixture"></div>
  <script src="https://code.jquery.com/qunit/qunit-2.9.2.js"></script>
  <script src="tests.js"></script>
</body>
</html>

E o conteúdo do tests.js:

QUnit.test( "hello test", function( assert ) {
  assert.ok( 1 == "1", "Passed!" );
});

No node:

Instale o QUnit globalmente para poder usar o CLI:

$ npm install -g qunit

Crie arquivos de teste em um test directory e execute:

$ qunit

Você deve ver algo como:

TAP version 13
ok 1 Module > Test #1
ok 2 Module > Test #2
1..2
# pass 2
# skip 0
# todo 0
# fail 0

E é isso! Enquanto o QUnit procura por arquivos de teste “test”, você também pode coloca-los em qualquer lugar e, em seguida, especificar caminhos de arquivo ou expressões glob:

$ qunit 'tests/*-test.js'

Para ver as opções adicionais suportadas, basta executar:

$ qunit --help

No npm:

npm install --save-dev qunit

Para testar os recursos mais recentes e correções de bugs no QUnit, uma versão gerada automaticamente a partir do último commit para o repositório QUnit Git também está disponível para uso:

Para mais informações sobre o framework, acesse o site principal do QUnit no link: qunitjs.com/

Gostou deste artigo? Comente abaixo!

React avançado — Utilizando “props.children” como função de primeira classe

O coração do React são componentes. Você pode aninhar esses componentes do mesmo modo que você aninha tags HTML, o que torna tudo mais fácil quando escrevemos JSX, afinal, lembra muito o bom e velho HTML.

Quando eu comecei com React, eu pensei “Basta usar props.children e pronto. Eu sei tudo sobre o objeto .children”. Te digo, como eu estava errado! 🙂

Como estamos trabalhando com JavaScript, nós podemos mudar o .children. Nós podemos passar propriedades para ele, decidir se queremos que ele renderize algo ou não, usá-lo do jeito que quisermos. Vamos mergulhar no poder do .children em React!

Abaixo, segue os tópicos que iremos abortar nesse artigo:

Tabela de conteúdo:

  • Elementos filhos
  • Tudo pode ser um elemento filho
  • Função como elemento filho
  • Manipulando .children
  • Usando loops em .children
  • Contando .children
  • Convertendo .children em um array
  • Permitir apenas um elemento filho
  • Editando .children
  • Mudando as propriedades dos elementos filhos
  • Clonando imutavelmente os elementos filhos
  • É isso aí!

Elementos filhos

Vamos dizer que temos um componente , que contém componentes como elementos filhos. Usamos da seguinte maneira:

<Grid>
  <Row />
  <Row />
  <Row />
</Grid>

Demo: http://www.webpackbin.com/Ekg_vyjPz

Esses três componentes Row são passados para o Grid como props.children. Usando um container como expressão (expression container, termo técnico do JSX para os colchetes), componentes pais podem renderizar os elementos filhos:

class Fullstop extends React.Component {
  render() {
    return <h1>Hello world!</h1>
  }
}

Não importa quantos elementos filhos você passe, ele sempre irá renderizar “Hello world!”, e nada mais.

Nota: O h1 no exemplo acima (assim como todas as tags HTML primitivas), está renderizando seu elemento filho, nesse caso, o nó de texto “Hello world!”

Continue lendo “React avançado — Utilizando “props.children” como função de primeira classe”

React Native simplifica o desenvolvimento de aplicativos:

Há um número crescente de aplicativos incríveis e populares nas lojas de aplicativos que foram criadas com React Native, estes incluem: Facebook Ads Manager, Facebook Messenger, AirBnB, Bloomber, UberEats, Discord e Instagram.

O crescimento de aplicativos para dispositivos móveis.

A Statista, que é uma provedora de dados de mercado e consumidores, prevê que os aplicativos móveis gerarão receita global de aproximadamente US$ 189 bilhões até o ano 2020. O desenvolvimento de aplicativos móveis está aumentando à medida que aumenta a necessidade de aplicativos que ajudarão a simplificar a vida e o trabalho.

Com a crescente demanda por aplicativos, os desenvolvedores estão procurando modos de facilitar o trabalho. Ao mesmo tempo, as empresas exigem que seus aplicativos estejam disponíveis em todas as plataformas: Web, iOS, Android, entre outras. Este é um desafio, pois os desenvolvedores têm que projetar e desenvolver a mesma coisa para três plataformas diferentes.

Três aplicativos pelo preço de um.

Com React Native, eles não precisam mais criar três aplicações diferentes para Web,Android e iOS. Um aplicativo será executado em todas as três plataformas. É uma estrutura rápida e fácil baseada, em JavaScript usada para criar aplicativos nativos. Também é apoiado pelo Facebook com amplo apoio e contribuição da comunidade, bem como tutoriais e materiais de aprendizagem.

Isso torna extremamente fácil começar a usar o React Native. Também é fácil fazer a transição de nativo para reagir e vice-versa e isso pode ser feito a qualquer momento sem esforço, porque o React Native alinha-se às convenções da plataforma nativa. Mais importante, pode-se mudar de React Native para totalmente nativo com muito pouco esforço.

O CEO da BlueGrass Digital, Nick Durrant, diz que é definitivamente muito mais barato, fácil e rápido desenvolver aplicativos móveis no React Native:

“O React Native permite uma única base de código JavaScript para todas as plataformas. Isso facilita a manutenção do aplicativo com o mesmo processo de desenvolvimento para todas as plataformas e a reutilização do mesmo código. Isso significa menos recursos, não há necessidade de equipes de desenvolvimento separadas. ”

Continue lendo “React Native simplifica o desenvolvimento de aplicativos:”

Como fazer: Relógio com JavaScript

Aprenda neste artigo como fazer um relógio mostrando a sua hora atual, atualizando em tempo real as horas, minutos e segundos.

Date():

Objetos Date() são baseados no valor de tempo que é o número em milissegundos desde 1º de Janeiro de 1970 (UTC).  O UTC (Também conhecido como Greenwich Mean Time, GMT), refere-se ao tempo como definido pelo Padrão de Tempo Mundial (World Time Standard). O Objeto Date também suporta métodos de tempos locais. O tempo local é o tempo conhecido pelo computador onde o JavaScript é executado.

Neste nosso exemplo, criaremos uma função que irá retornar o tempo de nossa máquina.

Vamos ao código:

Primeiro, criaremos uma tag h3 que irá receber os valores de nossa função. Esta tag mostrará as horas, os minutos e os segundos.

<!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>Relógio</title>
</head>
<body>
    <h3 id="hora"></h3>
    <script>
    </script>
</body>
</html>

Criado este campo de input, iremos criar uma função setInterval. Esta função irá executar uma função anônima que, utilizando o método Date(), getHours(), getMinutes(), retornará as horas, minutos e segundos atuais diretamente para a página HTML, utilizando o textContent.

setInterval(function(){
    
    let novaHora = new Date();
    // getHours trará a hora
    // geMinutes trará os minutos
    // getSeconds trará os segundos
    let hora = novaHora.getHours();
    let minuto = novaHora.getMinutes();
    let segundo = novaHora.getSeconds();

    // Chamamos a função zero para que ela retorne a concatenação
    // com os minutos e segundos
    minuto = zero(minuto);
    segundo = zero(segundo);

    // Com o textContent, iremos inserir as horas, minutos e segundos
    // no nosso elemento HTML
    document.getElementById('hora').textContent = hora+':'+minuto+':'+segundo;
},1000)

Para mostrar as horas no formato padrão (00:00:00), criaremos uma função denominada zero(x) que retornará uma concatenação de um ‘0’ em frente à X, com a condição de x ser menor que 10.

// A function zero concatena a string (número) 0 em frente aos números
// mantendo o zero na frente dos números menores que 10. Exemplo:
// 21:05:01
// 21:05:02
// e assim, sucessivamente
function zero(x) {
    if (x < 10) {
        x = '0' + x;
    } return x;
}

Gostou deste artigo? Deixe seu comentário abaixo!

Exercício fácil: Sequência de Fibonacci

Você conhece a Sequência de Fibonacci?

A Sequência de Fibonacci é uma sucessão de números. Esta sucessão obedece um padrão onde cada elemento subsequente é o resultado da soma dos dois elementos anteriores.

Ela pode ser definida pela seguinte fórmula:

Assim, teremos:

Fibonacci (0) = 0,

Fibonacci (1) = 1,

Fibonacci (2) = Fibonacci (0) + Fibonacci (1) =1,

Fibonacci (3) = Fibonacci (1) + Fibonacci (2) = 2,

Fibonacci (4) = Fibonacci (2) + Fibonacci (3) = 3,

Fibonacci (5) = Fibonacci (3) + Fibonacci (4)= 5,

Fibonacci (5) = Fibonacci (4) + Fibonacci (5) = 8,

E assim, sucessivamente.

Mas onde ela pode ser aplicada?

A Sequência de Fibonacci pode ser aplicada em diversas áreas, como:

  • Análise de mercados financeiros: existem relações entre picos e vales em gráficos de flutuação da bolsa financeira, que tendem a seguir razões numéricas aproximadas com as razões de números da Sequência de Fibonacci.
  • Triângulo de Pascal: os triângulos de Pascal e Pitágoras também se relacionam com a Sequência de Fibonacci.
  • Pintura e Arte: as artes utilizavam-se da Proporção Áurea.
  • Anatomia e Homem Vitruviano: medidas e funcionamento do universo conectadas pela proporção do número de ouro.
  • Entre outras diversas aplicações…

Exercício:

Neste exercício, você deverá reproduzir a Sequência de Fibonacci utilizando um laço de repetição. Utilize o laço For ou o While pra resolver este problema.

function fibonacci(n) {
    if () {
        return;
    }

    for () {
        if () {
            return;
        }
    }
}

Crie um algoritmo que retorne o valor da Sequência de Fibonacci na posição 5, na posição 7 e na posição 13. Você deverá ter um log de saída aproximadamente neste formato:

Gostou deste Exercício? Achou fácil ou difícil? Comente os seus resultados abaixo!

Você pode baixar o código-fonte com o resultado do exercício aqui: [download id=”2730″]

 

Como remover Elementos de um Array JavaScript alterando o length

Em JavaScript, os Arrays permitem agrupar valores e iterar sobre eles. Você pode adicionar e remover elementos destes vetores de várias maneiras diferentes.

Ao invés de um método de exclusão, o Array JavaScript possui várias maneiras de limpar os valores do vetor. Você pode remover os elementos do final de um Array usando pop(), no início usando shift(), ou no meio usando splice().

Removendo elementos do final de um Array utilizando o length:

Os elementos de um Array JavaScript podem ser removidos do final de um vetor, definindo a propriedade length (tamanho do array) como um valor menor que o valor atual. Qualquer elemento que possuir o índice maior que o estipulado no novo length, será removido.

// Definindo o vetor de tamanho 6 (a partir do índice 0)
let array1 = [1, 2, 3, 4, 5, 6];
array1.length = 4; // Alterando o tamanho (length) do array
console.log(array1); // [1, 2, 3, 4] vetor alterado

Removendo elementos do início de um Array utilizando o shift():

Para remover o primeiro elemento de um Array no JavaScript, podemos utilizar o método shift(). Ele funciona de forma muito parecida com o método pop(), com a diferença que o pop() remove o último elemento, e o shift() remove o primeiro elemento do vetor. Não é necessário passar parâmetros neste método, pois o shift() irá remover apenas o primeiro elemento do vetor. Os outros elementos restantes serão realocados para seus novos índices. O elemento que estava no índice 1, será realocado para o índice 0, e assim, sucessivamente.

// Criando um vetor com 4 elementos
let array2 = ['Ana', 'Marcos', 'Paulo', 'Alexandre'];
array2.shift(); // Removerá o primeiro elemento do vetor: 'Ana'
console.log(array2); // ['Marcos', 'Paulo', 'Alexandre']

O shift() retorna o elemento que foi removido, atualiza os índices e atualiza o length do Array. Se não houver elementos ou o comprimento da matriz for 0, o método retornará undefined.

Removendo elementos do meio do Array utilizando o splice():

O método splice() é utilizado para remover elementos de determinados índices de um vetor. Será necessário passar dois parâmetros neste método. O primeiro, especifica o índice que será removido. O segundo, especifica quantos elementos a partir deste índice serão removidos.

// Criando um vetor com os elementos 
let array3 = [1, 2, 3, 4, 5, 6, 7, 8, 9];
// Crie uma variável para adicionar o método slice()
// Passe como argumentos a partir de qual índice será removido, e quantos elementos serão removidos
let remover = array3.splice(3, 3);
console.log(array3); // [1, 2, 3, 7, 8, 9]

Gostou deste artigo? Tire suas dúvidas abaixo na sessão de comentários!

SAP amplia e expande contribuições para a comunidade de desenvolvedores web.

A SAP apresenta a UI5 Web Components, uma biblioteca para desenvolvedores Web que possibilita a criação de aplicações corporativas com maior facilidade.

A nova UI5 Web Components criada pela SAP permite que os desenvolvedores aproveitem recursos oferecidos pelo OpenUI5 enquanto utilizam outras estruturas como Angular, React, Vue.js. Os Web Components são conjuntos de elementos, de interface corporativa, com funções que não seriam tão facilmente implementadas utilizando HTML padrão.

Web Components são agnósticos em termos de framework, funcionam nos navegadores mais modernos e podem ser usados para acrescentar algumas funcionalidades avançadas em aplicações Web dinâmicas e páginas Web estáticas.

“O código aberto é uma parte fundamental da estratégia tecnológica da SAP, e somos ativos na comunidade há mais de 15 anos. Além de disponibilizar tecnologias desenvolvidas dentro da SAP à comunidade Open Source, contribuímos com outros projetos relevantes da indústria”, afirma Angelo Agra, head da unidade de desenvolvimento do SAP Data Hub no Brasil. “Nossa contínua colaboração com a comunidade open source em torno do CLA assistant e do OpenUI5 é uma importante fonte de contribuições e de novos recursos”, completa.

Continue lendo “SAP amplia e expande contribuições para a comunidade de desenvolvedores web.”

Diferenças entre React Native e React JS

Nos últimos anos, o React Native tornou-se um framework interessante e muito usado para Android e outras aplicações móveis de plataforma cruzada. Foi também customizado por alguns dos contribuidores para criação de aplicativos para desktop, como Mac e Windows.
Ainda há alguma confusão entre React Native e ReactJS. Embora sejam semelhantes de certa forma, existem grandes diferenças entre os dois.

Por que escolher o React?

Gerenciado pelo Facebook, Instagram e uma grande comunidade de empresas e desenvolvedores, o React é um dos frameworks mais procurados. De acordo com a análise JavaScript, o React está sendo utilizado em sites como Walmart, Netflix, Airbnb e Feedly.
Ele oferece websites com alto desempenho e escalabilidade. Reac garante até reusabilidade de código, permitindo aos desenvolvedores otimizar seu tempo na criação de códigos. Também otimiza o SEO da sua aplicação web. Embora o conceito de React ainda seja novo, ele está amadurecendo rapidamente, e o Facebook planeja continuar investindo nele.

As diferenças:

React Native é um framework para desenvolvimento mobile que reúne todos os componentes de um aplicativo nativo, auxiliando você a criar os aplicativos móveis nativos para Android, Windows e iOS em JavaScript. Isso permite que o usuário utilize o React JS para construir os componentes. Ele tem bibliotecas embutidas e seu navegador de bibliotecas auxilia na navegação de aplicativos móveis.

O React JS, também conhecido como React.js, é outro framework usado em desenvolvimento de interfaces de usuário para aplicativos da web. Para navegar pelas páginas da web, ele faz uso do React Router. Também faz uso de bibliotecas JavaScript e CSS para fins de animação.

Saber as diferenças básicas entre React Native e React JS não é o suficiente. Você também deve conhecer os prós de cada framework para se aprofundar neles.

React Native Prós:

É um dos frameworks JavaScript de mais rápido crescimento, que é como uma varinha mágica para os desenvolvedores. Se você for iniciante no desenvolvimento de aplicativos , precisará apenas conhecer alguns elementos de UI, JavaScript, APIs de plataforma ou quaisquer outros padrões de design específicos da plataforma.

Continue lendo “Diferenças entre React Native e React JS”