Gostou do nosso conteúdo? Te ajudou?
Nos ajude também! Faça um PIX, de qualquer valor:
programacao.progressiva@gmail.com

Introdução ao Canvas - Desenhando um Retângulo

Neste tutorial introdutório, vamos aprender como começar a usar o canvas em JavaScript, aprendendo a desenhar um retângulo e mudar algumas propriedades, como cores e espessura da linha.

Introdução ao Canvas: elemento <canvas>


O canvas é uma forma de fazer desenhos e diversos tipos de atividades gráficas, fazendo uma mistura de HTML5 e JavaScript.

Sem mais delongas, vamos aprender como usar o canvas.
Ele funciona como um outro elemento qualquer do HTML, para delimitar uma região onde iremos desenhar e atuar graficamente, delimite pelas tags:

<canvas>
  O Canvas não está ativado em seu Browser
</canvas>


A primeira coisa que fazemos é digitar um texto ali. Esse texto vai ser exibido caso não seja possível renderizar nada do Canvas, ou seja, se o Canvas não funcionar no seu navegador, vai aparecer essa mensagem de texto.

Mas só as tags não servem de nada, vamos adicionar alguns atributos:
  1. id = para fazer a identificação do elemento
  2. width = largura do canvas
  3. height = altura do canvas

Vamos experimentar um canvas de tamanho 300 x 200 (300 pixels de largura por 200 pixels de altura):
<canvas id = "meuRetangulo" width = "300" height = "200"
        style = "border: 1px solid black;">
   O Canvas não está ativado em seu Browser
</canvas>

Note que adicionamos um estilo, uma borda de 1px de espessura, sólida e preta, para você poder visualizar a área do canvas. Assim como uma <img>, o <canvas> também pode ser estilizado em relação a borda, espessura, cor, fundo etc. De fato, ele é bem parecido com o elemento <img>, como você vai notar no decorrer do tutorial.

Insira o código acima após a tag <body> do seu documento HTML e veja a mágica acontecer, vai aparecer uma tela, uma lona (canvas em inglês), é nessa região onde vamos trabalhar graficamente!

Sistema de Coordenada do Canvas

Antes de entrarmos em mais detalhes sobre o uso do canvas, precisamos entender seu sistema de coordenadas, que não é igual o nosso.

O dele é assim:
Tutorial de Canvas

Ou seja, ao contrário do nosso, ele começa no canto superior esquerda.
O eixo Y cresce de cima pra baixo (no nosso sistema cartesiano, é de baixo pra cima).
O eixo X é igual, cresce da esquerda pra direita.

Assim, um ponto (x,y) está na posição X (da esquerda pra direita) do eixo horizontal e na posição Y no eixo vertical (de cima pra baixo). Ao longo dos tutoriais, usaremos essa lógica.

Renderizando e Definindo o Contexto no Canvas: getContext()

O nosso código criou o 'canvas', é como se fosse um painel, onde iremos desenhar.
Obviamente, ele ainda está em branco, só tem seu esboço com sua borda.

Para começarmos a renderizar algum gráfico no nosso canvas, vamos usar uma linguagem de script, no caso, a melhor de todas: JavaScript. Mas antes, vamos criar um nó entre nosso canvas e uma variável de nome canvas:
var canvas = document.getElementById("meuRetangulo"); 
Prontinho. O próximo passo é usar um método especial, chamado getContext() do Canvas. Com ele, vamos definir o contexto de nosso uso do canvas, ou seja, para que e como queremos usar a região.

No nosso caso, queremos fazer gráficos de duas dimensões, 2D, então vamos passar como argumento '2d'. Vamos definir nossa variável de contexto:
var context = canvas.getContext("2d");

Esse é apenas um dos contextos possíveis para se trabalhar com Canvas, neste tutorial vamos usar apenas o 2D mesmo.

Agora nossa variável context vai ter acesso a diversos atributos e métodos, como o que desenha um retângulo.

Desenhando um Retângulo: fillRect()

Ok, finalmente vamos lá, desenhar nosso bendito retângulo.

Para isso, vamos usar um método do canvas, o fillRect(), que recebe 4 argumentos: os dois primeiros são as coordenadas do ponto inicial (mais próximo da origem) e os dois últimos são largura (eixo x) e altura (eixo y).

