Boas-vindas

Olá! Se você deseja aprender como escrever em arquivos em Python, este artigo é para você. Trabalhar com arquivos é uma habilidade importante que todo desenvolvedor em Python deve aprender.

Neste artigo, você saberá:

• Como abrir um arquivo.
• Como ler um arquivo.
• Como criar um arquivo.
• Como modificar um arquivo.
• Como fechar um arquivo.
• Como abrir arquivos para várias operações.
• Como trabalhar com métodos de objetos de arquivo.
• Como excluir arquivos.
• Como trabalhar com gerenciadores de contexto e porquê eles são úteis.
• Como lidar com exceções que podem surgir enquanto trabalha com seus arquivos
• e mais!

Vamos começar! ✨

🔹 Trabalhando com arquivos: sintaxe básica

Uma das funções mais importantes que você precisará usar enquanto trabalha com arquivos em python é open(), uma função interna que abre arquivos e permite que seus programas os utilizem e trabalhem com eles.

Esta é a sintaxe básica:

💡 Dica: estes são os dois argumentos mais comumente utilizados para chamar esta função. Existem mais seis opções de argumentos. Para aprender mais sobre eles, leia este artigo da documentação.

Primeiro parâmetro: o arquivo

O primeiro parâmetro da função open() é o file, o caminho relativo ou absoluto do arquivo em que você está tentando trabalhar.

Geralmente, utilizamos um caminho relativo. Ele indica onde o arquivo está localizado em relação à localização do script (arquivo Python) que está chamando a função open().

Por exemplo, o caminho nesta chamada de função:

open("names.txt") # O caminho relativo é "names.txt"

Ele contém apenas o nome do arquivo. Isso pode ser utilizado quando o arquivo que você deseja abrir está no mesmo diretório ou pasta em que o script em Python está localizado, desta forma:

Se o arquivo estiver dentro de uma pasta, assim:

Então, devemos especificar o caminho para dizer à função que o arquivo se encontra dentro de outra pasta.

Neste exemplo, este seria o caminho:

open("data/names.txt")

Note que estamos escrevendo data/ primeiro (o nome da pasta seguido por /) e, então, names.txt (o nome do arquivo com a extensão).

💡 Dica: as três letras .txt que vêm depois do ponto, em names.txt, são a "extensão" do arquivo, ou seu tipo. Neste caso, .txt indica que ele é um arquivo de texto.

Segundo parâmetro: o modo

O segundo parâmetro da função open() é mode, uma string de apenas um caractere. Este único caractere diz ao Python o que você pretende fazer com o arquivo no seu programa.

Os modos disponíveis são:

• Ler ("r").
• Adicionar ("a")
• Escrever ("w")
• Criar ("x")

Você também pode escolher abrir o texto em:

• Modo texto ("t")
• Modo binário ("b")

Para utilizar o modo de texto ou binário, será necessário adicionar os caracteres no modo principal. Por exemplo: "wb" representa escrever em modo binário.

💡 Dica: os modos padrão são ler ("r") e texto ("t"), o que significa "abrir para a leitura de texto" ("rt"). Então, você não precisar declarar isso dentro da função open() se quiser utilizá-los, pois esses modos são declarados por padrão. Você pode simplesmente escrever open(<nome_do_arquivo>).

Por que modos?

Faz sentido para o Python garantir apenas certas permissões com base no que você planeja fazer com o arquivo. Por que ele deveria permitir que seu programa faça mais que o necessário? Por isso que existem os modos.

Pense — permitir que o programa faça mais do que o necessário pode ser problemático. Por exemplo, se você precisar apenas ler o conteúdo do arquivo, será perigoso permitir que o seu programa o modifique inesperadamente, o que pode, potencialmente, causar alguns bugs.

🔸 Como ler um arquivo

Agora que você sabe mais sobre os argumentos que a função open() utiliza, vamos ver como podemos abrir o arquivo e salvá-lo dentro de uma variável para a utilizarmos dentro do programa.

Esta é a sintaxe básica:

Estamos apenas atribuindo o valor retornado a uma variável. Por exemplo:

names_file = open("data/names.txt", "r")

Talvez você se pergunte: qual o tipo de valor retornado por open()?

Bem, um objeto de arquivo.

Vamos falar um pouco sobre eles.

Objetos de arquivo

De acordo com a documentação do Python, um objeto de arquivo é:

Um objeto expondo uma API orientada a arquivos (com métodos como read() ou write()) para um recurso subjacente.

Isto nos diz que um objeto de arquivo é um objeto que nos permite trabalhar e interagir com arquivos existentes no nosso programa em Python.

O objeto de arquivo possui atributos, como:

• name: o nome do arquivo.
• closed: True se o arquivo estiver fechado. Do contrário, False.
• mode: o modo usado para abrir o arquivo.

Por exemplo:

f = open("data/names.txt", "a")
print(f.mode) # Output: "a"

Agora vamos ver como acessar o conteúdo do arquivo através de objetos de arquivo.

Métodos para ler um arquivo

Para lermos um objeto de arquivo, precisamos ter uma forma de "interagir" com ele em nosso programa e é exatamente isso que métodos fazem. Vamos ver alguns desses métodos.

Read()

O primeiro método que precisamos aprender é read(), que retorna todo o conteúdo do arquivo como uma string.

Aqui temos um exemplo:

f = open("data/names.txt")
print(f.read())

O resultado é:

Nora
Gino
Timmy
William

Você pode usar a função type() para confirmar que o valor retornado por f.read() é uma string:

print(type(f.read()))

# Resultado
<class 'str'>

Sim, é uma string!

Neste caso, o arquivo inteiro foi o resultado, pois não definimos um número máximo de bytes, mas também podemos fazer isso.

Segue um exemplo:

f = open("data/names.txt")
print(f.read(3))

O valor retornado é limitado ao número de bytes:

Nor

❗️Importante: você precisar fechar o arquivo após a tarefa ter sido concluída para liberar os recursos associados a esse arquivo. Para fazer isso, chamamos o método close(), assim:

Readline() x Readlines()

Podemos ler o arquivo linha por linha através desses dois métodos. Eles têm uma pequena diferença. Vamos vê-los em detalhes.

readline() lê uma linha do arquivo até o fim dessa linha. Um caractere de nova linha (\n) à direita é mantido na string.

💡 Dica: como opção, podemos passar o tamanho, o número máximo de caracteres que desejamos incluir no resultado da string.

Por exemplo:

f = open("data/names.txt")
print(f.readline())
f.close()

O resultado é:

Nora

Essa é a primeira linha do arquivo.

Por outro lado, readlines() retorna uma lista com todas as linhas do arquivo como elementos individuais (strings). Esta é a sintaxe:

Por exemplo:

f = open("data/names.txt")
print(f.readlines())
f.close()

O resultado é:

['Nora\n', 'Gino\n', 'Timmy\n', 'William']

Observe que há um \n (caractere de nova linha) ao final de cada string, excetuando a última.

💡 Dica: você pode obter a mesma lista com list(f).

Podemos trabalhar com esta lista no nosso programa designando-a a uma variável ou utilizando-a dentro de um laço:

f = open("data/names.txt")

for line in f.readlines():
    # Fazer algo com cada linha
    
f.close()

Também podemos iterar por f diretamente (o objeto de arquivo) em um laço:

f = open("data/names.txt", "r")

for line in f:
	# Do something with each line

f.close()

Esses são os principais métodos utilizados para se ler um objeto de arquivo. Vamos agora ver como criar arquivos.

🔹 Como criar um arquivo

Se você precisar criar um arquivo "dinamicamente" usando Python, podemos fazer isso com o modo "x".

Vamos ver como fazer isso. Esta é a sintaxe básica:

Aqui está um exemplo. Este é o meu diretório de trabalho atual:

Se eu executar esta linha de código:

f = open("new_file.txt", "x")

Um novo arquivo com aquele nome será criado:

Com este modo, você pode criar arquivos e escrevê-los dinamicamente usando os métodos que você aprenderá em instantes.

💡 Dica: o arquivo será inicializado vazio até que você o modifique.

Um fato curioso: se você tentar rodar esta linha novamente e um arquivo com o mesmo nome já existir, você verá este erro:

Traceback (most recent call last):
  File "<path>", line 8, in <module>
    f = open("new_file.txt", "x")
FileExistsError: [Errno 17] File exists: 'new_file.txt'

De acordo com a documentação do Python, essa exceção (erro em tempo de execução):

Aparece ao tentar criar um arquivo ou diretório que já existe.

Agora que você já sabe criar um arquivo, vamos ver como podemos modificá-lo.

🔸 Como modificar um arquivo

Para modificar (escrever em) um arquivo, precisamos utilizar o método write(). Há duas formas de se fazer isso (acrescentar ou escrever) baseado no modo em que você escolheu abrir o arquivo. Veremos isso em detalhes.

Acrescentar (append)

Acrescentar, aqui, significa acrescentar algo no final de outra coisa. O modo "a" permite que você abra um arquivo para acrescentar conteúdo a ele.

Por exemplo, se tivermos este arquivo:

e se quisermos adicionar uma nova linha a ele, podemos abrir o arquivo utilizando o modo "a" (append) e, em seguida, chamar o método write(), passando o conteúdo que queremos acrescentar como argumento.

Esta é a sintaxe básica para chamarmos o método write():

Aqui vemos um exemplo:

f = open("data/names.txt", "a")
f.write("\nNew Line")
f.close()

💡 Dica: observe que estou adicionando um \n antes da linha para indicar que quero que apareça em uma nova linha, não em uma continuação da linha existente.

Este é o arquivo agora, após a execução do script:

💡 Dica: a nova linha pode não ser exibida no arquivo até que f.close() seja executado.

Escrever (write)

Às vezes, você pode querer excluir um conteúdo do arquivo e substituí-lo totalmente por um novo conteúdo. Podemos fazer isso utilizando o método write() se abrirmos o arquivo com o modo "w".

Aqui temos este arquivo de texto:

Se executarmos este script:

f = open("data/names.txt", "w")
f.write("New Content")
f.close()

Este será o resultado:

Como pode ver, abrindo o arquivo no modo "w" e, depois, escrevendo, substituímos o conteúdo existente.

💡 Dica: o método write() retorna o número de caracteres escrito.

Se quisermos escrever várias linhas de uma vez, podemos usar o método writelines(), que leva uma lista de strings. Cada string representa uma linha a ser adicionada ao arquivo.

Aqui temos um exemplo. Este é o arquivo inicial:

Se executarmos este script:

f = open("data/names.txt", "a")
f.writelines(["\nline1", "\nline2", "\nline3"])
f.close()

As linhas serão adicionadas ao final do arquivo:

Abrir o arquivo para diversas operações

Agora que você sabe criar, ler e escrever em um arquivo, pode ser que você queira fazer mais que uma única ação no mesmo programa. Vamos ver o que acontece se tentarmos isso com os modos que aprendemos até agora:

Se você abrir um arquivo no modo "r" (read, ou ler) e, em seguida, tentar escrever nele:

f = open("data/names.txt")
f.write("New Content") # Tentativa de escrever
f.close()

Você receberá este erro:

Traceback (most recent call last):
  File "<path>", line 9, in <module>
    f.write("New Content")
io.UnsupportedOperation: not writable

Da mesma forma, se abrir um arquivo em modo "w" (write, ou escrever), e tentar ler o arquivo:

f = open("data/names.txt", "w")
print(f.readlines()) # Tentativa de ler
f.write("New Content")
f.close()

Receberá este erro:

Traceback (most recent call last):
  File "<path>", line 14, in <module>
    print(f.readlines())
io.UnsupportedOperation: not readable

O mesmo ocorrerá com o modo "a" (append, ou acrescentar).

Como podemos resolver isto? Para conseguirmos ler um arquivo e realizar outra operação dentro do mesmo programa, precisamos adicionar ao modo o símbolo  "+", desta forma:

f = open("data/names.txt", "w+") # Ler + Escrever

f = open("data/names.txt", "a+") # Ler + Acrescentar

f = open("data/names.txt", "r+") # Ler + Escrever

Útil, certo? Isso é o que você provavelmente utilizará nos seus programas, mas tenha certeza de incluir o modo para evitar possíveis bugs.

Às vezes, os arquivos são mais extensos do que o necessário. Vamos ver como excluir arquivos usando Python.

🔹 Como excluir arquivos

Para excluir arquivo utilizando Python, é preciso importar um módulo chamado os, que contém as funções para interagir com o seu sistema operacional.

💡 Dica: um módulo é um arquivo Python com variáveis, funções e classes relacionadas.

Em particular, você precisa da função remove(). Essa função recebe o caminho do arquivo como argumento e o exclui automaticamente.

Vejamos um exemplo. Queremos remover o arquivo chamado sample_file.txt.

