Como usar a API JavaScript para estender as funcionalidades do APEX

O JavaScript continua ganhando tração dentro do mundo Oracle. Além do banco estar aceitando código JS, o APEX que é uma plataforma low code que gera aplicações rapidamente está fornecendo uma API JS para manipulação de seus compoentes.

Na semana passada foi ao apresentado no Oracle Office Hours por mim (https://www.mundojs.com.br/author/pkunzel) um breve tutorial de como usar a está API para esta comunicação.

Segue então abaixo o vídeo para curtam e comentem o nele o que acharam.

Caso você queira conhecer o APEX, basta criar uma conta em apex.oracle.com para usa-lo sem custo. Por ser uma base de dados bem restrita, não dá para montar um sistema de grande, mas todas as funcionalidade estão lá

Como criar eventos JavaScript customizados

Criar eventos customizados no JavaScript é bem simples e pode ser feito em poucas linhas. O importante é termos os seguintes passos:

  • Criação de um objeto usando new Event
  • Atribuição de um listener a um elemento
  • Chamada ao método que disparará o evento criado e vinculado a aquele elemento.
// Criando o nosso evento
const meuEvento = new Event("meuNovoEvento");

// Atruibuindo o listener ao document mesmo para o exemplo ficar pequeno
document.addEventListener("meuNovoEvento", e => console.log(e))

// executando o evento para o elemento document.
document.dispatchEvent(meuEvento);

Basicamente é isso, abaixo eu gostaria de falar sobre alguns pontos importantes para você entender o que aconte por baixo do panos.

Sincrono ou Assincrono?

Segundo site do mozilla “Ao contrário dos eventos “nativos”, que são disparados pelo navegador e invocam manipuladores de eventos de forma assíncrona por meio do loop de eventos, dispatchEvent() invoca manipuladores de eventos de forma síncrona. Todos os manipuladores de eventos aplicáveis ​​são chamados e retornados antes do retorno de dispatchEvent().”

Modificando as propriedades do Evento

Se você executou o evento acima você deve ter visto no console que aparecem várias propriedades para o evento. Algumas uteis, outras apenas se você está querendo criar algo extremamente complexo.

Vamos falar de algumas delas

  • isTrusted: Será true quando o evento foi disparado por uma interação do usuário e false quando algum código JavaScript o fez.
  • bubbles: Determina se a aplicação fará o bubbling pelo DOM
  • cancelable: Informa se o elemento pode ser cancelado pelo comando e.preventDefault()
  • target: O elemento que sofreu a ação.
  • currentTarget: Normalmente é o mesmo que objeto que o target a não ser que tenha ocorrido algum redirecionamento.
  • type: O tipo, o nome do nosso elemento.

Então era isso, caso você tenha interesse em aprofundar os seus conheicmentos eu recomendo dar uma lida na documentação oficial que você pode acessar por este link https://developer.mozilla.org/en-US/docs/Web/API/Event

Microsoft cria proposta de tipagem para o JavaScript

A proposta planejada pela Microsoft e outros, incluindo desenvolvedores do programa Igalia Coding Experience e da Bloomberg, trata de adicionar “tipos como comentários” à linguagem.

A teoria é que seria possível ter uma sintaxe para tipos que poderiam ser usados ​​por ferramentas que precisam desses ganchos (como o próprio TypeScript da Microsoft) e ignorados por aqueles que não precisam.

Para ver a proposta orgina, clique aqui: https://devblogs.microsoft.com/typescript/a-proposal-for-type-syntax-in-javascript/

Em Resumo

“A ideia desta proposta”, disse Rosenwasser, “é que o JavaScript poderia criar um conjunto de sintaxe para tipos que os mecanismos ignorariam completamente, mas que ferramentas como TypeScript, Flow e outras poderiam usar”.

Rosenwasser foi rápido em enfatizar que a proposta não é colocar a verificação de tipo TypeScript em cada runtime JavaScript (certamente, pode-se imaginar todos os tipos de problemas de compatibilidade no futuro), em vez disso, o plano é que a abordagem seja escolhida por qualquer tipo verificador, não apenas os gostos de TypeScript.

Também ainda é apenas uma proposta no momento, prevista para a Etapa 1 do processo ECMA TC39. Há, portanto, muitos obstáculos pela frente antes que o conceito (se aceito) chegue à forma ECMAScript e muitas oportunidades para debate.

No entanto, a julgar pelas respostas de pouco mais de 16.000 desenvolvedores que responderam a perguntas na pesquisa State of JavaScript de 2021, há apetite por algum tipo de funcionalidade de tipo. A proposta dos desenvolvedores é um primeiro passo no caminho.

Live sobre Front-end JS e APEX

Olá pessoal, hoje é mainha primeira live solo apresentando sobre programação Front-end com o Oracle APEX. Nele estarei falando de diversas funcionalidades nas ações dinâmicas (event listeners) e como usar expressões javascript para estender as funcionalidades do código.

Onde?

A live será hoje, dia 21/06/22 as 20:00 no youtube pelo link:

Link da Live

Quais serão os tópicos?

Estarei falando de Oracle APEX, Ações Dinâmicas, JavaScript e jQuery

Isso ai, quem tiver interesse pode dar um pulo lá ou assistir depois.

Como usar JavaScript no Oracle APEX

O que é o Oracle APEX?

Para aqueles que não conhecem, o Oracle APEX é uma plataforma gratuita de desenvolvimento low code disponibilizado pela Oracle e que você pode testar tanto criando uma conta https://apex.oracle.com/, criando direto em cima de uma banco oracle em sua maquina quanto instanciando na nuvem.

Se você nunca mexeu nele, então eu recomendo começar pelo link que passei para ver se a plataforma atende as necessidades e pelo simples fato de ser mais rapido de fazer tudo funcionar.

Imagem do Dashboard do APEX
Dashboard do APEX

Nossas postagens sobre APEX

Veja aqui mais postagens nossas sobre o tópico: https://www.mundojs.com.br/tag/apex/

Onde o JavaScript se encaixa nisso?

Caso você ja tenha acessado o link ou acessou antes de continuar lendo você deve estar se perguntando, onde o JavaScript vai ser usado aqui? Se eu colocar JavaScript não vou estar deixando de usar a plataforma da forma correta?

Como muito pode ser feito sem programar e sem intervenção direta de código, eu espero que você tenha feito essas perguntas, pois elas são importantes.

A resposta é simples, você pode sim trabalhar com o Javascript usando a API JavaScript disponibilizada e pode fazê-lo em múltiplos níveis.

Por exemplo, coisas como

// caixas de mensagem
apex.message.alert(texto);
apex.message.confirm(texto, funcaoCallback);

// definir valores
apex.item(identificador).setValue(valor)

// chamadas AJAX
apex.server.process(nomeProcess, dadosEnviados, funcaoCallback);

Podem ser feitas com funcionalidades (blocos lógicos) low code como

  • alert
  • confirm
  • set value
  • execute server side code, set value ou refresh

Mesmo assim, é importante que saber que temos opções que recebem suporte e que estão disponíveis na API. por isso acho importante evitar código que modele/acesse diretamente as propriedades como

// caixas de mensagem
alert(texto)
confirm(texto)
$( seletor ).dialog();

// definir valores
document.querySelector(seletor).value = valor;
$(selector).val(valor)

// chamadas AJAX
fetch(url, opcoes)
$.ajax(url);

Por mais que estes métodos funcionem, ja me deparei com casos que o framework (não só no APEX) mudou e com isso a funcionalidade deixou de acontecer ou teve um comportamento inesperado. Problemas como

  • seletores mudarem dentro do framework
  • links serem ajustados
  • componentes complexos serem reestruturados

Entre outras opções são comuns com o crescimento das plataformas, especialmente quando elas usam conjuntos de ferramentas de suporte.

Conclusão

Essa foi uma postagem rápida tentando falar um pouco da melhor forma de trabalhar como um desenvolvedor front end no APEX e mostrar algo, que na minha opinião, é muito importante e precisa ser feito com basntate estudo e atenção

JavaScriptLandia – Para aqueles que amam JavaScript

O que é?

JavaScriptLandia, o programa de suporte individual da OpenJS Foundation, é um lugar onde todos os fãs de JavaScript, não importa seu sabor ou preferência de tecnologia, podem expressar de forma criativa suporte para o ecossistema JavaScript e comunidades OpenJS

Quais são os benefícios do programa JavaScriptLandia?

  • Um crachá digital para adicionar aos seus perfis online, avatar, blog e/ou site pessoal. Os detalhes serão enviados por e-mail separadamente dentro de uma semana.
  • Reconhecimento nesta página! Novos apoiadores serão adicionados à página semanalmente.
  • Um boletim semanal de apoiadores que o mantém atualizado sobre as últimas novidades dos projetos OpenJS, do Conselho de Projetos Cruzados e do Conselho de Administração. Você também será convidado a participar de discussões sobre governança e novas iniciativas.
  • Descontos para treinamento, certificação, conferências e outras ofertas exclusivas.

Angular 14 – Formulários Digitados e Componentes Independentes

Angular 14 foi lançado no início deste mês com a atualização mais significativa desde Ivy. Ele inclui dois recursos muito esperados, formulários reativos digitados e componentes autônomos, além de várias pequenas melhorias.

Os formulários reativos estritamente tipados são uma solicitação da comunidade de longa data que pode ser datada do lançamento do Angular 2.

Até o Angular 14, o Reactive Forms não incluía definições de tipo em muitas de suas classes, e o TypeScript não detectava bugs como no exemplo a seguir durante a compilação.

const login = new FormGroup({
  email: new FormControl(''),
  password: new FormControl(''),
});

console.log(login.value.notanemail);

Com o Angular 14, FormGroup, formControl e classes relacionadas incluem definições de tipo que permitem que o TypeScript detecte muitos erros comuns.

A migração para os novos Formulários Reativos Digitados não é automática. Os controladores de formulário, grupos, etc. existentes serão prefixados com Untyped durante a atualização, que retém a definição de tipo exata das versões anteriores do Angular.

Para aproveitar os novos formulários reativos tipados, os desenvolvedores precisarão remover manualmente o prefixo não digitado e corrigir quaisquer erros que possam surgir.

Os desenvolvedores podem encontrar mais detalhes na documentação de Formulários Reativos Digitados. A segunda grande mudança fornecida com o Angular 14 é o conceito de componentes autônomos.

Módulos Angular têm sido um assunto contestado há muito tempo, com muitos membros da comunidade alegando que isso leva a complicações desnecessárias nos aplicativos Angular.

Com o Angular 14, agora é possível criar componentes autônomos simplesmente passando a propriedade standalone: ​​true no decorador Component.

@Component({
  selector: 'sample-component',
  standalone: true,
  template: ``,
  imports: [ ComponentOne, ComponentTwo, SampleDirective,
             SampleService, CommonModule]
  ],
})
export class SampleComponent {
    ...
}