Por exemplo, se o ponto mais próximo do retângulo à origem é: (10, 20)
E queremos 270px de largura e 150 de altura, os outros argumento são: (270,150)

Nosso método que desenha o retângulo, é:
context.fillRect(10, 20, 270, 150);

Resultado:
Tutorial completo de canvas

Pintando um retângulo: fillStyle

Note que o retângulo, por padrão, é pintado de preto.
Para preencher ele de outra cor, azul por exemplo, basta usarmos o atributo fillStyle com a cor que desejamos, ANTES, de desenharmos o retângulo com o fillRect.

Veja como fica nosso código JS pra desenhar e pintar um retângulo de azul:
context.fillStyle = "blue";
context.fillRect(10, 20, 270, 150);

Cor e Espessura da borda: strokeStyle e lineWidth

O canvas, aliado ao JS, é tão poderoso, que podemos personalizar muita coisa, incluindo a cor da linha do retângulo, bem como sua espessura.

Vamos desenhar uma nova borda, por cima do nosso quadrado. 
Definimos a cor da borda com o atributo strokeStyle, vamos pintar de vermelha.
Definimos a espessura através do atributo lineWidth, vamos usar o valor 3.

Veja o código HTML completo com JS de nosso retângulo azul, de borda vermelha e espessura 3:

<!DOCTYPE html>
<meta charset="UTF-8">
<html>
 <head>
    <title>Apostila JavaScript Progressivo</title>
 </head>
 <body>
  <canvas id = "meuRetangulo" width = "300" height = "200"
      style = "border: 1px solid black;">
  O Canvas não está ativado em seu Browser
 </canvas>
 <script type="text/javascript">
  var canvas = document.getElementById("meuRetangulo");
  var context = canvas.getContext("2d")

  //Desenhando o retângulo pintado de azul
  context.fillStyle = "blue";
  context.fillRect(10, 20, 270, 150);

  //Desenhando uma borda vermelha
  //de espessura 3
  context.strokeStyle = "red";
  context.lineWidth = 3;
  context.strokeRect(10, 20, 270, 150);
 </script>
 </body>
</html>

Desenhando retângulos transparantes

O código abaixo desenha um quadrado azul, e começando no meio desse quadrado azul, desenhamos um quadrado vermelho, porém este último tem 50% de transparência (0.5), veja o código:

<!DOCTYPE html>
<meta charset="UTF-8">
<html>
 <head>
    <title>Apostila JavaScript Progressivo</title>
 </head>
 <body>
  <canvas id = "meuRetangulo" width = "300" height = "200"
      style = "border: 1px solid black;">
  O Canvas não está ativado em seu Browser
 </canvas>
 <script type="text/javascript">
  var canvas = document.getElementById("meuRetangulo");
  var context = canvas.getContext("2d")

  //Quadrado azul
  context.fillStyle = "rgb(0,0,200)";
  context.fillRect(50, 50, 50, 50);

  //Quadrado vermelho com transparência
  context.fillStyle = "rgb(200,0,0, 0.5)";
  context.fillRect(75, 75, 50, 50);
 </script>
 </body>
</html>

Veja o resultado:
Tutorial de Canvas completo grátis

A única coisa diferente que fizemos foi definir as cores do atributo fillStyle, que usamos o sistema RGB de cores para definir as cores dos quadrados.
E no último quadrado, fornecermos um dado a mais: 0.5 (para representar 50% de transparência).

Para saber mais sobre o sistema de RGB de cores:

Eventos de formulário: onfocus e onblur (focus e blur)

Neste tutorial, iremos aprender dois importantes eventos para se trabalhar com formulários em HTML e JavaScript o onblur e o onfocus (ou só focus e blur em event handler).

Eventos onfocus e onblur de Formulários

O evento onfocus dispara quando algum tipo de formulário (como input) está selecionado, ou seja, quando estamos usando ele, clicamos, digitamos ou estamos exercendo alguma ação nele.

Já o evento onblur ocorre quando 'saímos' desse formulário.

Por exemplo, no código abaixo, se você clicar no formulário de input,  o evento onfocus vai chamar a função dentro(), que pinta de vermelho o fundo do input, e quando você clicar fora do formulário, o evento onblur dispara e é acionada a função fora() que exibe pinta o inpt em azul:

Código HTML:
<!DOCTYPE html>
<meta charset="UTF-8">
<html>
 <head>
    <title>Apostila JavaScript Progressivo</title>
    <script type="text/javascript" src="script.js"></script>
 </head>
 <body>
 Clique dentro e fora:<input type="text" id="meuInput" 
                onfocus="dentro()" onblur="fora()">
 </body>
</html>

script.js:
function dentro()
{
   document.getElementById("meuInput").style.background = "red";
}

function fora()
{
   document.getElementById("meuInput").style.background = "blue";
}
Resultado:

Clique dentro e fora:


Event Handler: focus e blur

Os eventos se chamam onfocus e onblur na forma de propriedade de um elemento do HTML.
Se desejar trabalhar com estes eventos via JavaScript puramente, pelos event handlers e método addEventListener, os nomes são focus e onblur.

Veja como ficaria o exemplo anterior.
Código HTML:
<!DOCTYPE html>
<meta charset="UTF-8">
<html>
 <head>
    <title>Apostila JavaScript Progressivo</title>
    <script type="text/javascript" src="script.js"></script>
 </head>
 <body>
 Clique dentro e fora:<input type="text" id="meuInput">
 </body>
</html>


script.js
window.onload = function(){
   function dentro()
   {
 document.getElementById("meuInput").style.background = "red";
   }

   function fora()
   {
 document.getElementById("meuInput").style.background = "blue";
   }

   document.getElementById("meuInput").addEventListener("focus", dentro);
   document.getElementById("meuInput").addEventListener("blur", fora);
}

Certamente você já viu esse tipo de efeito ao preencher algum formulário, principalmente aqueles grande, com vários campos.

Se você for criar um sistema que possui diversos formulários, é sempre interessante usar focus e blur, visto que facilitam para o usuário saber em que campo dos formulários ele está situado, isso o ajuda a não se perder e seu projeto terá uma cara mais profissional.

Eventos de Teclado - onkeydown, onkeyup e onkeypress

Neste tutorial de JavaScript, vamos aprender a detectar eventos de teclado, como onkeydown, onkeyup e o onkeypress.

Eventos de teclado: onkeydown, onkeyup e o onkeypress

Assim como os eventos de mouse, de apertar o botão do mouse, soltar e clicar, existe o mesmo para o caso de teclas do seu teclado.

O onkeywdown detecta quando a tecla é pressionada (bem rápido)
O onkeyup é o evento que detecta o contrário, quando você solta a tecla.
E o onkeypress é o de apertar uma teclada como ALT, CONTROl ou SHIFT.

O primeiro evento a ocorrer no processo de digitar uma tecla é o onkeydown, depois imediatamente onkeypress, então o sistema captura a teclada e depois ocorre o onkeyup.

No exemplo abaixo, um código simples que mostra "DOWN" quando estamos apertando uma tecla e mostra o texto "UP" quando soltamos:

Código HTML:
<!DOCTYPE html>
<meta charset="UTF-8">
<html>
 <head>
    <title>Apostila JavaScript Progressivo</title>
    <script type="text/javascript" src="script.js"></script>
 </head>
 <body>
 Digite algo: <input type="text" id="caixa" onkeydown="down()"  onkeyup="up()">
 <div id="status"></div>

 </body>
</html>

script.js:
function down()
{
 document.getElementById("status").innerHTML="DOWN";
}

function up()
{
 document.getElementById("status").innerHTML="UP";
}

Resultado:

Digite algo:



Existe muita teoria e coisas complicadas por trás do uso da onkeypress, principalmente junto da onkeydown, então quem quiser saber em mais detalhes, veja aqui uma boa discussão:
https://stackoverflow.com/questions/3396754/onkeypress-vs-onkeyup-and-onkeydown

Se quisermos usar event handlers, basta usarmos os eventos com os nomes keydown, keypress e keyup. Nosso código JavaScript ficaria:


window.onload = function(){
 function down()
 {
  document.getElementById("status").innerHTML="DOWN";
 }

 function up()
 {
  document.getElementById("status").innerHTML="UP";
 }
 
 document.getElementById("caixa").addEventListener("keydown", down);
 document.getElementById("caixa").addEventListener("keyup", up);
}


O HTML é fica mais simples:
<!DOCTYPE html>
<meta charset="UTF-8">
<html>
 <head>
    <title>Apostila JavaScript Progressivo</title>
    <script type="text/javascript" src="script.js"></script>
 </head>
 <body>
 Digite algo: <input type="text" id="caixa">
 <div id="status"></div>

 </body>