Para fazer isso, escrevemos este código:

import os
os.remove("sample_file.txt")

• A primeira linha: import os é o "argumento de importação". Este argumento é escrito na parte superior do seu arquivo e dá acesso às funções definidas no módulo os.
• A segunda linha: os.remove("sample_file.txt") remove o arquivo especificado.

💡 Dica: você pode usar um caminho absoluto ou um caminho relativo.

Agora que você sabe excluir arquivos, vamos ver uma ferramenta interessante... os gerenciadores de contexto!

🔸 Conheça os gerenciadores de contexto

Gerenciadores de contexto (context managers, em inglês) são construções do Python que tornam a sua vida mais fácil. Usando-os, você não precisa se lembrar de fechar um arquivo no final do seu programa e tem acesso ao arquivo em uma parte específica do programa que você escolher.

Sintaxe

Este é um exemplo de uso de um gerenciador de contexto para se trabalhar com arquivos:

💡 Dica: o corpo do gerenciador de contexto deve ser indentado, assim como indentamos um laço, funções e classes. Se o código não for indentado, não será considerado parte do gerenciador de contexto.

Quando o corpo do gerenciador de contexto é finalizado, ele fecha o arquivo automaticamente.

with open("<path>", "<mode>") as <var>:
    # Trabalhando com o arquivo...

# O arquivo é fechado aqui!

Exemplo

Aqui temos um exemplo:

with open("data/names.txt", "r+") as f:
    print(f.readlines()) 

Este gerenciador de contexto abre o arquivo names.txt para a operação de leitura/escrita e designa o objeto de arquivo para uma variável f. Essa variável é usada no corpo do gerenciador de contexto para referenciar para o objeto de arquivo.

Tentando ler novamente

Depois do corpo ser feito, o arquivo é automaticamente fechado, então não pode ser lido sem abrir novamente. Mas espere! Nós temos uma linha que tenta ler novamente, como mostrado abaixo:

with open("data/names.txt", "r+") as f:
    print(f.readlines())

print(f.readlines()) # Tentando ler o arquivo novamente, fora do gerenciador de contexto

Vamos ver o que acontece:

Traceback (most recent call last):
  File "<path>", line 21, in <module>
    print(f.readlines())
ValueError: I/O operation on closed file.

Esse erro é lançado, pois estamos tentando ler um arquivo fechado. Incrível, certo? O gerenciador de contexto faz todo o trabalho pesado para nós, sendo legível e conciso.

🔹 Como lidar com exceções ao trabalharmos com arquivos

Quando você está trabalhando com arquivos, podem ocorrer erros. Às vezes, você não possui as permissões necessárias para modificar ou acessar um arquivo, ou o arquivo não existe.
Como programador, você precisa prever essas circunstâncias e lidar com elas no seu programa para evitar possíveis bugs e problemas que possam afetar a experiência do usuário.
Vamos ver as exceções mais comuns (erros de execução) que você pode encontrar enquanto trabalha com seus arquivos:

FileNotFoundError

De acordo com a documentação do Python, essa exceção:

Surge quando um arquivo ou diretório é solicitado, mas não existe.

Por exemplo, se o arquivo que você está tentando abrir não existir no seu diretório atual:

f = open("names.txt")

Você verá este erro:

Traceback (most recent call last):
  File "<path>", line 8, in <module>
    f = open("names.txt")
FileNotFoundError: [Errno 2] No such file or directory: 'names.txt'

Vamos analisar esse erro, linha por linha:

• File "<path>", line 8, in <module>. Essa linha informa a você que houve um erro quando o código no arquivo localizado em <path> estava em execução. Especificamente, quando a line 8 foi executada no <module>.
• f = open("names.txt"). Essa é a linha que causou o erro.
• FileNotFoundError: [Errno 2] No such file or directory: 'names.txt' . Essa linha diz que uma exceção FileNotFoundError aconteceu, pois o arquivo ou diretório names.txt não existe.

💡 Dica: o Python é muito descritivo com mensagens de erro, certo? Essa é uma grande vantagem durante o processo de depuração.

PermissionError

Essa é outra exceção comum ao se trabalhar com arquivos. De acordo com a documentação do Python, essa exceção:

Surge ao se tentar realizar uma operação sem os direitos de acesso adequados - por exemplo, permissões do sistema de arquivos.

Essa exceção ocorre quando tentamos ler ou modificar um arquivo que não possuímos permissão de acesso. Se você tentar, verá este erro:

Traceback (most recent call last):
  File "<path>", line 8, in <module>
    f = open("<file_path>")
PermissionError: [Errno 13] Permission denied: 'data'

IsADirectoryError

De acordo com a documentação do Python, essa exceção:

Surge quando uma operação de arquivo é solicitada em um diretório.

Essa exceção, em particular, ocorre quando você tenta abrir um arquivo ou trabalho em um diretório ao invés de um arquivo. Assim, tenha cuidado ao passar um caminho como um argumento.

Como lidar com exceções

Para lidar com exceções, você pode utilizar a declaração try/except. Com essas declarações, você pode "dizer" ao seu programa o que fazer caso aconteça algo inesperado.

Esta é a sintaxe básica:

try:
	# Tente executar esse código
except <type_of_exception>:
	# Se uma exceção desse tipo ocorrer, pare o processo e salte para este bloco
    

Aqui, você pode ver um exemplo de FileNotFoundError:

try:
    f = open("names.txt")
except FileNotFoundError:
    print("O arquivo não existe")

Basicamente, isso significa:

• Tentar abrir o arquivo names.txt.
• Se for lançado um erro do tipo FileNotFoundError, não parar o programa! Simplesmente imprimir uma declaração descritiva para o usuário.

💡 Dica: você pode escolher como lidar com a situação escrevendo um código apropriado no bloco except. Talvez você possa criar um arquivo, caso ele ainda não exista.

Para fechar o arquivo automaticamente após a tarefa (independentemente de uma exceção ter sido levantada ou não pelo bloco try), você pode adicionar o bloco finally.

try:
	# Tente executar esse código
except <exception>:
	# Se uma exceção desse tipo ocorrer, pare o processo imediatamente e salte para este bloco
finally: 
	# Faça isso após executar o código, mesmo que ocorra uma exceção

Este é um exemplo:

try:
    f = open("names.txt")
except FileNotFoundError:
    print("O arquivo não existe")
finally:
    f.close()