Como a injeção de dependência Angular ainda é necessária, muitas definições de módulo foram movidas para o decorador de componentes.

Ainda não está claro como a comunidade adotará esse novo recurso, e a equipe do Angular sinalizou o recurso como uma prévia do desenvolvedor e pode alterar a API em versões futuras.

Esta versão também inclui uma nova framework de diagnóstico estendida, que fornece feedback aprimorado sobre erros de modelo e práticas recomendadas.

Atualmente, o framework inclui dois novos avisos, um para a sintaxe inversa de banana em uma caixa ([]) (que é válida, mas raramente pretendida) e união nula desnecessária (??) quando a entrada não é anulável.

Por fim, o Angular 14 usa o TypeScript 4.7 mais recente e tem como alvo o ES2020 por padrão. Para uma lista completa de mudanças, acesse o anúncio oficial de lançamento

Angular é um software de código aberto disponível sob a licença do MIT. Contribuições são bem-vindas através do repositório Angular GitHub.

Fonte:

https://www.infoq.com/news/2022/06/angular-14-typed-forms/

https://github.com/angular/angular

Como funciona o Intl.NumberFormat?

Neste breve post veremos como funciona o Intl.NumberFormat em partes para entendê-lo melhor e podermos gerar várias strings com valores numéricos formatados corretamente.