</html>

Detectando uma tecla pressionada

Uma importante funcionalidade é saber que tecla foi digitada, ou seja, qual foi pra baixo (keydown).
Para saber, basta usar a propriedade key do objeto event.

No exemplo abaixo, vamos criar um script que detecta quando você digita alguma vogal: a, e, i, o ou u

Código HTML:

<!DOCTYPE html>
<meta charset="UTF-8">
<html>
 <head>
    <title>Apostila JavaScript Progressivo</title>
    <script type="text/javascript" src="script.js"></script>
 </head>
 <body>
 Digite algo: <input type="text" onkeydown="detecta(event)">
 </body>
</html>

script.js:
function detecta(event)
{
    var tecla = event.key;
    if (tecla == "a")
     alert ("Você apertou 'a'");
 if (tecla == "e")
     alert ("Você apertou 'e'");
 if (tecla == "i")
     alert ("Você apertou 'i'");
 if (tecla == "o")
     alert ("Você apertou 'o'");
 if (tecla == "u")
     alert ("Você apertou 'u'");
}

Note que, na propriedade onkeydown chamamos a função detecta() e passamos como argumento o objeto event. Esse objeto está cheio de informações importantes.

Uma delas, é a propriedade key: event.key
Nela, fica armazenada a tecla que você pressionou.

Basta agora comparar com 'a', 'e', 'i', 'o' ou 'u' para saber qual  foi pressionada.

Propriedades do objeto KeyboardEvent

Quando pressionamos uma tecla, um objeto especial é criado, é do tipo KeyboardEvent e ele possui diversas propriedades e métodos. No tópico anterior, usamos a propriedade key para detectar qual tecla foi digitada.

Existem diversas outras, e é importante você ter ao menos noção dos tipos de eventos que pode se trabalhar com seu teclado, caso um dia precise de algo, veja:
  • altKey - Retorna se ALT foi pressionada
  • charCode - Retorna o código unicode do caractere digitado
  • code - Retorna o código da tecla pressionada (cada tecla tem seu número, seu código)
  • ctrlKey - Retorna se a tecla CTROL foi pressionada
  • getModifierState() - Retorna se determinada teclada está ativada
  • key - Retorna a teclada digitada e detectada pelo evento
  • keyCode - Retorna o código Unicode da tecla que disparou o evento onkeypress, ou onkey down ou onkeyup
  • location - Retorna a localização da tecla no teclado
  • metaKey - Retorna se uma tecla "meta" foi pressionada
  • repeat - Retorna se uma teclada está sendo mantida pressionada ou não
  • shiftKey - Retorna se a tecla SHIFT foi pressionada ou não

Para saber em mais detalhes sobre cada uma dessas propriedades ou método:
https://www.w3schools.com/jsref/obj_keyboardevent.asp

Tratando Eventos (Event Handler) e o método addEventListener

Neste tutorial de nossa apostila de JavaScript, vamos aprender como trabalhar com os tratadores de eventos (event handlers) através do método addEventListener(), do JS.

Tratadores de Eventos - Event Handlers

Até o momento, durante nossos estudos de Eventos em JavaScript, estávamos lidando com os eventos a partir de atributos no código HTML.

Veja o exemplo do tutorial anterior, sobre Eventos envolvendo o Mouse, em um código de botão em HTML:

<button onmousedown="aperta()" 
        onmouseup="solta()" 
        onclick="clica()">
        Clique neu!</button>


Só aí temos três atributos lidando com eventos: onmousedown, onmouseup e onclick.
Mas além de ser desagradável para muitos programadores ficar misturando código JS dentro de HTML, isso tem uma limitação: você só pode associar uma função para um evento, apenas.

Porém, muitas vezes se faz necessário vários eventos, num mesmo elemento.
Por exemplo, ao passar o mouse pelo botão talvez você queira que ele mude de cor ou passo que exiba um alert: "Tem certeza que deseja apertar esse botão? Mwahahaha"

Para isso, precisamos trabalhar com 'tratadores de eventos', do inglês event handlers, que nada mais são que funções que vão tratar eventos, mas agora direto no código JavaScript.

O Método addEventListener