Existem várias maneiras de se customizar os argumentos try/except/finally. Você pode até adicionar um bloco else para rodar um bloco de código se nenhuma exceção tiver sido levantada no bloco try.

💡 Dica: para aprender mais sobre tratamento de exceções em Python, talvez você goste de ler meu artigo: "How to Handle Exceptions in Python: A Detailed Visual Introduction" (em inglês).

🔸 Em resumo

• Você pode criar, ler, escrever em arquivos e excluí-los usando Python.
• Objetos de arquivo têm seu próprio conjunto de métodos que você pode usar para trabalhar com eles em seu programa.
• Os gerenciadores de contexto ajudam você a trabalhar com arquivos e gerenciá-los, fechando-os automaticamente quando uma tarefa é concluída.
• O tratamento de exceções é fundamental em Python. Exceções comuns quando você está trabalhando com arquivos incluem FileNotFoundError, PermissionError e IsADirectoryError. Elas podem ser tratadas usando try/except/finally.

Espero que você tenha gostado do artigo e que ele tenha sido útil. Agora, você pode trabalhar com arquivos em seus projetos com Python.

Confira os cursos da autora. Siga a autora no Twitter. ⭐️

Os eventos de teclado em Javascript ajudam a capturar interações do usuário com o teclado.

Da mesma forma que em muitos outros eventos do Javascript, a interface do KeyboardEvent nos fornece todas as propriedades e métodos necessários para lidar com cada tecla pressionada pelo usuário.

Existem diversos artigos sobre como este método funciona e sobre como utilizá-lo. Ao mesmo tempo, a w3.org (texto em inglês) continua a atualizar as especificações, adicionando novas propriedades e removendo algumas existentes, marcando alguns códigos como legado.

Por conta disso, é essencial que os desenvolvedores da web tenham o hábito da aprendizagem contínua com relação à interface KeyboardEvent para saberem o que exatamente eles devem utilizar e o que não é mais relevante.

Neste artigo, vamos aprender sobre:

• A interface KeyboardEvent.
• Os tipos de eventos de teclado que devemos ter em mente.
• Os tipos de eventos de teclado que talvez nunca utilizaremos.
• As propriedades que são necessárias na prática e como diferentes navegadores lidam com elas.
• O que já não é mais usado e o que ainda está em uso.
• Um exercício prático para tentarmos fazer as coisas à medida que aprendemos.
• Por fim, a lista atual de códigos de teclas para referência e uso no futuro.

Espero que você aproveite.

A interface KeyboardEvent e os tipos de eventos

A interface de tecla (KeyboardEvent) fornece informações usando as constantes definidas, propriedades e um método único (neste momento). Ela é uma extensão da interface UIEvent, a qual, por sua vez, é uma extensão da interface Event.

Existem três tipos de eventos, primordialmente: keydown, keypress e keyup. Podemos obter informações contextual destes eventos a partir das propriedades e métodos da interface KeyboardEvent.

Você pode adicionar cada um destes eventos a um elemento HTML ou a um objeto document utilizando o método addEventListener. Segue um exemplo de listener do evento keydown onde o id é 'digite-aqui':

let elem = document.getElementById('digite-aqui');

elem.addEventListener("keydown", function (event) {
    // O evento do parâmetro é do tipo KeyboardEvent
  	addRow(event);
});

Como alternativa, você pode os métodos de tratamento, como onKeydown(event), onKeyup(event), onKeypress(event), com o elemento para tratar dos eventos de teclado. Abaixo, vemos um exemplo de como lidar com um evento de keyup em um elemento de input:

<input type="text" id="digite-aqui" onkeyup="façaAlgo(event)">

Se você imprimir no console do navegador o objeto event, verá todas as propriedades e métodos junto com aqueles que ele herda das interfaces.

Experimente esse evento interativo no exercício

Antes de avançarmos, que tal um exercício para explorarmos todos os eventos de teclado, suas propriedades, características e assim por diante? Acredito que será ótimo utilizá-lo juntamente com este artigo e posteriormente.

Você precisa apenas colocar seu cursor em qualquer lugar do aplicativo incorporado abaixo e pressionar qualquer tecla para ver a informação contextual sobre ela.

Você também pode filtrar os eventos, desmarcando-os nas caixas de seleções que estão na parte superior. Experimente:

Se tiver quaisquer problemas acessando o exercício acima, pode acessar a ferramenta diretamente por este link: https://keyevents.netlify.app/

Você também pode encontrar o código-fonte da demonstração aqui: https://github.com/atapas/js-keyevents-demo

keydown, keypress, keyup – qual você deve usar?

O eventos de tecla são:

• keydown: dispara quando qualquer tecla é pressionada.
• keypress: dispara quando uma tecla que retorna um valor de caractere é pressionada. Por exemplo, se você pressionar a tela a, este evento vai disparar a letra a, que retorna o valor 97. Por outro lado, este evento não vai funcionar quando pressionar a tecla shift pois ela não retorna um valor.
• keyup: dispara quando qualquer tecla é liberada.

Se todos os eventos estão vinculados a um elemento do DOM, a ordem de funcionamento seria:

1. Primeiro,  keydown
2. Depois, pressione (com a condição de estado acima)
3. Por último, keyup

Entre estes eventos, o mais utilizado é (ou deveria ser) keydown, pois:

• O evento keydown tem uma cobertura máxima de contextualização de informação. O evento keypress funciona apenas com um subconjunto de teclas. Você não consegue capturar Alt, Ctrl, Shift, Meta e outras eventos de teclas similares com keypress. Isto também significa que não podemos disparar eventos com a combinação de teclas como Ctrl+Z, Shift+Tab e assim por diante.
• Além disso, o evento keypress já não deve mais ser utilizado. Isto é o suficiente para evitá-lo.
• Embora os eventos keydown e keyup tratem de todas as teclas e muitos navegadores oferecem suporte a eles, existem algumas diferenças que deixam o keydown a frente de keyup. O evento keydown dispara antes do navegador processar a tecla. Se você cancelar o evento keydown (digo, utilizando event.preventDefault()) a ação do navegador também será cancelada. No caso do evento keyup, a ação dos navegadores não será cancelada mesmo que você cancele o evento.

No exemplo abaixo, utilizamos  event.preventDefault() ao disparar os eventos keydown e keyup. A ação do navegador escreve o caractere dentro da caixa de texto isso não vai acontecer no caso do evento keydown, mas acontecerá no evento de keyup.