Sintaxe

A sintaxe básica é bem simples, instanciamos um objeto que precisa de dois parametros, locales e options. Ambos são opcionais

new Intl.NumberFormat([locales[, options]])

locales: em 99% dos casos nós usaremos as strings com representação do local/país/região representada no nosso objeto. Você provavelmente usará os valores ‘pt-BR’, ‘en’ ou alguma variação parecida. Para um guia completo, confira aqui: https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry

const valor = 1999.99;
console.log(new Intl.NumberFormat('pt-BR').format(valor));
// saida: 1.999,99
console.log(new Intl.NumberFormat('ar-EG').format(valor));
// saida: ١٬٩٩٩٫٩٩

options: O segundo parâmentro é um pouco mais complicado pois as opções tem várias opções… kkkk… mas faz parte Vejamos um modelo e depois explicarei o que cada coisa faz

const valor = 1999.99;

const options = {
    style : "currency",
    currency : "BRL",
    minimumIntegerDigits : 10,
    minimumFractionDigits : 2,
    maximumFractionDigits: 5,
}

console.log(new Intl.NumberFormat('pt-BR', options).format(valor));
// saida: R$ 0.000.001.999,99

style:

Definição: O estilo do formato a ser utilizado.

Valor Padrão: “decimal”

Valores Permitidos: “decimal" para formato de número simples, "currency" para formato monetário e "percent" para formato percentual;