Para trabalharmos com event handler, precisamos associar uma função a determinado elemento. O nome disso é registrar o tratador de eventos e isso é feito com o método addEventListener, que tem a seguinte sintaxe:
elemento.addEventListener(evento, nome_da_função, false ou true)

Por exemplo, vamos criar um botão simples, cujo código HTML é:

<button id="meuBotao">Clique!</button>


Assim, seu nome (id), é "meuBotao".
Agora vamos no JavaScript e vamos 'pegar esse botão':
document.getElementById("meuBotao")

Neste elemento, vamos usar o método addEventListener, para toda vez que o evento "click" ocorrer, ele chame a função clique, veja o código completo:
<!DOCTYPE html>
<meta charset="UTF-8">
<html>
 <head>
    <title>Apostila JavaScript Progressivo</title>
    <script type="text/javascript" src="script.js"></script>
 </head>
 <body>
 <button id="meuBotao">Clique aqui</button>
 <script>
  document.getElementById("meuBotao").addEventListener("click", clique);

  function clique() {
    alert("Clicou!");
  }
</script>
 </body>
</html>
Rode e faça o teste.

Tratamento de eventos em arquivo externos

No exemplo anterior, fizemos com o script dentro do documento HTML direto.
Se tentar colocar o código JS num arquivo externo, como script.js, vai ver que não funciona.

Isso ocorre por o script não foi 'carregado' (load).
Para carregarmos, basta fazermos: windows.load = function (){ código JS}

Vamos ver o código do exemplo anterior, com o código JavaScript num arquivo externo.
HTML:
<!DOCTYPE html>
<meta charset="UTF-8">
<html>
 <head>
    <title>Apostila JavaScript Progressivo</title>
    <script type="text/javascript" src="script.js"></script>
 </head>
 <body>
 <button id="meuBotao">Clique aqui</button>
 </body>
</html>

script.js:
window.onload = function(){
 function minhaFuncao(){
     alert("Clicou!");
 }
 
 document.getElementById("meuBotao").addEventListener('click', minhaFuncao, false);
}
O que ocorre aqui é que, ao terminar de carregar a janela (windows.load), ele vai automaticamente carregar o arquivo externo, sem ele, nosso tratador de eventos não funciona, pois ninguém carregou o script.js antes.

Lista de eventos para usar na addEventListener():

Eventos de Mouse - onmousedown, onmouseup, onclick, onMouseOver e onMouseOut

Neste tutorial de nosso curso de JavaScript, vamos aprender 5 importantes eventos de mouse: onmousedown, onmouseup, onclick, onMouseOver e onMouseOut

Com eles, vamos aprender a detectar quando o usuário apertou o botão, soltou, clicou, passou por cima e saiu de cima de uma área com o mouse.

Eventos onmousedown, onmouseup e onclick- Apertando, soltando e clicando


O evento onmousedown significa 'quando o mouse for pra baixo', ou seja, quando você é o evento que detecta a ação de apertar o botão do mouse.

Já o evento onmouseup, significa 'quando o soltar o mouse', ou seja, é um evento que detecta o ato de soltar o botão do mouse

O terceiro evento, nós já conhecemos, é o onclick, e significa 'ao clicar'. Clicar é o ato de apertar e soltar alguma botão do mouse. Quando você só aperta, ele não faz nada, nem se somente soltar. Este evento só ocorre quando você clica, ou seja, quando você aperta e solta, a ação completa é que dispara o evento onclick, ok?

No script abaixo, criamos um botão em HTML e duas divs, que vão exibir a ação que você tomou.
Quando você clica no mouse, o evento onmousedown dispara a função "aperta()".
Quando você solta o botão do mouse, o evento onmouseup dispara a função "solta()".
E, por fim, quando você clica, o evento onclick dispara a ação "clica()".

Código HTML:
<!DOCTYPE html>
<meta charset="UTF-8">
<html>
 <head>
    <title>Apostila JavaScript Progressivo</title>
    <script type="text/javascript" src="script.js"></script>
 </head>
 <body>
  <button onmousedown="aperta()" onmouseup="solta()" onclick="clica()">Clique neu!</button>
  <div id="status"></div>
  <div id="status2"></div>
 </body>
</html>


script.js:
function aperta()
{
 var status=document.getElementById("status");
 status.innerHTML="Você apertou o botão do mouse";
}

function solta()
{
 var status=document.getElementById("status");
 status.innerHTML="Você soltou o botão do mouse";
}