Depois desta explicação, vemos que o evento keydown é claramente o vencedor e deve ser tornar o tipo de evento mais popular (mais usado).

Como utilizar as propriedades dos eventos de tecla pressionada na prática

Esta é a pergunta mais importante! A resposta mais curta é: depende. Mas de quê? Depende de:

• Qual o nível de suporte do navegador para a sua aplicação
• O quanto o código da sua aplicação é antigo e o quanto você está disposto a refatorar?

Antes de chegarmos nisso, contudo,  vamos ver um pouco sobre propriedades e métodos úteis da interface keyboardEvent.

As últimas três propriedades foram descontinuadas e deve-se utilizar a propriedade key no lugar delas. A propriedade key possui um suporte mais amplo dos navegadores (texto em inglês).

Encontramos suporte nos seguintes navegadores:

• Microsoft Edge: Versão >= 79
• Firefox: Versão >= 29
• Google Chrome: Versão >= 51
• Safari: Versão >= 10.1

Então, enquanto você não estiver utilizando nenhuma versão antiga de navegadores, a propriedade event.key deve ser o suficiente para identificar uma tecla. Caso você tenha que fornecer suporte a navegadores antigos, a melhor saída seria a propriedade event.which.

window.addEventListener("keydown", function (event) {
  
  if (event.key !== undefined) {
    // Handle the event with KeyboardEvent.key
  } else if (event.which !== undefined) {
    // Handle the event with KeyboardEvent.which
  }
});

Se o seu código possui propriedades descontinuadas e se você tiver a oportunidade de refatorar este código, sempre será melhor a fazer.

Teclas modificadoras

As teclas modificadoras são as teclas especiais do seu teclado que mudam o comportamento padrão de outras teclas. Control, Shift e Alt são algumas das teclas modificadoras. Quando uma tecla modificadora é combinada com outra tecla, você pode esperar que uma ação diferente ocorra.

Por exemplo, se você apertar a tecla z, deve retornar a letra e o código dela. Se você combinar com o modificador Control e pressionar Control+z, provavelmente terá a ação de desfazer a operação. Vamos ver isto com mais alguns exemplos na próxima seção.

As propriedades, event.altKey, event.ctrlKey, event.shiftKey e outras ajudam a  identificar qual modificador foi pressionado.

Combinação de teclas

Podemos combinar diversas teclas e realizar ações baseadas na combinação delas. O código abaixo mostra como combinar Control e z para definir uma ação:

document
  .getElementById("to_focus")
  .addEventListener("keydown", function(event) {
    if (event.ctrlKey && event.key === "z") {
      // Realiza uma ação, talvez até a operação de 'desfazer'
    }
});

Segue outro exemplo de combinação de teclas. Experimente:

Lista Completa de valores de eventos de teclado

A tabela abaixo mostra a lista de teclas com os valores de event.which, event.key e event.code.

Observe:

• event.which foi descontinuado (ou desatualizado)
• O valor de event.code é o mesmo para letras minúsculas e maiúsculas. No entanto, o valor de event.key representa a letra de fato.
• O valor de event.which é diferente no Firefox(FF) e em outros navegadores para as teclas: equal(=), semicolon(;), edash/minus(-)

E quanto ao teclado virtual?

E quanto ao teclado virtual que utilizamos em nosso celular ou tablet ou qualquer outro dispositivo?

As especificações dizem que o teclado virtual possui o mesmo layout e funcionalidade que um teclado padrão. Assim, ele deverá retornar um atributo adequado. Caso contrário, não retornará o valor correto.

Em resumo

Para resumir:

• Você pode utilizar o KeyboardEvent para capturar as interações do usuário utilizando um teclado.
• Existem três eventos primários: keydown, keypress, ekeyup.
• Devemos utilizar o tipo de evento keydown quando possível, pois ele é o suficiente para a maioria dos casos de uso do usuário.
• O tipo de evento keypress foi descontinuado.
• A propriedade event.which foi descontinuada. Utilize event.key sempre que possível.
• Se tiver que fornecer suporte para um navegador mais antigo, utilize o fallback apropriado para detectar a tecla.
• Podemos combinar várias teclas para realizar operações.
• O teclado virtual possui suporte para estes eventos desde que o layout e as funções sejam similares às de um teclado padrão.

Isto é tudo por agora. Obrigado por ler até aqui! Entre em contato com o autor. Você pode entrar em contato com ele (@tapasadhikary) e fazer comentários ou fique à vontade para segui-lo no Twitter .

A instrução GROUP BY é poderosa, mas, às vezes, pode causar confusão.

Mesmo após oito anos, sempre que utilizo o GROUP BY, eu tenho de parar e pensar o que exatamente está ocorrendo.

Neste artigo, nós vamos ver como criar uma instrução GROUP BY, o que ela faz em sua consulta e como você pode utilizá-la para gerar agregações e coletar insights sobre os seus dados.

O que vamos fazer:

• Configurar o banco de dados.
• Configurar os dados (criar vendas).
• Como funciona um GROUP BY?.
• Escrever instruções GROUP BY .
• Agregações (COUNT, SUM, AVG).
• Trabalhar com diversos grupos.
• Utilizar funções dentro do GROUP BY.
• Filtrar grupos com HAVING.
• Agregar com agrupamentos implícitos.

Configurar o banco de dados

Antes de escrever nossas consultas, precisamos configurar nosso banco de dados.

Para os exemplos, vamos utilizar o PostgreSQL, mas as consultas e conceitos mostrados serão de fácil compreensão para qualquer sistema de banco de dados moderno (como o MySQL, o SQL Server e assim por diante).

Para trabalhar com nosso banco de dados PostgreSQL, podemos utilizar psql — o comando de linha interativo do PostgreSQL. Se você possui outro serviço de banco de dados de sua preferência, não há problema de trabalhar nele também.

Para começar, vamos criar nossa tabela de dados. Com o PostgreSQL instalado, podemos usar o comando  createdb <database-name> no console para criar um novo banco de dados. Chamei o meu de fcc:

$ createdb fcc

Agora, vamos iniciar o nosso console interativo utilizando o comando psql, e nos conectar ao banco de dados que acabamos de fazer \c <nome-do-banco>:

$ psql
psql (11.5)
Type "help" for help.

john=# \c fcc
You are now connected to database "fcc" as user "john".
fcc=#

Observação: eu limpei a saída do psql nestes exemplos para facilitar a leitura, então não se preocupe se as saídas mostradas aqui não sejam exatamente iguais ao que você verá no seu terminal.