currency:

Definição: A moeda para usar na formatação monetária.

Valor Padrão: Não existe. Se o style for “currency”, então o esta propriedade precisa ser informada

Valores Permitidos: Os valores permitidos são os códigos de moedas da ISO 4217, como "USD" para dólar estadunidense, "EUR" para euro, ou "CNY" para RMB chinês — veja a Lista de códigos de moedas e fundos atuais.

minimumIntegerDigits

Definição: A quantidade mínima de dígitos inteiros para utilizar.

Valor Padrão: 1

Valores Permitidos: de 1 a 21

minimumFractionDigits

Definição: A quantidade mínima de dígitos fracionados para utilizar.

Valor Padrão: o padrão para formatos monetários é a menor unidade de dígitos fornecidos pela lista de códigos de moedas ISO 4217 (2 se a lista não fornecer a informação).

Valores Permitidos: de 0 a 20.

maximumFractionDigits

Definição: O número máximo de dígitos fracionados para utilizar

Valor Padrão: o padrão para a formatação de número simples é o maior entre minimumFractionDigits e 3.

Valores Permitidos: de 0 a 20.

CONCLUSÃO

Isso pessoal, esse foi um tutorial bem simples de como usar uma classe extremamente útil. Para mais detalhes, vejam também a documentação oficial https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat

Começa hoje a JS Nation

Gostaria de saber tudo que está acontecendo de novo com o JavaScript? Começa hoje 16/07/22 as 9:00 a JS Nation

O que é?

JSNation é um evento de 2 dias e 2 trilhas focado exclusivamente no desenvolvimento JavaScript. Descubra o futuro do ecossistema de desenvolvimento JavaScript e conecte-se à sua multidão estelar!

Este ano, o formato do evento será híbrido, com o primeiro dia (16 de junho) transmitido do local de Amsterdã, incluindo recursos híbridos de rede e entretenimento interativo; e segundo dia (20 de junho), além dos inúmeros workshops gratuitos, transmitidos online para o público global.

Palestras Grátis

A melhor parte para a grande maioria é sempre o fato de haverem palestras grátis 🙂

