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

JS Fest 2020

A JS Fest acontecerá na Ucrânia, nos dias 30-31 de Outubro de 2020. A JS Fest é um evento/conferência internacional que considera sobre todos os aspectos do desenvolvimento com javaScript. É uma das maiores conferências sobre desenvolvimento JavaScript de toda a Europa, reunindo centenas de pessoas com experiência na tecnologia. A conferência acontecerá pelo terceiro ano consecutivo e são esperados palestrantes de 10 países ao redor do mundo. Por tradição, a conferência ocorrerá na cidade de Kyiv – Ucrânia.

Será falado sobre:

  • Arquitetura de apps;
  • Frameworks modernos, como GraphQL, TypeScript, etc;
  • Blockchain;
  • Desenvolvimento mobile, em particular com Flutter;
  • Aplicativos JS de IA;
  • Tópicos recentes em desenvolvimento de software;
  • Como se manter atento com as tecnologias e requisitos de mercado.

Você pode esperar palestras sobre os temas:

  • Frameworks;
  • JavaScript no Backend;
  • Embarcados;
  • Mobile;
  • JS Core;
  • Arquitetura de software;
  • Design de software;
  • Otimização de aplicações;
  • Teste de aplicações;
  • Blockchain;
  • Inteligência Artificial;
  • Machine Learning.

O que você pode esperar do evento?

Abordagens e Ferramentas:

Na conferência, será abordado o tema de uso de ferramentas, frameworks e boas práticas no desenvolvimento.

Palestrantes famosos mundo afora:

Foram convidados especialistas dos Estados Unidos, Europa e Ucrânia que irão realizar palestras cheia de exemplos práticos sobre projetos utilizados na vida real.

Novos tópicos no mundo da tecnologia:

É uma oportunidade para aprender sobre as inovações e receber os insights em primeira mão.

Atmosfera especial:

Será criada uma atmosfera especial para a comunicação, receber novos conhecimentos, aprender, compartilhar ideias e inspirações.

Novas conexões e networking:

Este evento em larga-escala é uma excelente chance de adquirir novos contatos que poderão ser úteis no futuro de sua carreira no desenvolvimento.

Excelente Organização:

Trabalhando apenas com fornecedores comprovados e com estrito cumprimento de cronograma, para não haver surpresas ruins para você.

Sorteios:

Os parceiros prepararam surpresas e concursos interessantes para os participantes do evento, então você pode, além do conhecimento, ganhar alguns presentes!

Casos práticos:

Profissionais com experiência prática compartilharão conhecimentos e contarão sobre os desafios enfrentados nos seus projetos.

Você pode verificar em: https://jsfest.com.ua/indexe.html

Gostou desta notícia? Comente abaixo e compartilhe com seus amigos!

Referências:

https://jsfest.com.ua/indexe.html

https://armacad.info/

 

Como criar eventos ao pressionar CTRL, ALT e SHIFT

Neste post rápido será visto como criar eventos para capturar quando o usuário pressiona CTRL, ALT ou SHIFT na tela do navegador. Aproveitando que isso já está sendo visto, também vamos testar algumas combinações de teclas.

A primeira parte que você precisa fazer é o evento. Você precisa dizer onde que deverá estar o foco na hora que foi apertado o botão, no nosso exemplo usaremos o document pois mais amplo que isso não tem como. Você pode usar o body ou até uma “zona” menor caso prefira.

 

JavaScript

document.addEventListener("keydown", function(event){});

 

JQuery

$(document).bind('keydown', function(event){ });

Note que estamos usando o evento “keydown”, isso é importante pois keypress e keyup não captura as teclas que queremos.


 

Agora vejamos sobre como saber o que foi clicado, você já deve ter tentado o key, keycode e which, mas nada aconteceu. Isso acontece pois precisamos acessar outras propriedades para saber se o CTRL, ALT ou SHIFT foram pressionados. Veja abaixo:

event.ctrlKey // CTRL

event.altKey // ALT

event.shiftKey // SHIFT

Simples assim? Sim, simples assim….

Então se quisermos saber quem foi pressionado, podemos fazer o seguinte:

 

JavaScript