Eu encorajo você a acompanhar estes exemplos e a fazer as consultas por conta própria. Você vai aprender e lembrar bem mais trabalhando nos exemplos ao invés de apenas lê-los.

Configurar os dados (criar vendas).

Para os nossos exemplos, vamos utilizar um banco que guarde o histórico de vendas de vários produtos através de diferentes localizações.

Iremos chamar esta tabela de vendas. Ela será uma representação simples de uma loja: nome do local, nome do produto, preço e a data em que o produto foi vendido.

Se fossemos construir este banco em uma aplicação real, configuraríamos as chaves estrangeiras para outras tabelas (como local ou produtos). No entanto, para ilustrar os conceitos de GROUP BY, vamos utilizar apenas colunas do tipo TEXT.

Vamos criar a tabela e inserir alguns dados de vendas:

CREATE TABLE vendas(
  local TEXT,
  produto TEXT,
  preco DECIMAL,
  vendido_em TIMESTAMP
);

INSERT INTO vendas(local, produto, preco, vendido_em) VALUES
('Central', 'Café', 2, NOW()),
('Central', 'Café', 2, NOW() - INTERVAL '1 hora'),
('Centro', 'Biscoito', 3, NOW() - INTERVAL '2 hora'),
('Centro', 'Café', 2, NOW() - INTERVAL '1 dia'),
('Central', 'Biscoito', 2, NOW() - INTERVAL '2 dias'),
('Rua 1', 'Biscoito', 3, NOW() - INTERVAL '2 dias' - INTERVAL '1 hora'),
('Rua 1', 'Café', 2, NOW() - INTERVAL '3 dias'),
('Central', 'Biscoito', 3, NOW() - INTERVAL '3 dias' - INTERVAL '1 hora');

Temos 3 localizações: Central, Centro e Rua 1.

Nós temos dois produtos, Café e Biscoito, e inserimos diferentes valores em vendido_em para representar os itens sendo vendidos em dias e horas diferentes.

Existem algumas vendas na data de hoje, algumas na data de ontem, e algumas em dias anteriores a ontem.

Como funciona um GROUP BY?

Para ilustrar como as instruções GROUP BY funcionam, vamos primeiro falar através de um exemplo.

Imagine que temos um quarto cheio de pessoas que nasceram em países diferentes.

Se quiséssemos descobrir a média da altura das pessoas no quarto por país, primeiro, pediríamos para as pessoas se separarem em grupos baseados no país em que nasceram.

Uma vez separados em seus devidos grupos, poderíamos calcular a média de altura de qualquer um desses grupos.

É assim que funcionam as instruções GROUP BY. Primeiro, definimos como queremos agrupar as informações – então, podemos realizar cálculos ou agregações nos grupos.

Diversos grupos

Podemos agrupar os dados em quantos grupos ou subgrupos quisermos.

Por exemplo, depois de pedirmos para as pessoas se separarem baseados no seu país de nascimento, podemos dizer para cada um desses grupos que se separem em grupos baseados na cor de seus olhos.

Ao fazer isso, temos grupos de pessoas baseados na combinação do seu país de nascimento e na cor de seus olhos.

Agora, podemos encontrar a média da altura dentro de cada um desses pequenos grupos. Teremos um resultado mais específico: média de altura por país e cor dos olhos.

As instruções GROUP BY são frequentemente usadas para situações onde você utiliza a frase por alguma coisa ou para cada alguma coisa:

• Média de altura por país
• Número total de pessoas para cada combinação de cor de olhos e cor de cabelo
• Total de vendas por produto

Escrever instruções GROUP BY

Uma instrução GROUP BY é muito fácil de escrever — apenas utilizamos a palavra chave GROUP BY e então especificamos os campos que queremos agrupar:

SELECT ...
FROM vendas
GROUP BY local;

Esta consulta simples agrupa nossos dados de  vendas pela coluna do local.

Fizemos o agrupamento — mas e agora? O que colocamos em nosso SELECT?

A coisa mais clara para selecionar é o nosso local— nós agrupamos para que ao menos vejamos o nome dos grupos que fizemos:

SELECT location
FROM sales
GROUP BY location;

O resultado é as nossas três localizações:

  local
------------
 Rua 1
 Central
 Centro
(3 rows)

Se olharmos para a tabela bruta de dados  (SELECT * FROM vendas;), veremos que temos 4 linhas com o local Central, duas linhas com o local Centro, e duas linhas com o local Rua 1:

 produto 	|    local 	| preco |          vendido_em
---------+---------+------------+-------+----------------------------
 Cafe    	| Central    	|     2 | 2020-09-01 09:42:33.085995
 Cafe  	 	| Central    	|     2 | 2020-09-01 08:42:33.085995
 Biscoito	| Centro     	|     3 | 2020-09-01 07:42:33.085995
 Cafe  	 	| Centro     	|     2 | 2020-08-31 09:42:33.085995
 Biscoito	| Central    	|     2 | 2020-08-30 09:42:33.085995
 Biscoito	| Rua 1   	|     3 | 2020-08-30 08:42:33.085995
 Cafe  	 	| Rua 1		|     2 | 2020-08-29 09:42:33.085995
 Biscoito	| Central    	|     3 | 2020-08-29 08:42:33.085995
(8 rows)

Agrupando na coluna local, nosso banco de dados pega essas linhas de input e identifica locais únicos dentre eles — estes locais únicos servem como nosso "grupo".

E quanto às outras colunas da nossa tabela?

Se tentarmos selecionar a coluna produto que não agrupamos...

SELECT
  local,
  produto
FROM vendas
GROUP BY local;

...receberemos o seguinte erro:

ERROR:  column "vendas.produto" must appear in the GROUP BY clause or be used in an aggregate function

O problema aqui é que pegamos oito linhas e as esprememos ou as transformamos em três.

Não podemos apenas retornar o resto das colunas como normalmente fazíamos — nós possuíamos oito linhas, e agora temos três.

O que faremos com as cincos linhas restantes de dados? Quais das oito linhas de dados devem ser mostradas nestas três linhas de locais distintos?

Não há uma resposta clara e definitiva aqui.

Para utilizar o resto da nossa tabela de dados, nós também temos de analisar os dados do restante das colunas dentro dos nossos três grupos de local.

Isto significa que temos de agregar ou realizar um cálculo para produzir um tipo de resumo das informações sobre os dados restantes.

Agregações (COUNT, SUM, AVG)