function clica()
{
 var status2=document.getElementById("status2");
 status2.innerHTML="Você clicou com o botão do mouse";
}
Resultado:





Eventos onMouseOver e onMouseOut - Passando e Tirando o mouse de um elemento

Ainda no mundo dos eventos com o mouse, existem dois bem interessantes.

Um é o onMouseOver, que em inglês quer dizer 'quando o mouse tiver por cima', que detecta a ação do mouse estar sobre um determinado elemento da página.

Já o onMouseOut detecta o contrário: o evento de sair com o mouse de uma região.

No código abaixo, definimos um quadrado via div.
Ele originalmente tem fundo vermelho.

Quando passamos o mouse por cima, o evento onMouseOver é acionado, que chama a função "porCima()" e passa o atual objeto (this), que é a div, para a função. Lá, o fundo é alterado para verde.

Quando você tira o mouse de cima dessa região, o evento onMouseOut é acionado, que chama a função "porFora()", onde o parâmetro é o objeto atual. Dentro da função, alteramos o fundo do objeto (div) para azul.

Código HTML:

<!DOCTYPE html>
<meta charset="UTF-8">
<html>
 <head>
    <title>Apostila JavaScript Progressivo</title>
    <script type="text/javascript" src="script.js"></script>
 </head>
 <body>
  <div onmouseover="porCima(this)" onmouseout="porFora(this)"
   style="background-color:#FF0000; width:100px; height:100px;">Coloque o mouse aqui</div>
 </body>
</html>


script.js:
function porCima(obj)
{
 obj.style.backgroundColor = "#00FF00";
    obj.innerHTML = "Mouse dentro!";
}
 
function porFora(obj)
{
 obj.style.backgroundColor = "#0000FF";
    obj.innerHTML = "Mouse fora!";
}


Resultado:

Coloque o mouse aqui

Evento onchange - Evento de mudança de um elemento

Neste tutorial de nossa apostila de JavaScript, vamos aprender a usar evento onchange.

O Evento onchange


O evento onchange é utilizado nos chamados elementos de opção.
Ou seja, o evento dispara uma ação quando uma mudança ocorre em algum elemento.

As sintaxes de uso, são:
Inline:
<elemento onchange="minhaFunaco()">
No código JavaScript
meuObjeto.onchange = function(){
 //codigo da
 //funcao
};

Através do método addEventListener:
meuObjeto.addEventListener("change", minhaFuncao);


Exemplo de uso do evento onchange

Vamos usar uma input para exemplificar o evento onchange.
Iremos digitar algo na caixa de input e depois clicamos fora dela. Quando fizermos isso, tudo o que digitamos vai virar maiúsculo!


Código HTML:
<!DOCTYPE html>
<meta charset="UTF-8">
<html>
 <head>
    <title>Apostila JavaScript Progressivo</title>
    <script type="text/javascript" src="script.js"></script>
 </head>
 <body>
  Digite algo: <input type="text" id="meuInput" onchange="minhaFuncao()">
 </body>
</html>
script.js
function minhaFuncao()
{
   var minhaInput=document.getElementById("meuInput");
   minhaInput.value=(minhaInput.value).toUpperCase();
}
O que ocorre é que quando digitamos algo, estamos fazendo uma alteração, uma mudança (change, em inglês).

Quando clicamos fora da input, ela detecta que algo mudou nela e o evento onchange dispara, fazendo o que? Invocando a função minhaFuncao().

Essa função, do JS, vai pegar a input e ligar ela a variável minhaInput.
Agora pegamos o que tem escrito no input: minhainput.value
E fazemos receber essa mesma string, porém transformada em caracteres maiúsculos, através do método toUpperCase(), do objeto String, que já estudamos.


Teste o resultado, digite algo e depois clique fora:

Digite algo:


Ou seja, você deve usar o evento onchange quando desejar detectar alguma mudança, em seus elementos de opção.

Esses elementos, são:
  1. <input> - com type="checkbox", "color", "date", "datetime", "email", "file", "checkbox", "color", "password", "radio", "range", "search", "tel", "text", "time", "url", ou "week"
  2. <select>
  3. <textarea>

Exercício de JavaScript

No script anterior, ao invés de colocar todas as letras para maiúscula, faça com que apareça uma janela de alert, com a string digitada pelo usuário no formulário de input.