Veja aqui no link a lista de palestras: https://jsnation.com/remote-js-workshops

Workshops

Gostaria e pode gastar um pouco mais para aprender mais? então de uma olhada nos workshops disponiveis. Infelizmente eles tem um valor a parte até de alguns ingressos pagos, mas se o conhecimento tiver valor para o seu crescimento, vale o investimento. Veja aqui o link https://jsnation.com/js-workshops

Como usar o forEach no JavaScript

forEach

Neste breve artigo, estarei mostrando como usar o forEach no JavaScript usando todas as possibilidades de passagem de valores no exemplos. Estarei presumindo que você entende como funcionam Arrays e Arrow Functions.

Descrição e uso do forEach

O forEach é um método acessado dos objetos array (vetores) que itera entre todos os itens da lista executando uma função que informamos passada por parâmetro. Sendo assim, quando você possui uma coleção que precisa ser iterada ele é um ótimo candidato por ser sucinto e fácil de entender.

Quando não usar o forEach

Se você precisa parar a iteração, o forEach não é o melhor candidato. Ele não é um loop que podemo encerrar com ‘break’ e se na função de callback colocarmos um ‘return’, ele simplesmente seguirá para o próximo item. Neste tipo de situação, de preferencia para os loops tradicionais.

Array.forEach simples

a forma mais simples é chamando o método e passando uma função de callback que possui apenas um parâmetro

// Uma lista simples
const dados = [1,2,3,4,5,6,7,8];
// uma função de callback com apenas 1 item passado de parametro
const callback = item => console.log(item)
// a chamada
dados.forEach(callback);

Poderíamos colocar a função diretamente dentro da chamada

dados.forEach(item => console.log(item));

Ou chamar todo o primeiro exemplo em apenas 1 linha

[1,2,3,4,5,6,7,8].forEach(item => console.log(item));

Mas é importante tentar manter o seu código o mais fácil de entender possível.

Array.forEach com 2 parâmetros no callback

Digamos que você precise saber o índice do item por algum motivo, neste caso, precisamos informar mais um parâmetro em nossa callback. Vamos fazer um exemplo um pouco diferente

// Uma lista com strings para não confundir com o valor do indice
const dados2 = ['caixa', 'pallet', 'caixote', 'sacola', 'avulo'];
// A callback agora precisa de um segundo parametro 
const callback2 = (item, indice) => console.log(`${indice}: ${item}`)
// mesma chamada
dados2.forEach(callback2);

Ao executar o código você verá que teremos a posição dos items e seus valores. Para comparação, o For tradicional geraria este Loop da seguinte maneira:

for(let indice; indice < dados2.length; indice++) console.log(`${indice}: ${item}`)

Array.forEach com 2 parâmetros

Para este exemplo, manteremos o nosso segundo vetor

const dados2 = ['caixa', 'pallet', 'caixote', 'sacola', 'avulo'];

e vamos criar um objeto bem simples com apenas 1 função que executa um console log no valor passado por parametro, no mundo real seria somente uma função, mas para nosso exemplo ele ele vale.

let obj = { log : (umItem) =&gt; console.log(umItem)}

Agora, se você quisesse executar o obj.log para cada item do dados2, você poderia fazer algo assim:

dados2.forEach(item =&gt; obj.log(item));

e vai funcionar. Agora digamos que você tenha uma ambiente dinamico no qual você não sabe o qual objeto está executando o método log e dentro deste método poderiam acontecer coisas diferentes ou até que você está montando uma biblioteca que receberá o objeto e executará alguma coisa. Como você faria? Com o forEach, é possível fazer o seguinte

dados2.forEach(item =&gt; this.log(item), obj);

Deu erro? Isso é porque arrow function não podem receber escopo, se não entendeu, veja novamente o link Arrow Functions. Entendeu, então a parte abaixo é simples. A solução mais simples, use a função normal.

dados2.forEach(function(item){ this.log(item)}, obj);

Era isso, espero que tenham gostado, qualquer duvida deixem nos comentários.