Uma vez que definimos como agrupar nossos dados, podemos realizar agregações com as colunas restantes.

São coisas como contar o número de linhas por grupo, somar um valor em específico através do grupo, ou calcular a média das informações dentro do grupo.

Para começar, vamos encontrar o número de vendas por local.

Como cada gravação em nossa tabela de vendas é uma venda, o número de vendas por local seria o número de linhas dentro de cada local do grupo.

Para fazer isto, utilizaremos a função de agregação COUNT() para contar o número de linhas de cada grupo:

SELECT
  local,
  COUNT(*) AS numero_de_vendas
FROM vendas
GROUP BY local;

Nós usamos COUNT(*), que conta todas as linhas de input por grupo (COUNT() também funciona com expressões, mas possui um comportamento levemente diferente).

Abaixo, vemos como o banco de dados executa esta consulta:

• FROM vendas — Primeiro, retornamos todos os dados da tabela vendas
• GROUP BY local — Em seguida, determinamos os grupos únicos de local
• SELECT ... — Finalmente, selecionamos o nome do local e contamos o número de linhas daquele grupo

Nomearemos a contagem de linhas usando AS numero_de_vendas para fazer uma saída de dados mais legível. Se parecerá com o seguinte:

   local    | numero_de_vendas
------------+-----------------
 Rua 1      |       2
 Central    |       4
 Centro     |       2
(3 rows)

O local Rua 1 possui duas vendas, Central possui quatro, e Centro possui duas.

Aqui, podemos ver como pegamos as demais colunas de dados das nossas oito linhas independentes e as colocamos em um resumo das informações para cada local: o número de vendas.

De um jeito similar, ao invés de contar o número de linha em um grupo, podemos somar as informações dentro do grupo — como o dinheiro total ganho nesses locais.

Para fazer isto, utilizamos a função SUM() :

SELECT
  local,
  SUM(preco) AS ganho_total
FROM vendas
GROUP BY local;

No lugar de contar o número de linhas em cada grupo, somamos o total de ganhos de cada venda. Isto mostra o ganho total por local:

  local	    | ganho_total
------------+---------------
 Rua 1      |             5
 Central    |             9
 Centro     |             5
(3 rows)

Média (AVG)

Encontrar a média do valor de vendas por local significa apenas que trocaremos a função SUM() para a função AVG():

SELECT
  local,
  AVG(preco) AS media_de_ganho
FROM vendas
GROUP BY local;

Trabalhar com diversos grupos

Até o momento, temos trabalho apenas com um grupo: local.

E se quisermos subdividir o grupo ainda mais?

É semelhante ao cenário "País de nascimento e cor dos olhos" com o qual começamos. E se quiséssemos encontrar o número de vendas por produto e por local?

Para fazermos tudo isso, precisamos adicionar uma segunda condição de agregação ao declararmos o GROUP BY :

SELECT ...
FROM vendas
GROUP BY local, produto;

Ao adicionarmos uma segunda coluna GROUP BY, nós subdividimos ainda mais o nosso grupo de locais em grupo de locais por produto.

Agora que estamos agrupando também pela coluna produto, podemos retornar ao nosso SELECT (adicionarei a instrução ORDER BY nestas consultas para facilitar a leitura dos dados de saída.)

SELECT
  local,
  produto
FROM vendas
GROUP BY local, produto
ORDER BY local, produto;

Olhando para o resultado de nosso novo agrupamento, podemos ver nossas combinações únicas de local/produto:

  local     | produto
------------+---------
 Rua 1      | Biscoito
 Rua 1      | Café
 Centro     | Biscoito
 Centro     | Café
 Central    | Biscoito
 Central    | Café
(6 rows)

Agora que temos nossos grupos, o que queremos fazer com o resto das nossas colunas de dados?

Bem, podemos encontrar o número de vendas por produto e por local utilizando a mesma função de agregação utilizada antes:

SELECT
  local,
  produto,
  COUNT(*) AS numero_de_vendas
FROM vendas
GROUP BY local, produto
ORDER BY local, produto;

  local  | produto    | numero_de_vendas
------------+---------+-----------------
 Rua 1   | Biscoito   |               1
 Rua 1   | Café       |               1
 Centro  | Biscoito   |               1
 Centro  | Café       |               1
 Central | Biscoito   |               2
 Central | Café       |               2
(6 rows)

Como exercício para o leitor™: encontre o total de ganhos (soma) de cada produto por local.

Utilizar funções dentro do GROUP BY

Agora, tentaremos achar o número total de vendas por dia.

Se seguirmos padrões similares como fizemos com os nossos locais e agrupamos pela nossa coluna vendido_em...

SELECT
  vendido_em,
  COUNT(*) AS vendas_por_dia
FROM vendas
GROUP BY vendido_em
ORDER BY vendido_em;

...esperamos que o resultado seja ter cada grupo em um único dia— no entanto, temos isso:

          vendido_em        | vendas_por_dia
----------------------------+---------------
 2020-08-29 08:42:33.085995 |             1
 2020-08-29 09:42:33.085995 |             1
 2020-08-30 08:42:33.085995 |             1
 2020-08-30 09:42:33.085995 |             1
 2020-08-31 09:42:33.085995 |             1
 2020-09-01 07:42:33.085995 |             1
 2020-09-01 08:42:33.085995 |             1
 2020-09-01 09:42:33.085995 |             1
(8 rows)

Parece que nossos dados não estão agrupados — temos cada linha individualmente.

Nossos dados, no entanto, estão agrupados! O problema é que cada linha de vendido_em possui um valor único — então, nossas linhas são seus próprios grupos!

O GROUP BY está funcionando corretamente, mas não é a saída que queremos.

O que ocasiona esta situação é a informação extra do carimbo de data e hora.

Cada um destes carimbos se diferenciam por horas, minutos ou segundos — assim, eles são colocados em seu devido lugar em seu próprio grupo.

Precisamos converter cada um dos valores de data e hora para apenas data:

• 2020-09-01 08:42:33.085995 => 2020-09-01
• 2020-09-01 09:42:33.085995 => 2020-09-01

Convertido para uma data, todos os carimbos do mesmo dia retornarão apenas a referência do valor da data em que foi efetuada a compra—e será colocado dentro do mesmo grupo.

Para fazermos isso, converteremos os dados de vendido_em para data:

SELECT
  vendido_em::DATE AS date,
  COUNT(*) AS vendas_por_dia
FROM vendas
GROUP BY vendido_em::DATE
ORDER BY vendido_em::DATE;