document.addEventListener("keydown", function(event){

    if(event.ctrlKey) {
        console.log('ctrl');
    }

    if(event.altKey) {
        console.log('alt');
    }

    if(event.shiftKey) {
        console.log('shift');
    }
});

 

Para JQuery basta alterar a primeira linha por 

$(document).bind('keydown', function(event){

 

Por último, você pode estar querendo uma combinação, como por exemplo um CTRL + A. Agora que sabemos como pegar o CTRL, ficou fácil

document.addEventListener("keydown", function(event){

    if(event.ctrlKey && event.key == "a") {
        console.log('ctrl + a');
    }

});

 

É isso ai, espero que com esse post eu tenha ajudado outros que tiveram o mesmo problema para descobrir como criar estes eventos que combinam pressionar várias teclas. Até a próxima

Exercício Fácil – Evento com addEventListener()

O que são Eventos?

Eventos são ações que ocorrem em um sistema, resultando em interações que deixam as páginas web mais interessantes. Neste exercício, você deverá criar uma div com dois campos em HTML, chamados A e B, um botão chamado SOMAR, criando também uma função em JavaScript para somá-los. Utilizando o addEventListener, você deverá salvar os números assim que forem pressionados, utilizando-se da função “click”.

Requisitos:

Para este exercício, será necessário conhecimentos em Funções e Eventos.

Exercício:

Com base neste código HTML, crie a função soma e o evento addEventListener que irá receber os valores dos campos “inputValorA” e “inputValorB”.

Utilize este código HTML como base para realização do seu exercício:

<!DOCTYPE html>
<html>

<head>
    <meta charset="UTF-8" />
    <title>Exercicio Eventos</title>
</head>

<body>
    <div id="calculo">
        <!-- Crie os dois campos chamados "inputValorA" e "inputValorB" -->
        <fieldset>
            <label for="inputValorA">Valor de A:</label>
            <input id="inputValorA" type="number" placeholder="Digite o valor de A:">
        </fieldset>
        <fieldset>
            <label for="inputValorB">Valor de B:</label>
            <input id="inputValorB" type="number" placeholder="Digite o valor de B:">
        </fieldset>

        <!-- Criar um botão chamado SOMA -->
        <button class="calculo" type="submit">Somar</button>
    </div>
    <script>
    </script>
</body>

</html>

PARTE 1:

Crie uma função que retorne o somatório dos valores digitados pelo usuário nos campos de formulário.

Caso precise de ajuda, acesse este exercício sobre funções: Exercicio fácil: Funções como Parâmetro/

Protótipo da Função Soma:

// Esta função irá retornar o somatório
// dos valores A e B recebidos nos campos do HTML
function soma(a, b) {
    
    console.log(soma);
}

Parâmetros:

A função deverá receber dois parâmetros, A e B.

Valor de retorno:

A função deverá imprimir no console o somatório dos valores A e B.

PARTE 2:

Crie um evento que receba os valores que foram digitados nos campos “inputValorA” e “inputValorB”. Para isto, você deverá criar uma variável chamada botaoCalculo e utilizar o document.querySelector para selecionar a classe do botão(“.calculo”).

Caso precise de ajuda em eventos, acesse este link e confira o artigo Eventos no JavScript: Eventos no JavaScript

Logo após, deverá criar uma função addEventListener que irá receber os valores digitados.

Realizados estes procedimentos, efetuar a chamada da função soma, que irá retornar o somatório no console.

// Cria-se uma variável para buscar o elemento cálculo
// e após isso, crie um addEventListener para receber os valores dos inputs do HTML
let botaoCalculo = document.querySelector(".calculo");
variavel.addEventListener("click", function (evt) {
    
    let a = // Atribua o valor digitado no inputValorA no formato inteiro
    let b = // Atribua o valor digitado no inputValorB no formato inteiro
    
    // Realize a chamada da função soma, passando como parâmetros A e B
    soma();
})

Resolução:

O seu console.log ficará assim:

Eventos no JavaScript

O que são Eventos?

Eventos são ações que ocorrem no sistema. Envolver eventos na sua página web significa interação, que deixará a sua página mais atrativa e interessante. Podemos utilizar como exemplo, um clique em um botão em uma página web e este clique irá gerar uma ação (um evento).

Cada clique, cada tecla pressionada, um toque em uma tela touchscreen dão vida à sua página, criam interação. Estas interações são conhecidas como eventos.

Os eventos em JavaScript podem ser analisados em camadas. Por exemplo, preencher um formulário e devolver uma mensagem de sucesso ao usuário (alert()):

  • O campo é preenchido;
  • O usuário clica no botão de envio;
  • O botão dispara um evento;
  • O código escuta o evento disparado;
  • A mensagem de sucesso é mostrada ao usuário.

Quando o botão é clicado, o navegador emite a ação, que é conhecida como evento. A aplicação sabe que o botão foi clicado, mas se faz necessário saber o que acontece quando esta ação é realizada, fazendo-se necessário que o código esteja escutando ativamente o evento.

Cada evento disponível possui um manipulador de eventos, que é um bloco de código (uma função JavaScript) que é executado quando a ação foi disparada. Quando o código é rodado em resposta ao evento disparado, estamos registrando um manipulador de eventos. Em alguns casos, os manipuladores de eventos são chamados de escutadores de evento. Os escutadores escutam o evento acionado, e o manipulador de eventos é o código que será acionado em resposta a este acontecimento.

Eventos no JavaScript, como ocorrem?

// Nesta função, um evento será acionado
// quando o usuário pressioná-lo, e irá
// devolver uma mensagem de alerta na tela.
<!DOCTYPE html>
<html>

<head>
    <meta charset="UTF-8" />
    <title>Exemplo de Eventos</title>
</head>

<body>
    <button>Pressione Aqui</button>
    <script>
        var btn = document.querySelector('button');

        btn.addEventListener('click', mostrarCaixa, false);

        function mostrarCaixa(e) {
            window.alert("Você clicou em mim!");
        }
    </script>
</body>

</html>

Este código gera uma escuta de um evento (clicar no botão) e uma reação a ele (mostrar a caixa de diálogo).

Escutando Eventos (addEventListener()):

Eventos são disparados. A tarefa de escutar o evento certo é tratada pela função addEventListener(). Esta função notifica as outras partes do aplicativo quando o evento é disparado. Ela é usada da seguinte forma:

source.addEventListener(eventName, eventHandler, false);

Onde:

  • source é o nome da função (btn no caso de exemplo acima);
  • eventName é a especificação do evento que será escutado (‘click’ no nosso exemplo);
  • eventHandler é a especificação da função que será chamada quando o evento for disparado ( mostrarCaixa no exemplo acima);
  • O último argumento diz respeito às fases do evento, capturing e bubbling (conceitos que serão vistos adiante).

Manipuladores e Argumentos de Evento:

A função que é chamada quando um evento é disparado é conhecido como Manipulador de Eventos (event handler). Pelo addEventListener, conseguimos perceber que o nosso manipulador de eventos é a função mostrarCaixa.

btn.addEventListener('click', mostrarCaixa, false);

A declaração da função é praticamente a mesma que qualquer outra função declarada, com a exceção de que a função recebe um argumento, conhecido como argumentos de evento (“eventargs”). Estes argumentos de evento fornecem mais detalhes sobre o evento, tornando o manipulador mais inteligente. O manipulador de eventos do exemplo não faz nada com os argumentos do evento, mas serve como base para você criar argumentos ao seu critério.

Os argumentos de evento contém propriedades relevantes ao evento disparado. Por exemplo, uma ação disparada por um click do mouse terá propriedades diferentes em seus argumentos do evento de uma ação disparada por um toque na tela(no caso de telas touchscreen) e de uma tecla clicada.

Borbulhamento e captura de eventos (bubbling e capturing):

Borbulhamento e captura de eventos descrevem o que acontece quando dois manipuladores do mesmo tipo de evento são ativados em um elemento.

Na fase de captura:
  • O navegador verifica se o ancestral mais externo do elemento (<html>) tem um manipulador de eventos registrado nele e o executa.
  • Ele realiza o mesmo procedimento dentro dos elementos filhos até alcançar o elemento clicado.
Na fase de Borbulhamento:
  • O navegador verifica se o elemento clicado tem um manipulador de elementos registrado e o executa.
  • Em seguida, ele passa para o próximo elemento ancestral imediato e realiza a mesma coisa sucessivamente, até alcançar o elemento (<html>).