Em nossa instrução GROUP BY, utilizamos ::DATE para cortar uma parte do carimbo de data/hora para apenas dia. Isto corta efetivamente as horas/minutos/segundos do carimbo e retorna apenas o dia.

No nosso SELECT, retornamos a mesma expressão e damos a ela um nome para deixar o resultado mais bonito.

Pela mesma razão, não podemos retornar o produto sem agrupar ou realizar algum tipo de agrupamento. O banco de dados não deixará retornar apenas o vendido_em — tudo que está no SELECT deve estar dentro do GROUP BY ou em algum tipo de agregação nos grupos resultantes.

O resultado de vendas por dia que originalmente queríamos ver:

    date    | vendas_por_dia
------------+---------------
 2020-08-29 |             2
 2020-08-30 |             2
 2020-08-31 |             1
 2020-09-01 |             3
(4 rows)

Filtrar grupos com HAVING

Dando continuidade, vamos verificar como filtrar nossas linhas agrupadas.

Para fazer isso, vamos tentar encontrar dias onde houve mais de uma venda.

Sem agrupar, normalmente filtraríamos nossas linhas utilizando a instrução. Por exemplo:

SELECT *
FROM vendas
WHERE produto = 'Café';

Com nossos grupos, utilizaremos algo parecido com isso para filtrá-los com base na quantidade de linhas...

SELECT
  vendido_em::DATE AS date,
  COUNT(*) AS vendas_por_dia
FROM vendas
WHERE COUNT(*) > 1      -- filtrar os grupos?
GROUP BY vendido_em::DATE;

Infelizmente, isso não funciona e recebemos este erro:

ERROR:  aggregate functions are not allowed in WHERE

Funções agregadas não são permitidas dentro da instrução WHERE, pois ela é avaliada antes da instrução GROUP BY—não há nenhum grupo para realizar os cálculos.

Existe, contudo, um tipo de instrução que nos permite filtrar e realizar agregações. Ela é avaliada depois da instrução GROUP BY: a instrução HAVING.

A instrução HAVING é como a instrução WHERE para os seus grupos.

Para encontrar os dias em que houve mais de uma venda, adicionamos a instrução HAVING que verificará a quantidade de linhas dentro do grupo:

SELECT
  vendido_em::DATE AS date,
  COUNT(*) AS vendas_por_dia
FROM sales
GROUP BY vendido_em::DATE
HAVING COUNT(*) > 1;

A instrução HAVING filtra qualquer linha onde a contagem de linhas deste grupo não é maior que um. Vemos isso no nosso resultado:

    date    | vendas_por_dia
------------+---------------
 2020-09-01 |             3
 2020-08-29 |             2
 2020-08-30 |             2
(3 rows)

Apenas para deixar completo, segue em ordem a execução de todas as partes de uma instrução SQL:

• FROM — Retorna todas as linhas da tabela FROM
• JOIN — Realiza quaisquer junções
• WHERE — Filtra linhas
• GROUP BY — Forma grupos
• HAVING — Filtra grupos
• SELECT — Seleciona os dados a serem retornados
• ORDER BY — Ordena a saída de linhas
• LIMIT — Retorna uma certa quantidade de linhas

Agregações com agrupamentos implícitos

O último tópico que veremos é a agregação que pode ser realizada sem o GROUP BY— ou, melhor dizendo, que possui um agrupamento implícito.

Estas agregações são úteis em cenários em que você quer encontrar um agrupamento específico dentro de uma tabela — como o total de ganhos ou o maior ou menor valor da coluna.

Por exemplo, podemos encontrar o total de ganhos de todos os locais selecionando a soma da tabela inteira:

SELECT SUM(preco)
FROM vendas;

 sum
-----
  19
(1 row)

Até o momento fizemos $19 de vendas em todos os locais (vivaaaaa!).

Outra coisa útil que podemos consultar é o primeiro ou o último valor de algo.

Por exemplo, qual a data da nossa primeira venda?

Para encontrá-la, basta utilizarmos a função  MIN():

SELECT MIN(vendido_em)::DATE AS primeira_venda
FROM vendas;

 primeira_venda
------------
 2020-08-29
(1 row)

(Para encontrar a data da última venda, bastar substituir MIN() por MAX().)

Como usar MIN / MAX

Embora essas consultas simples possam ser utilizadas em consultas independentes, elas são frequentemente parte de filtros de consultas maiores.

Por exemplo, vamos tentar encontrar o total de vendas do último dia em que tivemos vendas.

Um jeito de podermos escrever esta consulta seria o seguinte:

SELECT
  SUM(preco)
FROM vendas
WHERE vendido_em::DATE = '2020-09-01';

Esta consulta funciona, mas obviamente codificando a data de 2020-09-01.

09/01/2020 talvez seja o último dia em que tivemos uma venda, mas nem sempre será essa data. Precisamos de uma solução dinâmica.

Conseguimos isto através da combinação desta consulta com a função MAX() em uma subconsulta:

SELECT
  SUM(preco)
FROM venda
WHERE vendido_em::DATE = (
  SELECT MAX(vendido_em::DATE)
  FROM vendas
);

Na nossa instrução WHERE, encontramos a data mais antiga dentro da tabela utilizando a subconsulta: SELECT MAX(vendido_em::DATE) FROM vendas.

Então, utilizamos esta "data máxima" como um valor para filtrar a tabela, e somamos cada uma das vendas.

Agrupamento implícito

Chamamos de agrupamento implícito, pois, se tentarmos selecionar e agregar  o valor com uma coluna não agregada dessa forma...

SELECT
  SUM(preco),
  local
FROM vendas;

...teremos um erro familiar:

ERROR:  column "vendas.local" must appear in the GROUP BY clause or be used in an aggregate function

GROUP BY é uma ferramenta

Como muitos dos tópicos em desenvolvimento de software, GROUP BY é uma ferramenta.

Existem várias maneiras de escrever e reescrever estas consultas utilizando a combinação de  GROUP BY, funções agregadas ou outras ferramentas como  DISTINCT, ORDER BY e LIMIT.

Entender e trabalhar com o GROUP BY requer um pouco de pratica, mas ao aprender, você descobrirá um conjunto inteiramente novo de problemas que você poderá resolver!

Se gostou deste post, você pode seguir o autor deste artigo no Twitter, onde ele fala sobre banco de dados e sobre como ter sucesso na carreira como desenvolvedor.

Obrigado pela leitura!