Curso de Expressões Regulares (Regex) 🔍

Domine a arte de encontrar padrões em textos com precisão cirúrgica. Aprenda a ferramenta mais poderosa para processamento de dados, validação e automação.

O que você vai dominar

Foco: Entenda a lógica por trás dos metacaracteres e como aplicá-los em qualquer linguagem de programação ou ferramenta moderna.

🎯 Por que aprender Regex?

Velocidade Épica

Processe gigabytes de logs ou milhares de linhas de código em segundos.

Ver Metacaracteres
Validação Robusta

Garanta que e-mails, senhas e documentos sigam o formato correto sem falhas.

Validação de Dados
Limpeza e Extração

Transforme dados bagunçados em informações estruturadas automaticamente.

Limpeza de Dados
Independência de Linguagem

Aprenda uma vez e use em Python, JS, Java, PHP e ferramentas como VS Code.

Ver Ecossistema

📚 Estrutura do Curso (16 Aulas)

O curso é dividido em dois módulos estratégicos para levar você do zero ao nível avançado.

Módulo 1: A Lógica do Padrão (Aulas 01-08)

Construa sua base sólida com os fundamentos do Regex. * Aula 01 - Introdução e Conceitos 🧠 * Aula 02 - Estrutura Básica 🏗️ * Aula 03 - Metacaracteres Fundamentais 🔣 * Aula 04 - Conjuntos e Intervalos 📦 * Aula 05 - Quantificadores 🔢 * Aula 06 - Âncoras e Limites ⚓ * Aula 07 - Agrupamentos e Captura 🎯 * Aula 08 - Alternância (Or) 🔀

Módulo 2: Domínio e Aplicações (Aulas 09-16)

Aplique seu conhecimento em cenários reais e linguagens modernas. * Aula 09 - Modificadores (Flags) 🚩 * Aula 10 - Regex no Front-end (JS) 📜 * Aula 11 - Regex no Back-end (Python) 🐍 * Aula 12 - Validações de Campo ✅ * Aula 13 - Extração de Dados em Massa ⛏️ * Aula 14 - Transformação de Texto 🧹 * Aula 15 - Performance e Segredos 🚀 * Aula 16 - Projeto Final: Data Cleaner 🎓

Success

Pronto para o próximo nível? Clique no botão abaixo e descubra o poder do Regex!

Começar Curso

Plano de Ensino 🧭

Curso: Curso de Expressões Regulares (Regex)
Público-alvo: Estudantes de ADS, Ciência da Computação e Desenvolvedores de Software
Carga Horária: 20 Aulas (80 Horas Teórico-Práticas)

🎯 1. Objetivos do Curso

Compreender os fundamentos conceituais e arquiteturais de Curso de Expressões Regulares (Regex).
Aplicar padrões de projeto, sintaxe moderna e boas práticas da indústria.
Desenvolver soluções completas através de exercícios práticos e desafios de projeto.

📚 2. Cronograma de Aulas (Matriz de 20 Semanas)

Aula	Tema Central	Atividades e Entregas
01	Introdução ao Regex	Teoria, Prática Guiada, Quiz e Exercícios
02	Estrutura Básica de uma Expressão Regular ️	Teoria, Prática Guiada, Quiz e Exercícios
03	Metacaracteres Fundamentais	Teoria, Prática Guiada, Quiz e Exercícios
04	Conjuntos de Caracteres	Teoria, Prática Guiada, Quiz e Exercícios
05	Quantificadores	Teoria, Prática Guiada, Quiz e Exercícios
06	Âncoras	Teoria, Prática Guiada, Quiz e Exercícios
07	Agrupamentos e Captura	Teoria, Prática Guiada, Quiz e Exercícios
08	Alternância	Teoria, Prática Guiada, Quiz e Exercícios
09	Modificadores (Flags)	Teoria, Prática Guiada, Quiz e Exercícios
10	Regex na Prática com JavaScript	Teoria, Prática Guiada, Quiz e Exercícios
11	Regex com Python	Teoria, Prática Guiada, Quiz e Exercícios
12	Validação de Dados Reais	Teoria, Prática Guiada, Quiz e Exercícios
13	Extração de Dados ️	Teoria, Prática Guiada, Quiz e Exercícios
14	Limpeza e Transformação	Teoria, Prática Guiada, Quiz e Exercícios
15	Desempenho e Boas Práticas	Teoria, Prática Guiada, Quiz e Exercícios
16	Projeto Final: O Grande Desafio	Teoria, Prática Guiada, Quiz e Exercícios
17	Expressões Regulares Avançadas (Lookarounds e Backreferences)	Teoria, Prática Guiada, Quiz e Exercícios
18	Processamento de Dados Textuais com AWK e SED	Teoria, Prática Guiada, Quiz e Exercícios
19	Scripts Shell Robustos com Tratamento de Sinais	Teoria, Prática Guiada, Quiz e Exercícios
20	Projeto Capstone: Pipeline de ETL Textual Autônomo em Shell	Teoria, Prática Guiada, Quiz e Exercícios

🧠 3. Metodologia de Ensino

Teoria Fundamentada: Aulas com conceitos detalhados, diagramas arquiteturais e sintaxe de referência.
Ciclo Teoria ⇄ Prática: Cada aula conta com Quiz Interativo (10 questões) para validação imediata, Lista de Exercícios Sanfonados (com Gabarito Explicado) e Desafio de Projeto Prático.
Laboratório Contínuo: Ambientes configurados passo a passo na seção de Setups da plataforma.

💼 4. Competências e Perfil Desenvolvido

Dominar as ferramentas e fluxos de desenvolvimento de Curso de Expressões Regulares (Regex).
Resolver problemas técnicos de alta complexidade com código limpo e performático.
Construir portfólio prático com 20 projetos aplicados.

📊 5. Critérios de Avaliação

20 Listas de Exercícios: Resolução individual dividida em Básico, Intermediário e Desafio.
20 Quizzes Interativos: Validação formativa com feedback imediato via JavaScript.
20 Desafios de Projetos: Aplicações práticas consolidando o aprendizado de cada unidade.

Aulas

Aulas do Curso

Bem-vindo à seção de aulas! Aqui você encontra todo o conteúdo do curso organizado em 5 módulos estruturados.

📚 Módulos do Curso

Módulo 1: Fundamentos & Bases ---
Módulo 2: Arquitetura & Conceitos Essenciais ---
Módulo 3: Engenharia & Aplicação Prática ---
Módulo 4: Software, Ferramentas & Padrões ---
Módulo 5: Tópicos Avançados & Projeto Capstone ---

Aula 01 – Introdução ao Regex 🔍

Bem-vindo à primeira aula do curso de Expressões Regulares! Hoje vamos entender o que é esse "superpoder" e por que ele é essencial para qualquer pessoa que trabalhe com tecnologia.

🧐 O que são Expressões Regulares?

Uma Expressão Regular (ou Regex) é uma sequência de caracteres que forma um padrão de busca. Imagine que você está procurando uma agulha em um palheiro; o Regex é como um detector de metais ultra-sofisticado que te ajuda a encontrar exatamente o que você precisa.

Conceito Chave

Regex não é uma linguagem de programação, mas sim uma sintaxe poderosa suportada por quase todas as linguagens (JavaScript, Python, Java, PHP, etc.) e ferramentas (VS Code, Excel, Google Sheets).

🌍 Onde são utilizadas?

O Regex está em todo lugar, mesmo que você não perceba:

Validação: Verificar se o que o usuário digitou é realmente um e-mail ou CPF.
Busca e Substituição: Trocar todas as datas do formato DD/MM/AAAA para AAAA-MM-DD.
Extração: Retirar apenas os números de telefone de um bloco enorme de texto.
Web Scraping: Coletar informações específicas de sites.

📊 Fluxo de Funcionamento

graph LR
    A["Texto Bruto"] --> B{"Padrão Regex"}
    B -- "Match" --> C["Resultado Encontrado"]
    B -- "No Match" --> D["Nenhum Resultado"]
    style B fill:#f9f,stroke:#333,stroke-width:4px

💻 Exemplos Práticos no Dia a Dia

Vamos ver como o Regex simplifica tarefas complexas:

$ # Procurando a palavra "erro" em um log $ grep -E "erro" logs.txt $ $ # Extraindo apenas números de uma string $ echo "Pedido #12345" | sed 's/[^0-9]//g' $ 12345

Dica

Regex pode parecer assustador no começo devido à sua sintaxe "estranha", mas com prática, você verá que é uma ferramenta de produtividade incomparável.

🛠️ Ferramenta Indispensável: Regex101

Para testar suas expressões online sem precisar configurar nada, utilizaremos o Regex101.

Como usar:

Selecione a linguagem (Flavor) no menu lateral (ex: JavaScript ou Python).
Digite sua Expressão Regular no campo superior.
Digite o Texto de Teste no campo central.
Veja a mágica acontecer e a explicação detalhada no painel direito!

📝 Exercícios de Aquecimento

Básico: No Regex101, digite o texto "Olá Mundo" e tente encontrar a palavra "Mundo" usando Regex literal.
Básico: Qual a diferença entre pesquisar "Log" e "log" em um texto? (Dica: Pense em Maiúsculas/Minúsculas).
Intermediário: Tente encontrar o número "2024" no texto "O ano atual é 2024".
Intermediário: Como você buscaria a palavra "Regex" usando apenas metacaracteres se já soubesse que ela tem 5 letras? (Veremos isso na Aula 03, mas tente adivinhar!).
Desafio: No Regex101, cole um parágrafo qualquer e tente destacar todas as letras "a" (minúsculas).

🚀 Mini-Projeto: O Primeiro Match

Objetivo: Validar manualmente uma palavra em uma frase.

Abra o Regex101.
Crie um padrão para encontrar seu próprio nome em um texto que descreve quem você é.
Ative a flag i (Ignore Case) e veja se o nome continua sendo encontrado mesmo se você mudar a caixa das letras.

Aula 02 – Estrutura Básica de uma Expressão Regular 🏗️

Nesta aula, vamos mergulhar na fundação do Regex: a busca por textos fixos e como as máquinas interpretam as letras.

🔡 Texto Literal

A forma mais simples de Regex é o texto literal. Se você digitar gato no seu buscador Regex, ele encontrará exatamente a sequência de letras "g", "a", "t", "o", nessa ordem.

Atenção

O Regex procura por padrões exatos. Se você buscar por gato, as palavras Gato ou GATO não serão encontradas por padrão, pois a busca é sensível a maiúsculas e minúsculas.

🔠 Sensibilidade (Case Sensitivity)

Por padrão, a maioria dos motores de Regex diferencia A de a.

Padrão: casa
Texto: "A casa é verde." ✅ (Match)
Texto: "Minha Casa, minha vida." ❌ (No Match)

Dica

Para ignorar essa diferença, usamos a flag i (Ignore Case). Com ela, casa encontraria CASA, cAsA, etc.

📊 Diagrama de Fluxo de Busca Literal

graph TD
    Start((Início)) --> CheckG{Letra 'g'?}
    CheckG -- Sim --> CheckA{Letra 'a'?}
    CheckG -- Não --> Next["Próximo caractere"]
    CheckA -- Sim --> CheckT{Letra 't'?}
    CheckA -- Não --> Next
    CheckT -- Sim --> CheckO{Letra 'o'?}
    CheckT -- Não --> Next
    CheckO -- Sim --> Match((MATCH!))
    CheckO -- Não --> Next
    Next --> CheckG

💻 Primeiros Testes Práticos em Terminal

Podemos usar o Regex até no seu computador para filtrar arquivos ou textos.

$ # Filtrando nomes que começam com "A" (case-sensitive) $ echo "Ana\nana\nArthur" | grep "A" $ Ana $ Arthur $ $ # Filtrando nomes ignorando maiúsculas/minúsculas $ echo "Ana\nana\nArthur" | grep -i "ana" $ Ana $ ana

📝 Exercícios de Fixação

Básico: Crie uma expressão para encontrar a palavra "Python" em um parágrafo. Funciona se o texto estiver escrito "python"?
Básico: No Regex101, use o texto "O rato roeu a roupa do rei". Tente dar match na palavra "rato".
Intermediário: Tente encontrar a palavra "programação" (com acento). O Regex literal exige o acento?
Intermediário: Como você buscaria o número "123" usando texto literal?
Desafio: No Regex101, experimente ativar e desativar a flag i no canto superior direito e observe o que muda ao buscar por seu próprio nome.

🚀 Mini-Projeto: Localizador de Erros

Objetivo: Encontrar mensagens de erro em um log simulado.

Cole o seguinte texto no Regex101:

SYSTEM_INFO: Starting...
SYSTEM_WARNING: Low memory.
SYSTEM_ERROR: Database connection failed.
system_error: Disk full.

Crie um Regex literal para encontrar apenas SYSTEM_ERROR.
Agora, use a flag i para encontrar as duas ocorrências de erro (tanto maiúscula quanto minúscula).

Aula 03 – Metacaracteres Fundamentais 🔣

Bem-vindo ao coração do Regex! Metacaracteres são símbolos especiais que não representam a si mesmos, mas sim conceitos como "qualquer número" ou "qualquer letra".

⏺️ O Ponto (`.`) - O Coringa

O ponto é o metacaractere mais versátil. Ele dá match em qualquer caractere único, exceto quebras de linha.

Padrão: c.sa
Match: casa, cosa, c1sa, c#sa.

Conceito

O . é como uma peça de Lego que se encaixa em qualquer buraco de um único caractere.

🔢 Atalhos de Classes (`\d`, `\w`, `\s`)

Existem atalhos para grupos comuns que facilitam muito a nossa vida:

Metacaractere	O que significa	Exemplo
`\d`	Digit (Qualquer número de 0 a 9)	`9`, `5`
`\w`	Word (Letras, números e underline `_`)	`a`, `B`, `7`, `_`
`\s`	Space (Espaços, tabs e quebras de linha)	, `\t`

Dica

Se você usar a letra maiúscula (\D, \W, \S), você está fazendo a negação. Por exemplo, \D significa "qualquer coisa que NÃO seja um número".

📊 Tabela de Correspondências

graph TD
    Text["Texto: A1 _"] --> D["\d"]
    Text --> W["\w"]
    Text --> S["\s"]
    D --> MatchD["Matches: 1"]
    W --> MatchW["Matches: A, 1, _"]
    S --> MatchS["Matches: ' ' (espaço)"]

🛡️ O Caractere de Escape (`\`)

E se você quiser procurar por um ponto real (como em um endereço de IP)? Como o . é um metacaractere, você precisa "desativar" o poder dele usando a barra invertida \.

Padrão: google.com (Errado: o ponto encontrará qualquer coisa)
Padrão: google\.com (Certo: encontra exatamente o ponto final)

💻 Exemplo em TermynalJS

$ # Buscando padrões com dígitos (\d) $ grep -P "\d\d/\d\d" datas.txt $ 10/05 $ 25/12 $ $ # Buscando por um ponto literal $ grep -P "v1\.0" versoes.txt $ v1.0.1

📝 Exercícios de Fixação

Básico: Crie um Regex para encontrar datas no formato 00/00 usando \d.
Básico: Use o . para encontrar as palavras cola, cela e cila com um único padrão.
Intermediário: Como você buscaria um nome de usuário que tem 3 letras seguidas de um underline? (Ex: abc_).
Intermediário: Tente dar match em um valor monetário simples como $ 5 usando \$ \s \d.
Desafio: No Regex101, tente encontrar todas as palavras em um texto que possuam exatamente 4 letras usando \w\w\w\w.

🚀 Mini-Projeto: Extrator de Versões

Objetivo: Identificar versões de software em um texto.

Texto: A versão estável é v1.4, mas testamos a v1.a e a v2.0.
Crie um Regex que capture apenas as versões válidas (v + número + ponto + número).
Dica: Use v\d\.\d.

Aula 04 – Conjuntos de Caracteres 📦

E se você quiser encontrar uma vogal, mas não souber qual? Ou apenas letras minúsculas? É aqui que entram os Conjuntos de Caracteres.

🔡 O que são Conjuntos?

Um conjunto é definido entre colchetes []. Ele diz ao Regex: "Dê match em qualquer um dos caracteres que estão aqui dentro".

Padrão: [aeiou]
Texto: "bola" -> Encontra o, depois a.

📏 Usando Intervalos (Ranges)

Em vez de digitar todos os números ou letras, podemos usar o hífen - para definir um intervalo.

Conjunto	Descrição
`[a-z]`	Qualquer letra minúscula de 'a' até 'z'.
`[A-Z]`	Qualquer letra maiúscula de 'A' até 'Z'.
`[0-9]`	Qualquer número de 0 a 9 (o mesmo que `\d`).
`[a-zA-Z]`	Qualquer letra, independente da caixa.

Flexibilidade

Você pode combinar tudo: [a-f0-3] encontrará as letras de 'a' a 'f' e os números de 0 a 3.

📊 Visualização de Conjuntos

graph LR
    Input["Texto: 'B3'"] --> Set["Conjunto: [A-Z][0-9]"]
    Set --> Match["Match: 'B' e '3'"]

🚫 Negação (`[^...]`)

Se você colocar um circunflexo ^ logo após o primeiro colchete, o conjunto se torna uma negação. Ele encontrará qualquer coisa que NÃO esteja na lista.

Padrão: [^0-9]
Significado: Qualquer caractere que NÃO seja um número.

Atenção

O ^ só tem poder de negação se for o primeiro caractere dentro dos colchetes. Se estiver fora, ele tem outra função (veremos na Aula 06).

💻 Exemplo em TermynalJS

$ # Buscando apenas vogais $ echo "software" | grep -o "[aeiou]" $ o $ a $ e $ $ # Buscando tudo que NÃO é letra minúscula $ echo "RegEx 101" | grep -o "[^a-z]" $ R $ E $ $ 1 $ 0 $ 1

📝 Exercícios de Fixação

Básico: Crie um Regex que encontre apenas as letras 'x', 'y' ou 'z'.
Básico: Use um intervalo para encontrar qualquer letra entre 'm' e 'q'.
Intermediário: Crie um padrão que localize todas as consoantes minúsculas (Dica: Pense em negação de vogais ou lista completa).
Intermediário: Como você buscaria um caractere que seja uma letra maiúscula ou um dígito?
Desafio: No Regex101, tente criar um padrão que encontre um código de 3 caracteres onde o primeiro é uma letra maiúscula, o segundo é um número e o terceiro é uma letra minúscula.

🚀 Mini-Projeto: Filtro de Placas (Básico)

Objetivo: Identificar o início de uma placa de carro antiga (3 letras).

Texto: ABC-1234, xyz-9999, DEF-0000.
Crie um Regex que pegue apenas os conjuntos de 3 letras maiúsculas.
Dica: Use [A-Z][A-Z][A-Z].

Aula 05 – Quantificadores 🔢

Até agora, cada símbolo que escrevemos representava exatamente uma posição no texto. Com os Quantificadores, podemos dizer: "Encontre este padrão várias vezes seguidas".

➕ Os Quantificadores Básicos

Eles são colocados logo após o caractere ou conjunto que você quer repetir.

Símbolo	Significado	Exemplo (`a...`)
`*`	Zero ou mais vezes.	`a*` encontra "", "a", "aaaa"
`+`	Uma ou mais vezes.	`a+` encontra "a", "aaaa" (mínimo 1)
`?`	Opcional (Zero ou uma vez).	`a?` encontra "" ou "a"

🎯 Quantidade Exata `{n,m}`

Se você precisa de um controle mais fino, usamos as chaves.

{n}: Exatamente n vezes. (Ex: \d{3} para 3 dígitos).
{n,}: No mínimo n vezes. (Ex: \w{5,} para palavras longas).
{n,m}: Entre n e m vezes. (Ex: \d{2,4} para anos com 2 ou 4 dígitos).

📊 Funcionamento Visual

graph TD
    Start["Padrao: \d+"] --> Case1["Texto: '1' -> Match: '1'"]
    Start --> Case2["Texto: '123' -> Match: '123'"]
    Start --> Case3["Texto: 'abc' -> No Match"]

🧠 Guloso vs. Preguiçoso (Greedy vs Lazy)

Por padrão, os quantificadores são gulosos: eles tentam pegar o máximo de texto possível.

Texto: "capítulo 1" e "capítulo 2"
Padrão: ".*" -> Pegará desde a primeira aspa até a última.
Padrão Preguiçoso: ".*?" -> Pegará apenas o primeiro conteúdo entre aspas.

Dica

Adicione o ? após um quantificador (como +? ou *?) para torná-lo preguiçoso.

💻 Exemplo em TermynalJS

$ # Buscando palavras com 5 a 8 letras $ grep -E "\b\w{5,8}\b" texto.txt $ Brasil $ Programas $ $ # Validando um ano (4 dígitos) $ echo "2024" | grep -P "^\d{4}$" $ 2024

📝 Exercícios de Fixação

Básico: Crie um Regex que encontre a palavra "casa" seguida de um ou mais espaços.
Básico: Use o ? para encontrar tanto "cor" quanto "color" (em inglês, color vs colour).
Intermediário: Crie um padrão para validar um número de telefone simples com 8 ou 9 dígitos (ex: 988887777).
Intermediário: Use \d{1,3} para encontrar todos os números entre 1 e 999 em um texto.
Desafio: No Regex101, tente capturar tudo o que está dentro de uma tag HTML <div>...</div> de forma que ele pare no primeiro fechamento de tag (preguiçoso).

🚀 Mini-Projeto: Validador de Usuário

Objetivo: Validar um nome de usuário que deve: - Começar com uma letra. - Ter entre 5 e 12 caracteres alfanuméricos.

Dica: Use [a-zA-Z]\w{4,11}.
Por que {4,11}? Porque a primeira letra já conta como 1 caractere!
Teste com: admin, user123, a, meu_usuario_muito_longo.

Aula 06 – Âncoras ⚓

Até agora, nossos padrões encontravam correspondências em qualquer lugar do texto. As Âncoras servem para fixar a busca em uma posição específica: o início ou o fim do texto/linha.

🔝 Início da Linha (`^`)

O símbolo ^ (circunflexo), quando usado fora de colchetes, indica que o padrão deve começar exatamente no início da linha.

Texto: Engenharia de Software
Padrão: ^Engenharia -> ✅ Match
Padrão: ^Software -> ❌ No Match (pois 'Software' não está no início)

🔚 Fim da Linha (`$`)

O símbolo $ (cifrão) indica que o padrão deve estar exatamente no fim da linha.

Texto: projeto.js
Padrão: js$ -> ✅ Match
Padrão: projeto$ -> ❌ No Match

🛡️ Validação Completa de Campos

Este é o uso mais importante das âncoras. Ao combinar ^ no início e $ no fim, você garante que o texto inteiro obedeça à regra, sem "lixo" antes ou depois.

Padrão	O que aceita	Exemplo "2024"
`\d{4}`	Qualquer lugar	`"Em 2024..."` ✅
`^\d{4}$`	Apenas o número	`"2024"` ✅
`^\d{4}$`	Texto misto	`"Ano 2024"` ❌

📊 Visualização de Âncoras

graph LR
    S["^"] -- "Começa aqui" --> Text["Texto alvo"]
    Text -- "Termina aqui" --> E["$"]
    style S fill:#f96
    style E fill:#f96

💻 Exemplo em TermynalJS

$ # Listando apenas arquivos que terminam em .md $ ls | grep -P "\.md$" $ README.md $ aula-01.md $ $ # Validando se uma linha contém APENAS números $ echo "12345" | grep -P "^\d+$" $ 12345 $ $ echo "123a45" | grep -P "^\d+$" $ # (Sem saída, pois contém uma letra)

📝 Exercícios de Fixação

Básico: Crie um Regex que verifique se uma frase começa com a palavra "Bem-vindo".
Básico: Crie um Regex que localize arquivos que terminam com a extensão .pdf.
Intermediário: Tente validar uma linha que deve conter exatamente 5 dígitos, sem nada antes ou depois.
Intermediário: Como você buscaria uma linha que começa com um número e termina com um ponto final?
Desafio: No Regex101, use o texto:
```
linha 1
outra linha
última linha
```
Ative a flag m (multiline) e tente encontrar todas as linhas que terminam com a palavra linha.

🚀 Mini-Projeto: Validador de ID

Objetivo: Validar um código de produto que deve ter exatamente: - 2 letras maiúsculas no início. - Seguidas por um hífen -. - Terminadas por 4 números.

Dica: Use ^[A-Z]{2}-\d{4}$.
Teste com: AB-1234 (✅), abc-1234 (❌), AB-123 (❌), Z-9999 (❌).

Aula 07 – Agrupamentos e Captura 🎯

As vezes não queremos apenas encontrar um texto, mas sim isolar uma parte dele para usar mais tarde. É aqui que os parênteses () entram em cena.

📦 Grupos de Captura `()`

Ao envolver parte do seu Regex em parênteses, você cria um grupo. Isso permite: 1. Aplicar quantificadores a um grupo inteiro. 2. Extrair aquela parte específica do texto.

Padrão: (abc)+ -> Encontra "abc", "abcabc", "abcabcabc".
Sem parênteses: abc+ -> Encontra "abccccccc" (apenas o 'c' repete).

🔢 Referências Internas (Backreferences)

O motor de Regex "lembra" o que foi capturado em cada parênteses. Você pode usar \1, \2, etc., para repetir o que foi encontrado no primeiro ou segundo grupo.

Padrão: <(\w+)>.*?</\1>
Exemplo: Ele garante que se abriu uma tag <b>, ela deve fechar com </b>, e não com </i>.

Numeração

Os grupos são numerados pela ordem em que os parênteses abrem. O grupo 0 é sempre o match completo.

📊 Estrutura de Grupos

graph TD
    P["(Grupo 1) e (Grupo 2)"] --> G1["\1"]
    P --> G2["\2"]
    G1 -- "Contém" --> V1["Conteúdo 1"]
    G2 -- "Contém" --> V2["Conteúdo 2"]

💻 Exemplo em TermynalJS (Substituição)

No terminal ou editores, podemos usar grupos para trocar a ordem das coisas.

$ # Trocando Nome e Sobrenome (Ricardo Pires -> Pires, Ricardo) $ echo "Ricardo Pires" | sed -r 's/(\w+) (\w+)/\2, \1/' $ Pires, Ricardo

📝 Exercícios de Fixação

Básico: Crie um Regex que capture o código de área e o número de um telefone separadamente: (11) 9999-8888.
Básico: Use parênteses para repetir a palavra "Erro" 3 vezes: ErroErroErro.
Intermediário: No Regex101, use um texto com datas 21/10/2024 e capture o dia, o mês e o ano em 3 grupos diferentes.
Intermediário: Como você buscaria uma palavra que se repete duas vezes seguidas separada por espaço? (Ex: tchau tchau). Dica: use \1.
Desafio: Crie um padrão que extraia apenas o nome de usuário de um e-mail contato@empresa.com (tudo o que vem antes do @).

🚀 Mini-Projeto: Extrator de Preços

Objetivo: Extrair a moeda e o valor separadamente de uma lista de produtos.

Texto: Cadeira: R$ 150, Mesa: US$ 300, Sofá: € 500.
Regex: ([A-Z\$]+)\s?(\d+).
No Regex101, observe no painel lateral como ele separa os "Capture Groups" para cada item encontrado.
Dessa forma, um sistema poderia converter os valores automaticamente consultando o grupo 1 (moeda)!

Aula 08 – Alternância 🔀

E se você precisar encontrar "cachorro" OU "gato"? O operador de Alternância | (pipe) é o "OU" do Regex.

🏗️ O Operador `|`

A alternância permite que você defina várias opções de match. Ela verifica se o texto corresponde à opção da esquerda ou da direita.

Padrão: cachorro|gato
Match: Encontra tanto "cachorro" quanto "gato".

Prioridade

O Regex tenta o match da esquerda para a direita. No padrão ab|abc, se o texto for "abc", ele pode dar match em "ab" e parar (dependendo do motor), por isso é boa prática colocar o padrão mais longo primeiro: abc|ab.

📦 Alternância com Agrupamento

Geralmente usamos a alternância dentro de parênteses para limitar o "poder" do OU.

Padrão: venda (carro|moto)
Match: venda carro, venda moto.
Sem parênteses: venda carro|moto -> Encontraria venda carro OU apenas moto.

📊 Árvore de Decisão

graph TD
    Start["Texto: 'moto'"] --> Check1{"venda carro?"}
    Check1 -- Não --> Check2{"moto?"}
    Check2 -- Sim --> Match((MATCH!))

💻 Exemplo em TermynalJS

$ # Buscando por extensões de imagem variadas $ ls | grep -Ei "\.(jpg|png|gif|webp)$" $ logo.png $ foto.jpg $ loader.gif

📝 Exercícios de Fixação

Básico: Crie um Regex que encontre as cores "verde", "amarelo" ou "azul".
Básico: Use a alternância para encontrar os nomes "João" ou "Maria".
Intermediário: Crie um padrão que localize arquivos com extensões .pdf ou .docx.
Intermediário: Como você buscaria as saudações "Bom dia", "Boa tarde" ou "Boa noite" usando agrupamento? Dica: Bo(m dia|a tarde|a noite).
Desafio: No Regex101, crie um padrão que valide se uma palavra é "SIM", "S", "NAO" ou "N" (use a flag i).

🚀 Mini-Projeto: Filtro de Protocolos

Objetivo: Identificar se uma URL utiliza protocolos seguros ou comuns.

Texto: http://site.com, https://seguro.org, ftp://files.net, ssh://server.
Regex: (http|https|ftp|ssh)://.
No Regex101, veja como ele destaca apenas o protocolo inicial.
Extra: Tente simplificar http|https para https?.

Aula 09 – Modificadores (Flags) 🚩

Até agora, aprendemos a sintaxe estrutural. As Flags (ou Modificadores) são configurações globais que mudam o comportamento de como o motor de Regex processa o texto.

🏳️ As Flags Mais Comuns

Elas geralmente são colocadas após a barra final de um Regex: /padrão/flags.

Flag	Nome	Descrição
i	Ignore Case	Ignora a diferença entre Maiúsculas e Minúsculas.
g	Global	Encontra todas as ocorrências, não apenas a primeira.
m	Multiline	Faz as âncoras `^` e `$` funcionarem para cada linha.
s	Dot All	Faz o ponto `.` dar match também em quebras de linha (`\n`).

🔄 Global (`g`) vs Single Match

Sem a flag global, o Regex para assim que encontra o primeiro resultado.

Texto: casa, casa, casa
Padrão /casa/: Encontra apenas a primeira "casa".
Padrão /casa/g: Encontra as três instâncias.

📊 Resumo Visual das Flags

graph TD
    P["Padrão: /erro/"] --> NoFlag["Sem Flags: Encontra 'erro' (1ª vez)"]
    P --> FlagI["Flag 'i': Encontra 'erro', 'ERRO', 'Erro'"]
    P --> FlagG["Flag 'g': Encontra todas as vezes"]
    P --> FlagM["Flag 'm': ^ e $ olham cada linha"]

💻 Exemplo em TermynalJS

Em comandos de terminal, as flags costumam ser opções (como -i para ignore case).

$ # Buscando por "admin" ignorando caixa $ grep -i "admin" usuarios.txt $ Admin $ ADMIN $ admin_01

📝 Exercícios de Fixação

Básico: No Regex101, busque por "regex" em um parágrafo e ative a flag g. Observe os múltiplos destaques.
Básico: Ative a flag i e tente dar match em "TEXTO" usando o padrão texto.
Intermediário: Use a flag m para encontrar o início de cada linha em um texto com vários parágrafos.
Intermediário: Qual flag você usaria para garantir que o ponto . capture todo o conteúdo de um arquivo HTML, incluindo as quebras de linha?
Desafio: No Regex101, experimente combinar flags: /padrao/gi. O que isso faz?

🚀 Mini-Projeto: Limpador de Logs

Objetivo: Destacar todas as linhas que contenham erros, independente da caixa.

Texto:

10:00 - info: system ok
10:01 - ERROR: connection lost
10:05 - Error: timeout
10:10 - info: retrying

Regex: ^.*error.*$
Flags necessárias: g (para pegar todos), i (para pegar as variações de 'error') e m (para o ^ e $ olharem cada linha).

Aula 10 – Regex na Prática com JavaScript 📜

Agora que você já conhece a teoria, vamos aplicá-la em código real! O JavaScript possui um suporte excelente para Regex, utilizando o objeto RegExp ou a sintaxe de barras /padrao/.

🛠️ Três Métodos Essenciais

Em JavaScript, usamos Regex principalmente de três formas:

1. `regex.test(string)`

Retorna um booleano (true ou false). Ideal para validação.

const regexEmail = /^[a-z]+@gmail\.com$/;
console.log(regexEmail.test("contato@gmail.com")); // true

2. `string.match(regex)`

Retorna um array com as correspondências encontradas. Ótimo para extração.

const texto = "Match 1 e Match 2";
const encontrados = texto.match(/\d/g);
console.log(encontrados); // ["1", "2"]

3. `string.replace(regex, novoTexto)`

Substitui o que foi encontrado por um novo texto. Perfeito para limpeza e transformação.

const fone = "9999-8888";
const limpo = fone.replace("-", ""); // "99998888"

📊 Fluxo no JavaScript

graph LR
    A["RegExp Object"] --> B["test() -> Boolean"]
    A --> C["match() -> Array"]
    A --> D["replace() -> String"]

💻 Exemplo em TermynalJS (Node.js)

$ # Testando via Node.js $ node -e "console.log(/\d+/.test('Aula 10'))" $ true $ $ # Extraindo anos de uma frase $ node -e "console.log('2023 e 2024'.match(/\d+/g))" $ [ '2023', '2024' ]

📝 Exercícios de Fixação

Básico: Crie uma variável que contenha um Regex para validar se uma string é composta apenas por letras minúsculas: const regex = /.../.
Básico: Use o método .test() para verificar se a palavra "sucesso" está contida na frase "O curso é um sucesso!".
Intermediário: Dado o texto contato: 11-9999-8888, use .match() com a flag g para extrair todos os números.
Intermediário: Use .replace() para trocar todos os espaços de uma frase por sublinhados (_).
Desafio: Crie uma função que receba uma senha e use .test() para garantir que ela tenha pelo menos um número e pelo menos 6 caracteres.

🚀 Mini-Projeto: Validador de Formulário (JS)

Objetivo: Criar um script que valide um campo de nome de usuário.

Regra: O nome deve ter entre 3 e 15 letras, sem números.

Código:

const username = "ricardo_pires";
const validador = /^[a-zA-Z]{3,15}$/;

if (validador.test(username)) {
    console.log("✅ Usuário Válido!");
} else {
    console.log("❌ Usuário Inválido! Use apenas letras (3-15).");
}

Teste mudando o valor da variável username.

Aula 11 – Regex com Python 🐍

Python é uma das linguagens mais poderosas para processamento de texto e dados. Para usar Regex, utilizamos a biblioteca padrão re.

📦 A Biblioteca `re`

Diferente do JavaScript, no Python os métodos de Regex fazem parte de um módulo que você precisa importar.

import re

texto = "O ano é 2024"

1. `re.search(padrao, string)`

Procura a primeira ocorrência do padrão. Retorna um objeto de "Match" ou None.

match = re.search(r"\d+", texto)
if match:
    print(f"Encontrado: {match.group()}") # "2024"

2. `re.findall(padrao, string)`

Retorna uma lista com todas as ocorrências encontradas.

texto = "A1, B2, C3"
matches = re.findall(r"\d", texto)
print(matches) # ["1", "2", "3"]

3. `re.sub(padrao, substituto, string)`

Substitui as ocorrências por um novo texto (equivalente ao .replace do JS).

limpo = re.sub(r"\s+", "_", "Texto com espaços")
print(limpo) # "Texto_com_espaços"

🏗️ O uso do `r""` (Raw Strings)

Em Python, sempre use o prefixo r antes das aspas do seu Regex. Isso evita que o Python interprete as barras invertidas \ como comandos especiais dele mesmo.

Correto: re.search(r"\d", texto)
Errado: re.search("\d", texto) (pode causar bugs!)

💻 Exemplo em TermynalJS (Python CLI)

$ # Rodando script rápido em Python $ python -c "import re; print(re.findall(r'\w+', 'Regex é top'))" $ ['Regex', 'é', 'top'] $ $ # Verificando se começa com letra $ python -c "import re; print(bool(re.match(r'[a-zA-Z]', '123')))" $ False

📝 Exercícios de Fixação

Básico: Importe a biblioteca re e verifique se a palavra "Python" existe na frase "Aprendendo Python com Regex".
Básico: Use findall() para extrair todos os números de uma string: "Pedidos #102, #305 e #400".
Intermediário: Use re.sub() para remover todos os parênteses de um número de telefone: (11) 9999-8888.
Intermediário: Crie um script que use re.search() para encontrar a primeira data no formato DD/MM/AAAA.
Desafio: Crie uma função em Python que receba uma lista de e-mails e retorne apenas os que terminam em @empresa.com.

🚀 Mini-Projeto: Extrator de Links (Python)

Objetivo: Extrair todas as URLs de um bloco de texto.

Código Sugerido:

import re

html = 'Acesse <a href="https://google.com">Google</a> e <a href="https://python.org">Python</a>'
links = re.findall(r'https?://[\w.]+', html)

for link in links:
    print(f"Link encontrado: {link}")

Desafio: Tente fazer o findall retornar apenas o domínio (sem o http).

Aula 12 – Validação de Dados Reais ✅

Nesta aula, vamos colocar em prática tudo o que aprendemos para construir validadores de dados comuns no dia a dia do desenvolvimento.

📧 Validação de E-mail

Validar e-mail com Regex é um dos temas mais debatidos, pois existem formatos muito complexos. Vamos focar em uma versão robusta e prática:

Padrão: ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
Explicação:
- ^...$: Garante que o texto inteiro é o e-mail.
- [a-zA-Z0-9._%+-]+: Usuário (letras, números e alguns símbolos).
- @: O símbolo obrigatório.
- [a-zA-Z0-9.-]+: Domínio.
- \.[a-zA-Z]{2,}: Extensão (ex: .com, .org, .com.br).

🆔 Validação de CPF (Formato)

Lembrando que o Regex valida apenas o formato (máscara), não a lógica do dígito verificador.

Formato: 000.000.000-00
Padrão: ^\d{3}\.\d{3}\.\d{3}-\d{2}$
Com pontos opcionais: ^\d{3}\.?\d{3}\.?\d{3}-?\d{2}$

📱 Validação de Telefone (Brasil)

Formato: (11) 99999-8888
Padrão: ^$\d{2}$\s\d{4,5}-\d{4}$

📊 Tabela de Padrões Reais

Dado	Regex Sugerido
Data (DD/MM/AAAA)	`^\d{2}/\d{2}/\d{4}$`
CEP	`^\d{5}-\d{3}$`
Hora (24h)	`^([01]\d\|2[0-3]):[0-5]\d$`

💻 Exemplo em TermynalJS (Validação Única)

$ # Validando um CPF via terminal $ echo "123.456.789-00" | grep -P "^\d{3}\.\d{3}\.\d{3}-\d{2}$" $ 123.456.789-00 $ $ # Testando um CPF inválido $ echo "123-456" | grep -P "^\d{3}\.\d{3}\.\d{3}-\d{2}$" $ # (Nenhum resultado retornado)

📝 Exercícios de Fixação

Básico: Crie um Regex para validar um CEP no formato 00000-000.
Básico: Melhore o validador de CPF para aceitar tanto números com pontos quanto apenas números (12345678900).
Intermediário: Crie um validador de URL simples que comece com https:// e termine com .com.
Intermediário: Valide um horário no formato HH:MM.
Desafio: No Regex101, crie um padrão para "Senhas Fortes" que exija: Mínimo 8 caracteres, pelo menos uma letra e pelo menos um número. (Use o que aprendeu, não precisa ser uma única expressão se for difícil demais agora!).

🚀 Mini-Projeto: Validador de Senhas

Objetivo: Verificar se uma senha atende aos requisitos mínimos de segurança.

Regra: A senha deve ter entre 8 e 20 caracteres e conter ao menos um caractere especial (!@#$%*).
Regex sugerido: ^[\w!@#$%*]{8,20}$ (Note: este aceita, mas não obriga o especial, para obrigar precisaríamos de lookaheads, que é avançado. Por enquanto, valide se ela contém apenas os permitidos e o tamanho).
Teste com: senha123 (✅), 123 (❌), senha_muito_longa_que_passa_do_limite (❌).

Aula 13 – Extração de Dados ⛏️

Buscar padrões é útil, mas extrair informações específicas de uma massa de texto é onde o Regex economiza horas de trabalho manual.

📅 Extraindo Datas

Imagine um log de sistema com milhares de linhas. Como extrair apenas as datas das ocorrências?

Texto: O sistema falhou em 21/10/2024 e novamente em 23/10/2024.
Regex: \d{2}/\d{2}/\d{4}
Resultado: ["21/10/2024", "23/10/2024"]

🏷️ Extraindo Hashtags e Menções

Muito comum em análise de redes sociais.

Hashtags: #[a-zA-Z\d_]+
Menções (@): @[a-zA-Z\d_]+

🔗 Extraindo Links de HTML

Extrair o atributo src de imagens ou href de links.

Regex para Links: href="([^"]+)"
Explicação: Captura tudo o que está dentro das aspas do href.

📊 Fluxo de Extração

graph TD
    Data["Documento Grande (PDF/Log)"] --> Regex["Motor de Busca (findall)"]
    Regex --> List["Lista de Resultados"]
    List --> Clean["Dados Limpos e Prontos"]

💻 Exemplo em TermynalJS (grep -o)

A flag -o do grep é excelente para extração, pois ela retorna apenas a parte que deu match, e não a linha inteira.

$ # Extraindo apenas as hashtags de um post $ echo "Aprendendo #Regex com #Python e #JS" | grep -oP "#\w+" $ #Regex $ #Python $ #JS

📝 Exercícios de Fixação

Básico: Crie um Regex para extrair todos os valores monetários de uma lista: R$ 10, R$ 50, R$ 100.
Básico: Extraia todas as palavras que possuem exatamente 3 letras de um parágrafo.
Intermediário: Dado um texto com vários nomes de usuários no formato @usuario, extraia apenas o nome (sem o @) usando grupos de captura.
Intermediário: Extraia todos os números de telefone de uma página de contatos.
Desafio: No Regex101, tente extrair o conteúdo de dentro de todos os títulos <h1>...</h1> de um código HTML simulado.

🚀 Mini-Projeto: Analisador de Logs

Objetivo: Extrair os IPs e os horários de acesso de um log de servidor.

Texto de Exemplo:

192.168.0.1 - [10:30:05] - GET /index.html
10.0.0.5 - [10:32:10] - POST /login

Regex para IP: \d{1,3}(\.\d{1,3}){3}
Regex para Hora: \[(\d{2}:\d{2}:\d{2})\]
Crie um script (JS ou Python) que percorra essas linhas e imprima: "O IP X acessou o sistema às Y horas".

Aula 14 – Limpeza e Transformação 🧼

Muitas vezes recebemos dados "sujos": com espaços extras, formatos inconsistentes ou informações desnecessárias. O Regex é o "sabão" ideal para limpar esses dados.

🧹 Removendo Espaços Extras

Espaços em branco antes, depois ou duplos no meio do texto são vilões de bancos de dados.

Espaços no início/fim: ^\s+|\s+$
Espaços duplos: \s{2,} (substituir por um único espaço " ").

🔄 Transformando Formatos (Reordenação)

Usando grupos de captura, podemos mudar a ordem das informações.

Transformar: 2024-10-21 (ISO) -> 21/10/2024 (BR)
Regex: (\d{4})-(\d{2})-(\d{2})
Substituição: $3/$2/$1

🎭 Mascarando Dados Sensíveis

Esconder partes de um código ou e-mail por segurança.

Texto: 123.456.789-00
Regex: \d(?=\d{2}) (Usa um lookahead para pegar todos os números exceto os dois últimos).
Substituição: *
Resultado: ***.***.***-00

📊 Fluxo de Transformação

graph LR
    Input["Dado Sujo"] --> Find["Padrão Regex"]
    Find --> Replace["Ação: Reorder / Delete / Replace"]
    Replace --> Output["Dado Pronto"]

💻 Exemplo em TermynalJS (JS Replace)

$ # Removendo tags HTML de um texto $ node -e "console.log('

Olá

'.replace(/<[^>]+>/g, ''))" $ Olá $ $ # Limpando caracteres não-numéricos de um telefone $ node -e "console.log('(11) 9999-8888'.replace(/\D/g, ''))" $ 1199998888

📝 Exercícios de Fixação

Básico: Crie um Regex para remover todos os parênteses e traços de um CPF.
Básico: Use .replace() para trocar todas as letras "a" por "@" em uma frase.
Intermediário: Dado um nome completo "Pires, Ricardo", use Regex para transformá-lo em "Ricardo Pires". (Dica: Use dois grupos e troque sua ordem).
Intermediário: Crie um padrão que remova todas as quebras de linha duplas, transformando-as em apenas uma.
Desafio: No Regex101, use a aba "Substitution" para transformar uma lista de preços no formato 150.00 para o formato brasileiro 150,00 usando grupos.

🚀 Mini-Projeto: Sanitizador de Inputs

Objetivo: Criar uma função que "limpe" um nome de usuário, removendo qualquer caractere que não seja uma letra ou número.

Código Sugerido (JS):

function limparUsuario(input) {
    return input.replace(/[^a-zA-Z0-9]/g, "");
}

console.log(limparUsuario("ricardo! @pires 101")); // "ricardopires101"

Desafio: Modifique a função para que ela também converta tudo para minúsculas após a limpeza.

Aula 15 – Desempenho e Boas Práticas ⚡

Nem tudo que funciona é eficiente. Um Regex mal escrito pode travar um servidor ou tornar uma aplicação lenta. Vamos aprender a escrever padrões profissionais.

🐢 O Perigo do Backtracking

Backtracking acontece quando o motor de Regex tenta várias combinações e falha, precisando "voltar" e tentar de novo. Casos extremos levam ao Catastrophic Backtracking.

Exemplo Ruim: (a+)+b
Se você testar isso em uma string com muitos 'a's e nenhum 'b', o computador fará bilhões de cálculos inúteis.

Cuidado

Evite aninhar quantificadores (como (a*)*).

🚀 Dicas de Performance

Seja Específico: Em vez de .* (que pega tudo), use [a-z]+ se você sabe que só haverá letras.
Use Âncoras: ^ e $ ajudam o motor a falhar rápido se o padrão já não bater no início/fim.
Grupos de Não-Captura: Se você não precisa extrair o dado, use (?:...) em vez de (...). Isso economiza memória.
Falhe Cedo: Coloque os padrões mais comuns primeiro na alternância |.

🎓 Boas Práticas de Legibilidade

Regex pode ser ilegível. Ajude seus colegas (e seu eu do futuro):

Comente: Documente o que aquele "hieroglifo" faz.
Não reinvente a roda: Use bibliotecas consagradas para validações ultra-complexas (como e-mail).
Teste Sempre: Use ferramentas como Regex101 com exemplos reais antes de colocar em produção.

📊 Comparativo de Performance

graph LR
    P1["Padrão Amplo (.*)"] -- "Lento" --> Engine["Motor Regex"]
    P2["Padrão Específico (\d+)"] -- "Rápido" --> Engine
    Engine --> Result["Resultado"]

💻 Exemplo em TermynalJS (Otimização)

$ # Padrão genérico e lento $ time find . | grep -P ".*\.md" $ $ # Padrão otimizado e específico $ time find . | grep -P "\.md$" $ # (O segundo será ligeiramente mais rápido em diretórios gigantes)

📝 Exercícios de Fixação

Básico: Transforme o grupo (abc) em um grupo de não-captura.
Básico: Reescreva o padrão .* para algo que procure apenas por números de 0 a 9.
Intermediário: Identifique o erro de performance no padrão (a|b|c|d|e|f|g)+ e como simplificá-lo usando conjuntos [].
Intermediário: Por que usar ^ em um validador de formulário melhora a performance em relação a uma busca sem âncora?
Desafio: No Regex101, observe o painel "Regex Debugger" enquanto testa o padrão (a+)+c contra a string aaaaaaaaaaaaab. Veja quantos passos o motor executa antes de falhar.

🚀 Mini-Projeto: Auditor de Regex

Objetivo: Analisar um Regex existente e sugerir melhorias.

Regex Alvo: ^.*@.*\..*$ (Um validador de e-mail bem ruim).
Problemas: .* é muito genérico e pode causar lentidão.
Sugerir uma versão mais específica usando conjuntos de caracteres (visto na Aula 12).
Explique por que a nova versão é mais segura contra ataques de negação de serviço (ReDoS).

Aula 16 – Projeto Final: O Grande Desafio 🏆

Parabéns! Você chegou à última aula do curso. Agora é hora de consolidar tudo o que aprendeu em um desafio prático que simula uma tarefa real de um Engenheiro de Dados ou Desenvolvedor Backend.

🎯 O Cenário

Você recebeu um arquivo de texto bruto (OCR) gerado a partir de notas fiscais antigas. O texto está bagunçado, com espaços extras, diferentes formatos de data e valores misturados. Sua missão é criar um "Sanitizador de Notas" usando Regex.

Dados de Exemplo:

NOTA_FISCAL #001 - DATA: 21-10-2024 - VALOR: R$ 150,00 - STATUS: Pago
nota_fiscal #002 | DATA: 22/10/2024 | VALOR: 300.00 | STATUS: pendente
NF #003; dt: 23.10.2024; val: R$ 50,50; st: PAGO

🛠️ Requisitos do Projeto

O seu algoritmo (em JS, Python ou apenas Regex) deve ser capaz de:

Normalizar o Título: Identificar "NOTA_FISCAL", "nota_fiscal" ou "NF" e transformar tudo em "NF".
Padronizar a Data: Converter todos os formatos (-, /, .) para o padrão brasileiro DD/MM/AAAA.
Limpar o Valor: Extrair apenas o número decimal (ex: 150,00).
Normalizar o Status: Transformar "pendente", "Pago" ou "PAGO" em letras maiúsculas: PAGO ou PENDENTE.

📊 Estrutura de Solução Proposta

graph TD
    Raw["Texto Bruto"] --> T1["Normalizar Títulos (Alternância)"]
    T1 --> T2["Normalizar Datas (Grupos de Captura)"]
    T2 --> T3["Extrair Valores (Dígitos e Vírgula)"]
    T3 --> T4["Normalizar Status (Lower/Upper Case)"]
    T4 --> Final["JSON / CSV Limpo"]

💻 Exemplo de Saída Esperada

Após o processamento, os dados devem estar assim: - NF #001 | 21/10/2024 | 150,00 | PAGO - NF #002 | 22/10/2024 | 300,00 | PENDENTE - NF #003 | 23/10/2024 | 50,50 | PAGO

📝 Exercício Final: O Script Completo

Tente implementar a solução acima na linguagem de sua preferência.

Dica de Python:

import re

linha = "NOTA_FISCAL #001 - DATA: 21-10-2024 - VALOR: R$ 150,00 - STATUS: Pago"

# 1. Normalizar Título
linha = re.sub(r"(NOTA_FISCAL|nota_fiscal|NF)", "NF", linha)

# 2. Normalizar Data
linha = re.sub(r"(\d{2})[-.](\d{2})[-.](\d{4})", r"\1/\2/\3", linha)

# 3. Limpar Status
if "Pago" in linha or "PAGO" in linha:
    linha = re.sub(r"STATUS: \w+", "STATUS: PAGO", linha, flags=re.I)

print(linha)

🎨 Conclusão do Curso

Expressões Regulares são uma ferramenta vital. Você não precisa memorizar tudo, mas agora você sabe: - O que procurar: Qual metacaractere resolve seu problema. - Onde testar: Usando o Regex101. - Como aplicar: Em JavaScript, Python ou no Terminal.

Continue praticando e use esse superpoder para automatizar tarefas chatas no seu dia a dia! 🚀

Aula 17 - Expressões Regulares Avançadas (Lookarounds e Backreferences) 🔍

Objetivo Pedagógico

Objetivo: Dominar a teoria e a aplicação de expressões regulares avançadas: autômatos finitos (DFA vs NFA), lookarounds positivos e negativos, grupos atômicos, backreferences e prevenção de Catastrophic Backtracking (ReDoS).

📑 1. Fundamentos Teóricos & Análise Técnica

As Expressões Regulares constituem uma linguagem formal para especificação de padrões sobre sequências de caracteres, fundamentadas na Hierarquia de Chomsky e na teoria dos autômatos finitos.

A compreensão profunda dos motores de regex divide-se em aspectos teóricos e computacionais: 1. DFA (Deterministic Finite Automaton) vs. NFA (Non-Deterministic Finite Automaton): - Motores DFA (ex: GNU grep básico, re2): Varrem cada caractere do texto exatamente uma vez em tempo estritamente linear $O(n)$, mas não suportam recursos como backreferences ou lookarounds. - Motores NFA (ex: PCRE, Python, Perl, JavaScript): Operam orientados ao padrão de busca, permitindo retrocesso (Backtracking). São imensamente expressivos, mas vulneráveis a complexidade temporal exponencial em padrões mal projetados. 2. Lookarounds (Afirmações de Largura Zero - Zero-Width Assertions): - Permitem testar condições no texto sem consumir caracteres para a correspondência final: - Positive Lookahead (?=...) e Negative Lookahead (?!...). - Positive Lookbehind (?<=...) e Negative Lookbehind (?<!...). 3. Catastrophic Backtracking e Ataques ReDoS (Regular Expression Denial of Service): - Quando quantificadores aninhados colapsam (ex: (a+)+$) contra uma entrada divergente (ex: aaaaaaaaaaaaaaaaaaaaaaaa!), o motor NFA explora todas as permutações possíveis, consumindo 100% da CPU por horas. - Prevenção: Uso de quantificadores possessivos (a++) ou agrupamentos atômicos (?>...) que proíbem o backtracking no grupo avaliado.

📐 Arquitetura Conceitual & Diagrama de Fluxo

graph LR
    Regex["Expressão Regular: (?<=TOKEN:)[A-Z0-9]{8}(?!_TEMP)"] --> Engine["Motor NFA com Retrocesso Controlado"]
    Engine --> Lookbehind["Positive Lookbehind: Exige prefixo 'TOKEN:' sem incluir no match"]
    Lookbehind --> Match["Casamento de 8 Caracteres Alfanuméricos"]
    Match --> Lookahead["Negative Lookahead: Rejeita se sufixo for '_TEMP'"]
    Lookahead --> Success["Captura Segura e Atômica!"]
    style Regex fill:#e1f5fe,stroke:#01579b
    style Engine fill:#fff3e0,stroke:#e65100
    style Lookbehind fill:#f3e5f5,stroke:#7b1fa2
    style Match fill:#e8f5e9,stroke:#2e7d32
    style Success fill:#e0f2f1,stroke:#00695c

🔍 Pilares e Diretrizes Técnicas

Nesta unidade, aprofundamos os seguintes conceitos fundamentais: - Lookarounds de Largura Zero: Validação contextual de limites de palavras e padrões anteriores ou posteriores sem alterar os ponteiros de extração. - Backreferences com \1, \2: Referenciação de grupos capturados anteriormente para validação de tags balanceadas (ex: <([a-z]+)>.*?</\1>). - Grupos Atômicos e Quantificadores Possessivos: Eliminação do caminho de retrocesso para anular completamente vulnerabilidades de ReDoS. - Conformidade com Padrão PCRE (Perl Compatible): Aproveitamento dos modificadores globais (s dotall, m multiline, x extended com comentários).

🛠️ 2. Implementação Prática em Expressões Regulares PCRE, Teoria dos Autômatos e Parsing

Abaixo está a implementação técnica de referência, estruturada com padrões de engenharia de software e foco em robustez:

// pcre_regex_toolkit.sh (Extração Avançada com Lookarounds usando Perl e Ripgrep)
#!/usr/bin/env bash
# Demonstração de Expressões Regulares Avançadas com PCRE em Terminal

SAMPLE_TEXT="API_KEY:A9X8K2M1_PROD | API_KEY:B7Y4L9Z0_TEMP | SECRET:99X8K2M1"

echo "Texto de Entrada: $SAMPLE_TEXT"
echo "--------------------------------------------------------"

# 1. Extrair chaves de produção usando Positive Lookbehind e Negative Lookahead
# Deve capturar 'A9X8K2M1' e ignorar 'B7Y4L9Z0' porque termina com _TEMP
echo "Resultado Lookbehind (?<=API_KEY:) + Lookahead (?!.*_TEMP):"
perl -nE 'say for /(?<=API_KEY:)([A-Z0-9]{8})(?!_TEMP)/g' <<< "$SAMPLE_TEXT"

# 2. Exemplo de Backreference para validar integridade de tags XML/HTML
HTML_SNIPPET="<section>conteudo valido</section><div>invalido</span>"
echo -e "
Validando tags estritamente fechadas com Backreference (\\1):"
perl -nE 'say "Tag válida: $&" while /<([a-z]+)>.*?<\/\1>/g' <<< "$HTML_SNIPPET"

💡 Análise Passo a Passo do Código

Uso de (?<=API_KEY:): Inspeciona se a chave é precedida pelo prefixo sem incluí-lo na variável capturada.
Negative Lookahead (?!_TEMP): Descarta qualquer correspondência que possua o marcador de teste indesejado.
Backreference <\/\1>: Garante que o elemento de fechamento corresponda exatamente ao nome do identificador capturado no primeiro grupo.

🎯 3. Próximos Passos & Sequência Didática

Slides da Aula
- Visualizar Apresentação Interativa
- Abrir Slides em Tela Cheia
Quiz de Fixação
- Testar Conhecimentos (10 Questões)
Exercícios Práticos
- Lista de Exercícios com Gabarito
Desafio de Projeto
- Especificação do Desafio Prático

Aula 18 - Processamento de Dados Textuais com AWK e SED 📊

Objetivo Pedagógico

Objetivo: Manipular fluxos massivos de dados estruturados em texto no ambiente Unix/Linux utilizando a linguagem de processamento orientado a padrões AWK e o editor de fluxo não interativo SED.

📑 1. Fundamentos Teóricos & Análise Técnica

Na tradição da filosofia Unix, fluxos de texto puro representam a interface universal entre processos. Quando arquivos de log atingem dezenas de gigabytes, ferramentas convencionais baseadas em carregamento total em memória falham; SED e AWK processam esses fluxos linha a linha com eficiência de milissegundos e consumo ínfimo de RAM.

A distinção arquitetural entre as duas ferramentas define seu caso de uso ideal: 1. SED (Stream Editor - Editor de Fluxo): - Especializado em transformações de texto em fluxo contínuo através de seu ciclo padrão: lê uma linha do stdin para o Pattern Space, aplica comandos sequenciais e envia para o stdout. - Comandos Críticos: Substituição (s/padrao/substituto/flags), deleção de linhas (d), impressão seletiva com supressão (sed -n '/padrao/p') e o uso do Hold Space para manipulações complexas de múltiplas linhas. 2. AWK (Linguagem Completa de Processamento de Registros e Campos): - É uma linguagem de programação Turing-completa com tipagem associativa automática e foco em dados tabulares. - Modelo de Execução Orientado a Padrão-Ação: PADRÃO { AÇÃO }. - Variáveis de Sistema Fundamentais: - FS (Field Separator) e OFS (Output Field Separator). - NR (Number of Records - número total de linhas processadas) e FNR (número da linha no arquivo atual). - NF (Number of Fields - quantidade de colunas na linha corrente). - Tabelas Hash Associativas: Permitem agregações estatísticas, cálculos de médias e agrupamentos instantâneos sem dependência de bancos de dados.

📐 Arquitetura Conceitual & Diagrama de Fluxo

graph TD
    Input["Arquivo de Log Massivo (10GB Nginx/Access Log)"] --> Stream["Stream Linha a Linha (stdin)"]
    Stream --> SED["SED: Filtro e Sanitização Rápida (s///g, d)"]
    SED --> Pipe["Pipe Unix (| Sem Escrita em Disco)"]
    Pipe --> AWK["AWK: Parser de Colunas ($1, $7, $9)"]
    AWK --> Hash["Tabela Associativa: count[$status]++"]
    Hash --> End["Bloco END: Imprime Relatório Agregado Formatado"]
    style Input fill:#e1f5fe,stroke:#01579b
    style SED fill:#fff3e0,stroke:#e65100
    style AWK fill:#f3e5f5,stroke:#7b1fa2
    style End fill:#e8f5e9,stroke:#2e7d32

🔍 Pilares e Diretrizes Técnicas

Nesta unidade, aprofundamos os seguintes conceitos fundamentais: - Processamento Estritamente Linear em Memória: Capacidade de processar centenas de gigabytes de logs consumindo apenas alguns megabytes de memória RAM. - Poder dos Blocos BEGIN e END no AWK: Inicialização de estruturas e totalização de relatórios após o término do processamento das linhas. - Expressões Regulares Nativa em Ambos: Filtragem seletiva de linhas que satisfazem padrões complexos antes de cálculos aritméticos. - Edição In-Place com Backup no SED: O modificador sed -i.bak permite substituições atômicas no próprio arquivo mantendo cópia de salvaguarda.

🛠️ 2. Implementação Prática em Processamento de Texto Unix, SED e AWK

Abaixo está a implementação técnica de referência, estruturada com padrões de engenharia de software e foco em robustez:

// log_analytics_pipeline.sh (Pipeline de Análise de Acessos HTTP com SED e AWK)
#!/usr/bin/env bash
# Pipeline de alta velocidade para sumarização de tráfego HTTP

# Simulação de registros de log do Nginx (IP, Data, Método, Rota, Status, Bytes)
LOG_DATA='192.168.1.10 - [05/Sep/2026:10:00:01] "GET /api/v1/orders HTTP/1.1" 200 4521
192.168.1.15 - [05/Sep/2026:10:00:02] "POST /api/v1/login HTTP/1.1" 401 512
192.168.1.10 - [05/Sep/2026:10:00:03] "GET /api/v1/orders HTTP/1.1" 200 4521
192.168.1.20 - [05/Sep/2026:10:00:04] "GET /healthz HTTP/1.1" 200 24
192.168.1.15 - [05/Sep/2026:10:00:05] "POST /api/v1/login HTTP/1.1" 200 890'

echo "=== Relatório Agregado de Status HTTP por AWK ==="
echo "$LOG_DATA" | awk '
BEGIN {
    print "STATUS\tTOTAL_REQS\tTOTAL_BYTES"
    print "----------------------------------------"
}
{
    # $9 é o status HTTP (200, 401) e $10 são os bytes
    status = $9
    bytes = $10

    req_count[status]++
    bytes_count[status] += bytes
}
END {
    for (s in req_count) {
        printf "%s\t%d\t\t%d KB\n", s, req_count[s], bytes_count[s] / 1024
    }
}'

💡 Análise Passo a Passo do Código

Uso de Arrays Associativos: A chave req_count[status] acumula contadores dinamicamente sem necessidade de declaração prévia.
Bloco BEGIN Declarativo: Imprime cabeçalhos formatados antes de iniciar a leitura do fluxo de dados.
Formatação com printf no END: Produz tabelas perfeitamente alinhadas para fácil interpretação em relatórios operacionais.

🎯 3. Próximos Passos & Sequência Didática

Slides da Aula
- Visualizar Apresentação Interativa
- Abrir Slides em Tela Cheia
Quiz de Fixação
- Testar Conhecimentos (10 Questões)
Exercícios Práticos
- Lista de Exercícios com Gabarito
Desafio de Projeto
- Especificação do Desafio Prático

Aula 19 - Scripts Shell Robustos com Tratamento de Sinais 🛡️

Objetivo Pedagógico

Objetivo: Desenvolver scripts em Shell defensivos de nível profissional: modos estritos (set -euo pipefail), tratamento de sinais do sistema operacional com trap, locks concorrentes com flock e logs estruturados para auditoria.

📑 1. Fundamentos Teóricos & Análise Técnica

Scripts em Shell frequentemente controlam tarefas críticas de automação e orquestração de servidores. No entanto, scripts mal elaborados falham silenciosamente ao encontrar erros, deixam arquivos temporários órfãos e corrompem bases de dados compartilhadas em execuções paralelas.

A engenharia de Bash Scripting Defensivo baseia-se em princípios sólidos: 1. O Modo Estrito Padrão (set -euo pipefail): - set -e (errexit): O script encerra imediatamente se qualquer comando retornar um código de saída diferente de zero. - set -u (nounset): Trata a expansão de variáveis não declaradas como um erro fatal, prevenindo desastres como rm -rf $DIRETORIO_INEXISTENTE/*. - set -o pipefail: Em pipelines com múltiplos estágios (cmd1 | cmd2 | cmd3), o status de retorno será o do último comando a falhar, e não o status do último comando executado. 2. Gerenciamento de Sinais do Kernel com trap: - Processos recebem sinais de ciclo de vida do kernel: SIGINT (Ctrl+C), SIGTERM (pedido de encerramento gracioso) ou o pseudossinal EXIT do próprio interpretador. - O comando trap registra funções de limpeza que garantem a exclusão de arquivos temporários, liberação de soquetes e alerta de falhas mesmo sob encerramento inesperado. 3. Controle de Concorrência com flock (File Locking): - Impede que instâncias concorrentes de um mesmo script executadas por agendadores (como o Cron) colidam, utilizando travas a nível de inode do sistema de arquivos.

📐 Arquitetura Conceitual & Diagrama de Fluxo

graph TD
    Start["Início do Script (PID: 4125)"] --> Lock["flock /tmp/meu_job.lock (Trava Concorrente)"]
    Lock --> Setup["trap cleanup EXIT SIGINT SIGTERM"]
    Setup --> Temp["Cria Diretório Efêmero mktemp -d"]
    Temp --> Work["Execução da Tarefa Crítica (Processamento de Dados)"]
    Work --> Signal{"Recebeu SIGINT / Erro?"}
    Signal -- Sim --> Cleanup["Executa cleanup() via trap: Deleta Temp e Libera Lock"]
    Signal -- Não --> Success["Conclui Tarefa e Aciona cleanup() no EXIT"]
    style Start fill:#e1f5fe,stroke:#01579b
    style Lock fill:#fff3e0,stroke:#e65100
    style Setup fill:#f3e5f5,stroke:#7b1fa2
    style Cleanup fill:#ffebee,stroke:#c62828
    style Success fill:#e8f5e9,stroke:#2e7d32

🔍 Pilares e Diretrizes Técnicas

Nesta unidade, aprofundamos os seguintes conceitos fundamentais: - Modo Estrito Universal: Inclusão obrigatória de set -euo pipefail no topo de qualquer script de produção corporativa. - Funções de Limpeza com trap: Garantia irrestrita de purga de artefatos temporários no disco independentemente da causa de saída. - Bloqueio Exclusivo com flock: Prevenção matemática de corrida de concorrência em scripts agendados no Cron. - Saída e Códigos Semânticos: Uso de códigos de retorno padronizados para integração confiável com sistemas de monitoramento.

🛠️ 2. Implementação Prática em Bash Scripting Defensivo, POSIX e Signal Trapping

Abaixo está a implementação técnica de referência, estruturada com padrões de engenharia de software e foco em robustez:

// defensive_script_template.sh (Template de Script Bash Robusto com Trap e Flock)
#!/usr/bin/env bash
set -euo pipefail
IFS=$'\n\t'

# 1. Garantir que apenas uma instância execute concorrentemente
LOCK_FILE="/tmp/portal_batch_sync.lock"
exec 200>"$LOCK_FILE"
flock -n 200 || {
    echo "[ERRO] Outra instância do script já está em execução! Abortando." >&2
    exit 1
}

# 2. Criar diretório temporário seguro
TEMP_DIR=$(mktemp -d -t portal_sync_XXXXXX)
echo "[INFO] Diretório temporário alocado: $TEMP_DIR"

# 3. Registrar função de limpeza atômica via trap
cleanup() {
    local exit_code=$?
    echo "[CLEANUP] Executando rotina de limpeza final (Exit Code: $exit_code)..."
    rm -rf "$TEMP_DIR"
    flock -u 200 || true
    echo "[CLEANUP] Recursos liberados com sucesso."
    exit "$exit_code"
}
trap cleanup EXIT SIGINT SIGTERM

# 4. Lógica de Execução com tratamento estrito
echo "[EXEC] Processando lote de sincronização de dados..."
# Simulação de trabalho seguro
touch "$TEMP_DIR/dados_processados.csv"
echo "Processamento concluído com sucesso!"

💡 Análise Passo a Passo do Código

Uso de File Descriptor 200 com flock: Mecanismo robusto que associa a trava ao ciclo de vida do descritor de arquivo aberto.
Criação de Diretório com mktemp -d: Evita ataques de symlink e colisões em diretórios compartilhados como /tmp.
Rotina cleanup no Pseudossinal EXIT: Garante execução automática ao encerrar o script com sucesso ou sob falha fatal.

🎯 3. Próximos Passos & Sequência Didática

Slides da Aula
- Visualizar Apresentação Interativa
- Abrir Slides em Tela Cheia
Quiz de Fixação
- Testar Conhecimentos (10 Questões)
Exercícios Práticos
- Lista de Exercícios com Gabarito
Desafio de Projeto
- Especificação do Desafio Prático

Aula 20 - Projeto Capstone: Pipeline de ETL Textual Autônomo em Shell 🚀

Objetivo Pedagógico

Objetivo: Engenhar um pipeline autônomo de Extração, Transformação e Carga (ETL) inteiramente baseado em ferramentas Unix nativas (Bash, AWK, SED, Grep, Xargs e Curl), processando logs massivos, enriquecendo dados e gerando relatórios com total tolerância a falhas.

📑 1. Fundamentos Teóricos & Análise Técnica

O Projeto Capstone de Automação e Scripting demonstra o ápice de produtividade da plataforma Unix: construir soluções completas de engenharia de dados e infraestrutura sem o overhead de linguagens pesadas de runtime.

O pipeline de ETL Textual realiza as seguintes fases essenciais: 1. Extração (Extract): - Coleta de dados brutos provenientes de múltiplos arquivos de log comprimidos (.gz) utilizando zcat e streaming por pipes sem descompressão física em disco. 2. Transformação (Transform): - Normalização de timestamps para o padrão ISO-8601 com SED. - Filtragem de requisições de bots conhecidos e scrapers usando Grep com expressões regulares PCRE. - Cálculo de métricas e agregação de contadores por meio de programas AWK estruturados. 3. Carga e Notificação (Load): - Serialização dos dados transformados em formato JSON estruturado. - Despacho automatizado do relatório consolidado para um endpoint corporativo de auditoria via curl com retentativas exponenciais.

📐 Arquitetura Conceitual & Diagrama de Fluxo

graph TD
    Logs["Logs de Acesso Gzip (.log.gz)"] --> Stream["zcat (Streaming Sem Escrita)"]
    Stream --> SED["SED: Normalização de Timestamps & Paths"]
    SED --> Grep["Grep PCRE: Descarta Bots & Scrapers"]
    Grep --> AWK["AWK: Agrupamento Estatístico e Totais"]
    AWK --> JSON["Geração de Payload JSON Consolidado"]
    JSON --> Curl["cURL: Envio para API de Observabilidade"]
    style Logs fill:#e1f5fe,stroke:#01579b
    style SED fill:#fff3e0,stroke:#e65100
    style AWK fill:#f3e5f5,stroke:#7b1fa2
    style JSON fill:#e8f5e9,stroke:#2e7d32
    style Curl fill:#e0f2f1,stroke:#00695c

🔍 Pilares e Diretrizes Técnicas

Nesta unidade, aprofundamos os seguintes conceitos fundamentais: - Streaming I/O sem Arquivos Intermediários: Preservação da vida útil de discos SSD e eliminação de gargalos de I/O por uso de pipes anônimos na memória. - Tolerância a Falhas em Pipeline: Monitoramento rigoroso com set -o pipefail evitando propagação de erros parciais. - Paralelismo Seguro com xargs -P: Capacidade de processar múltiplos arquivos em paralelo utilizando todos os núcleos do processador. - Auditabilidade Total: Geração de logs de telemetria com carimbo de data/hora para auditoria das fases do ETL.

🛠️ 2. Implementação Prática em Engenharia de Dados em Shell, Automação Unix e Parsing

Abaixo está a implementação técnica de referência, estruturada com padrões de engenharia de software e foco em robustez:

// etl_textual_capstone.sh (Pipeline Completo de ETL Textual com Shell e AWK)
#!/usr/bin/env bash
set -euo pipefail

echo "=== [ETL CAPSTONE] Iniciando Pipeline Textual Autônomo ==="

# 1. Dados brutos de simulação
RAW_INPUT='2026-09-05 12:00:01|USER_101|STATUS:200|LATENCY:14ms
2026-09-05 12:00:02|USER_BOT|STATUS:403|LATENCY:2ms
2026-09-05 12:00:03|USER_102|STATUS:500|LATENCY:120ms
2026-09-05 12:00:04|USER_101|STATUS:200|LATENCY:18ms'

# 2. Execução do pipeline de transformação integrado via pipes
PROCESSED_JSON=$(echo "$RAW_INPUT" |     # Fase 1: Filtro com Grep (Elimina Bots)
    grep -v "USER_BOT" |     # Fase 2: Normalização com SED (Remove prefixo STATUS: e LATENCY:)
    sed -E 's/STATUS://g; s/LATENCY:([0-9]+)ms/\1/g' |     # Fase 3: Agrupamento e Geração JSON com AWK
    awk -F'|' '
    BEGIN {
        total_requests = 0
        total_errors = 0
        sum_latency = 0
    }
    {
        total_requests++
        status = $3
        lat = $4
        sum_latency += lat
        if (status >= 500) total_errors++
    }
    END {
        avg_lat = total_requests > 0 ? sum_latency / total_requests : 0
        printf "{\"total_requests\": %d, \"errors\": %d, \"avg_latency_ms\": %.2f}\n",                total_requests, total_errors, avg_lat
    }')

echo "Relatório JSON Gerado:"
echo "$PROCESSED_JSON"
echo "=== [ETL CAPSTONE] Pipeline Concluído com Sucesso Absoluto! ==="

💡 Análise Passo a Passo do Código

Uso de grep -v: Elimina ruídos e dados espúrios antes que eles cheguem aos estágios de parsing.
Normalização com sed -E: Limpa prefixos e converte unidades de tempo para números puros.
Geração Estruturada de JSON no AWK: Exporta dados formatados para consumo por qualquer API web contemporânea.

🎯 3. Próximos Passos & Sequência Didática

Slides da Aula
- Visualizar Apresentação Interativa
- Abrir Slides em Tela Cheia
Quiz de Fixação
- Testar Conhecimentos (10 Questões)
Exercícios Práticos
- Lista de Exercícios com Gabarito
Desafio de Projeto
- Especificação do Desafio Prático

Exercícios

🏋️ Exercícios do Curso

Lista completa das 20 unidades de exercicios organizadas em 5 módulos didáticos.

Módulo 1: Fundamentos (01 a 04) ---
Módulo 2: Conceitos Essenciais (05 a 08) ---
Módulo 3: Aplicação Prática (09 a 12) ---
Módulo 4: Padrões e Ferramentas (13 a 16) ---
Módulo 5: Avançado e Capstone (17 a 20) ---

Exercícios: Aula 01 – Introdução ao Regex 📝

Pratique os conceitos fundamentais de busca e identificação de padrões.

🟢 Nível Básico

1. Busca Literal Direta

No Regex101, utilize o texto abaixo: O aprendizado de Expressões Regulares é um diferencial para o programador moderno.

Tarefa: Crie um padrão que localize exatamente a palavra "programador".
Desafio Extra: Quantos matches ocorrem se você buscar apenas por "er"?

2. Identificação de Plataformas

Cite 3 ferramentas ou linguagens de programação que você utiliza no dia a dia que possuem suporte nativo para Regex. Como você acha que o Regex poderia ajudar no uso dessas ferramentas?

🟡 Nível Intermediário

3. Case Sensitivity na Prática

Utilize o texto: Regex, regex, REGEX, ReGeX.

Tarefa: Crie um padrão literal regex (minúsculo).
Ação: Ative e desative a flag i (ignore case) no seu testador. Explique o que acontece com o número de matches em cada estado.

4. Localizando Números Simples

No texto: Em 1970 surgiram as bases do Regex, e em 2024 ele continua essencial.

Tarefa: Tente encontrar o número "2024" usando apenas caracteres literais. O que acontece se você buscar por "20 24"?

🔴 Nível Desafio

5. O Primeiro Match Contextual

Imagine que você tem um arquivo de log com milhares de linhas como esta: 2024-10-21 14:30:05 - ERROR: Database connection failed.

Tarefa: Crie um padrão que localize apenas a palavra "ERROR".
Reflexão: Se o log tivesse a palavra "error" (minúscula), seu padrão funcionaria? Como garantir que ele pegue ambos sem usar flags? (Pense em como os conjuntos [] poderiam ajudar, mesmo sem tê-los estudado ainda).

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

### Questão 1: Busca Literal Direta **Resposta Comentada:** - **Fundamentação:** No contexto de **Introdução ao Regex**, o conceito abordado (Busca Literal Direta) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 2: Identificação de Plataformas **Resposta Comentada:** - **Fundamentação:** No contexto de **Introdução ao Regex**, o conceito abordado (Identificação de Plataformas) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 3: Case Sensitivity na Prática **Resposta Comentada:** - **Fundamentação:** No contexto de **Introdução ao Regex**, o conceito abordado (Case Sensitivity na Prática) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 4: Localizando Números Simples **Resposta Comentada:** - **Fundamentação:** No contexto de **Introdução ao Regex**, o conceito abordado (Localizando Números Simples) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 5: O Primeiro Match Contextual **Resposta Comentada:** - **Fundamentação:** No contexto de **Introdução ao Regex**, o conceito abordado (O Primeiro Match Contextual) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais.

Exercícios: Aula 02 – Estrutura Básica 🏗️

Aprofundando em buscas literais e sensibilidade de caixa.

🟢 Nível Básico

1. Buscando Marcas e Nomes

Texto: O iPhone, o iPad e o MacBook são produtos da Apple.

Tarefa: Localize a palavra Apple.
Questão: Se você buscar por apple, o match ocorre? Por que?

2. Espaços e Símbolos

Texto: Preço: R$ 50,00 | Desconto: 10%

Tarefa: Tente dar match exatamente em R$ 50,00.
Atenção: Lembre-se que espaços contam como caracteres!

🟡 Nível Intermediário

3. Palavras Combinadas

Texto: O curso de Regex é excelente. Eu amo regex!

Tarefa: Crie um padrão que encontre as duas ocorrências da palavra "regex", independente de ser maiúscula ou minúscula, utilizando a flag i.

4. Filtro de Substrings

Texto: casa, casarão, casado, casulo.

Tarefa: Busque pela palavra literal casa.
Observação: Quantos matches você obteve? Ele pegou partes de outras palavras ou apenas a palavra isolada? Por que isso acontece no Regex literal?

🔴 Nível Desafio

5. Simulando um Finder

Crie uma lista de 10 nomes de arquivos fictícios (ex: foto.jpg, relatorio.pdf, musica.mp3).

Tarefa: Crie um Regex literal para encontrar todos os arquivos que terminam em .jpg.
Reflexão: Como você faria para encontrar arquivos .JPG e .jpg ao mesmo tempo sem usar flags?

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

### Questão 1: Buscando Marcas e Nomes **Resposta Comentada:** - **Fundamentação:** No contexto de **Estrutura Básica de uma Expressão Regular ️**, o conceito abordado (Buscando Marcas e Nomes) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 2: Espaços e Símbolos **Resposta Comentada:** - **Fundamentação:** No contexto de **Estrutura Básica de uma Expressão Regular ️**, o conceito abordado (Espaços e Símbolos) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 3: Palavras Combinadas **Resposta Comentada:** - **Fundamentação:** No contexto de **Estrutura Básica de uma Expressão Regular ️**, o conceito abordado (Palavras Combinadas) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 4: Filtro de Substrings **Resposta Comentada:** - **Fundamentação:** No contexto de **Estrutura Básica de uma Expressão Regular ️**, o conceito abordado (Filtro de Substrings) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 5: Simulando um Finder **Resposta Comentada:** - **Fundamentação:** No contexto de **Estrutura Básica de uma Expressão Regular ️**, o conceito abordado (Simulando um Finder) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais.

Exercícios: Aula 03 – Metacaracteres Fundamentais 🔣

Dominando o ponto, classes de caracteres e o escape.

🟢 Nível Básico

1. Uso do Coringa

Texto: pato, pelo, polo, pulo, p8lo.

Tarefa: Crie um padrão usando o ponto . que localize todas essas palavras de 4 letras que começam com 'p' e terminam com 'lo' ou 'to'.
Padrão sugerido: p.lo (Veja quais ele ignora).

2. Localizando Números

Texto: O código do produto é 948 e o lote é o 002.

Tarefa: Use o metacaractere \d para encontrar todos os dígitos isoladamente. Quantos matches você encontrou no total?

🟡 Nível Intermediário

3. O Desafio do Espaço

Texto: Nome: Ricardo Pires | Idade: 30

Tarefa: Crie um padrão que utilize \s para encontrar os espaços entre o nome e o sobrenome, e entre a idade e o número.

4. Alfanuméricos e Underline

Texto: user_01, admin-02, guest_v3.

Tarefa: Use \w para encontrar os caracteres.
Questão: O \w deu match no hífen - do admin-02? Por que?

🔴 Nível Desafio

5. Endereços de IP e o Escape

Texto: O servidor DNS é 8.8.8.8 e o gateway é 192.168.1.1.

Tarefa: Crie um Regex que localize exatamente o IP 8.8.8.8.
Importante: Se você usar 8.8.8.8 sem o escape, seu padrão também encontraria 8A8B8C8? Prove isso no Regex101.
Dica: Use \ antes de cada ponto.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

### Questão 1: Uso do Coringa **Resposta Comentada:** - **Fundamentação:** No contexto de **Metacaracteres Fundamentais**, o conceito abordado (Uso do Coringa) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 2: Localizando Números **Resposta Comentada:** - **Fundamentação:** No contexto de **Metacaracteres Fundamentais**, o conceito abordado (Localizando Números) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 3: O Desafio do Espaço **Resposta Comentada:** - **Fundamentação:** No contexto de **Metacaracteres Fundamentais**, o conceito abordado (O Desafio do Espaço) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 4: Alfanuméricos e Underline **Resposta Comentada:** - **Fundamentação:** No contexto de **Metacaracteres Fundamentais**, o conceito abordado (Alfanuméricos e Underline) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 5: Endereços de IP e o Escape **Resposta Comentada:** - **Fundamentação:** No contexto de **Metacaracteres Fundamentais**, o conceito abordado (Endereços de IP e o Escape) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais.

Exercícios: Aula 04 – Conjuntos de Caracteres 📦

Praticando com intervalos, colchetes e negação.

🟢 Nível Básico

1. Seleção de Vogais

Texto: As nuvens se movem rapidamente pelo céu azul.

Tarefa: Crie um padrão que localize todas as vogais (maiúsculas e minúsculas) usando um único conjunto.

2. Intervalos Numéricos

Texto: O preço subiu de 250 para 380 em apenas 5 dias.

Tarefa: Use o intervalo [0-9] para destacar todos os números. Existe diferença se você usar \d?

🟡 Nível Intermediário

3. Letras e a Negação

Texto: ID: AB-1234 | Status: OK

Tarefa: Use a negação [^a-zA-Z] para encontrar tudo o que NÃO é uma letra.
Reflexão: O que o Regex encontrou? (Espaços, números e símbolos).

4. Intervalos Customizados

Texto: A nota foi A+, a outra foi C e a última foi F-.

Tarefa: Crie um conjunto que localize apenas as notas de 'A' até 'C'. Ignore 'F'.

🔴 Nível Desafio

5. Filtrando Senhas Simples

Imagine que uma senha deve ter 4 caracteres, onde todos são obrigatoriamente letras minúsculas entre 'a' e 'f', ou números entre '1' e '5'.

Tarefa: Crie o padrão Regex para validar essa regra (dica: repita o conjunto 4 vezes ou tente adivinhar como simplificar).
Teste com: abcd, 1234, af15, gh78 (estes dois últimos devem falhar).

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

### Questão 1: Seleção de Vogais **Resposta Comentada:** - **Fundamentação:** No contexto de **Conjuntos de Caracteres**, o conceito abordado (Seleção de Vogais) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 2: Intervalos Numéricos **Resposta Comentada:** - **Fundamentação:** No contexto de **Conjuntos de Caracteres**, o conceito abordado (Intervalos Numéricos) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 3: Letras e a Negação **Resposta Comentada:** - **Fundamentação:** No contexto de **Conjuntos de Caracteres**, o conceito abordado (Letras e a Negação) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 4: Intervalos Customizados **Resposta Comentada:** - **Fundamentação:** No contexto de **Conjuntos de Caracteres**, o conceito abordado (Intervalos Customizados) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 5: Filtrando Senhas Simples **Resposta Comentada:** - **Fundamentação:** No contexto de **Conjuntos de Caracteres**, o conceito abordado (Filtrando Senhas Simples) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais.

Exercícios: Aula 05 – Quantificadores 🔢

Praticando a repetição de padrões e o comportamento guloso vs. preguiçoso.

🟢 Nível Básico

1. O Poder do +

Texto: aaaaa bbb c dddddddd

Tarefa: Use a+ para pegar todos os 'a's de uma vez só em um único match. Faça o mesmo para as outras letras.

2. Opcionais

Texto: O arquivo pode ser foto.jpg ou imagem.jpeg.

Tarefa: Crie um padrão para capturar a extensão, onde o 'e' de jpeg seja opcional. (Dica: Use jpe?g).

🟡 Nível Intermediário

3. Quantidade Exata

Texto: Código: 123456 | Serial: AB9876

Tarefa: Use \d{6} para encontrar apenas o código numérico de 6 dígitos.

4. Intervalos de Repetição

Texto: O nome do usuário deve ter de 3 a 5 letras.

Tarefa: Crie um padrão que valide palavras compostas apenas por letras (\w ou [a-z]) que tenham entre 3 e 5 caracteres.

🔴 Nível Desafio

5. Fugindo da "Gulodice"

Texto: O link é <a href="https://example.com">Example</a> e o outro é <a href="https://example.org">Org</a>.

Tarefa: Crie um padrão para capturar o conteúdo dentro de href="...".
Desafio: Tente usar href=".*" primeiro e veja o erro (ele pegará até o final da linha). Depois, use o quantificador preguiçoso href=".*?" para corrigir.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

### Questão 1: O Poder do + **Resposta Comentada:** - **Fundamentação:** No contexto de **Quantificadores**, o conceito abordado (O Poder do +) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 2: Opcionais **Resposta Comentada:** - **Fundamentação:** No contexto de **Quantificadores**, o conceito abordado (Opcionais) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 3: Quantidade Exata **Resposta Comentada:** - **Fundamentação:** No contexto de **Quantificadores**, o conceito abordado (Quantidade Exata) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 4: Intervalos de Repetição **Resposta Comentada:** - **Fundamentação:** No contexto de **Quantificadores**, o conceito abordado (Intervalos de Repetição) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 5: Fugindo da "Gulodice" **Resposta Comentada:** - **Fundamentação:** No contexto de **Quantificadores**, o conceito abordado (Fugindo da "Gulodice") é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais.

Exercícios: Aula 06 – Âncoras ⚓

Fixando a posição da busca com início e fim de linha.

🟢 Nível Básico

1. Início de Frase

Texto: Erro: Falha na conexão. Sistema em Erro.

Tarefa: Crie um padrão que localize a palavra "Erro" apenas se ela estiver no início da frase.

2. Extensões de Arquivos

Texto: indice.html, estilo.css, script.js, backup.html.old

Tarefa: Use o $ para encontrar apenas os arquivos que terminam exatamente com .html.
Desafio: O seu padrão pegou o backup.html.old? (Não deveria!).

🟡 Nível Intermediário

3. Validação de Linha Exclusiva

Texto:

12345
abcde
123
123456

Tarefa: Crie um Regex que aceite apenas linhas que contenham exatamente 5 dígitos (nem mais, nem menos). Use ^ e $.

4. Começa e Termina

Texto: A01, B02, C03, A04X

Tarefa: Localize códigos que começam com 'A' e terminam com um número.
Dica: Use ^A\d+$ (em testes de linha única no Regex101).

🔴 Nível Desafio

5. O Modo Multiline

Texto:

http://site.com
https://google.com
ftp://servidor.net

Tarefa: No Regex101, ative a flag m (multiline). Crie um padrão que localize apenas as linhas que começam com https.
Reflexão: O que muda se você desativar a flag m?

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

### Questão 1: Início de Frase **Resposta Comentada:** - **Fundamentação:** No contexto de **Âncoras ⚓**, o conceito abordado (Início de Frase) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 2: Extensões de Arquivos **Resposta Comentada:** - **Fundamentação:** No contexto de **Âncoras ⚓**, o conceito abordado (Extensões de Arquivos) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 3: Validação de Linha Exclusiva **Resposta Comentada:** - **Fundamentação:** No contexto de **Âncoras ⚓**, o conceito abordado (Validação de Linha Exclusiva) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 4: Começa e Termina **Resposta Comentada:** - **Fundamentação:** No contexto de **Âncoras ⚓**, o conceito abordado (Começa e Termina) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 5: O Modo Multiline **Resposta Comentada:** - **Fundamentação:** No contexto de **Âncoras ⚓**, o conceito abordado (O Modo Multiline) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais.

Exercícios: Aula 07 – Agrupamentos e Captura 🎯

Trabalhando com parênteses, grupos e referências.

🟢 Nível Básico

1. Agrupando Repetições

Texto: ha ha ha haaaaa!

Tarefa: Use parênteses para agrupar o padrão (ha ) e adicione um quantificador para encontrar as repetições de "ha ".

2. Captura Simples

Texto: Nome: Ricardo | Sobrenome: Pires

Tarefa: Crie dois grupos de captura: um para o nome e outro para o sobrenome. Verifique no painel do Regex101 se os grupos 1 e 2 contêm os valores corretos.

🟡 Nível Intermediário

3. Extraindo Dados de Logs

Texto: [2024-10-21] INFO: Servidor iniciado.

Tarefa: Crie um padrão que capture apenas a data dentro dos colchetes em um grupo, e o nível do log (INFO) em outro grupo.

4. Referências Internas (Backreferences)

Texto: O código secreto é 123-123. O outro é 456-789.

Tarefa: Crie um Regex que identifique padrões onde o número antes do hífen seja igual ao número depois do hífen.
Dica: Use (\d{3})-\1.

🔴 Nível Desafio

5. Reorganizando Datas

Texto: 2024-12-25 (Formato AAAA-MM-DD)

Tarefa: Crie três grupos de captura para Ano, Mês e Dia.
Desafio: Imagine que você quer transformar isso para o formato brasileiro DD/MM/AAAA. Como você faria a substituição usando $1, $2 e $3? (Apenas descreva ou teste na aba "Substitution" do Regex101).

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

### Questão 1: Agrupando Repetições **Resposta Comentada:** - **Fundamentação:** No contexto de **Agrupamentos e Captura**, o conceito abordado (Agrupando Repetições) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 2: Captura Simples **Resposta Comentada:** - **Fundamentação:** No contexto de **Agrupamentos e Captura**, o conceito abordado (Captura Simples) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 3: Extraindo Dados de Logs **Resposta Comentada:** - **Fundamentação:** No contexto de **Agrupamentos e Captura**, o conceito abordado (Extraindo Dados de Logs) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 4: Referências Internas (Backreferences) **Resposta Comentada:** - **Fundamentação:** No contexto de **Agrupamentos e Captura**, o conceito abordado (Referências Internas (Backreferences)) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 5: Reorganizando Datas **Resposta Comentada:** - **Fundamentação:** No contexto de **Agrupamentos e Captura**, o conceito abordado (Reorganizando Datas) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais.

Exercícios: Aula 08 – Alternância 🔀

Praticando o uso do "OU" e a prioridade de padrões.

🟢 Nível Básico

1. Seleção Simples

Texto: O gato dormiu no tapete, mas o cachorro preferiu o sofá.

Tarefa: Crie um padrão que localize as palavras "gato" ou "cachorro".

2. Opções de Arquivos

Texto: projeto.html, estilo.css, script.js

Tarefa: Crie um Regex que identifique se o arquivo tem extensão .html ou .js.

🟡 Nível Intermediário

3. Alternância com Agrupamento

Texto: Eu gosto de café. Você gosta de chá?

Tarefa: Use parênteses para agrupar as opções de bebida: gosta de (café|chá).
Reflexão: O que acontece se você remover os parênteses e deixar gosta de café|chá?

4. Prioridade de Match

Texto: super, supercomputador

Tarefa: Tente dar match em supercomputador|super e depois em super|supercomputador. Como o Regex se comporta no segundo caso ao encontrar a palavra longa?

🔴 Nível Desafio

5. Validando Respostas curtas

Texto: Resposta: Sim, Resposta: Não, Resposta: Talvez

Tarefa: Crie um padrão que capture apenas o que vem depois de "Resposta: " se for as palavras "Sim" ou "Não". Ignore "Talvez".
Dica: Use Resposta:\s(Sim|Não).
Extra: Como você faria para aceitar "S" ou "N" também?

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

### Questão 1: Seleção Simples **Resposta Comentada:** - **Fundamentação:** No contexto de **Alternância**, o conceito abordado (Seleção Simples) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 2: Opções de Arquivos **Resposta Comentada:** - **Fundamentação:** No contexto de **Alternância**, o conceito abordado (Opções de Arquivos) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 3: Alternância com Agrupamento **Resposta Comentada:** - **Fundamentação:** No contexto de **Alternância**, o conceito abordado (Alternância com Agrupamento) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 4: Prioridade de Match **Resposta Comentada:** - **Fundamentação:** No contexto de **Alternância**, o conceito abordado (Prioridade de Match) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 5: Validando Respostas curtas **Resposta Comentada:** - **Fundamentação:** No contexto de **Alternância**, o conceito abordado (Validando Respostas curtas) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais.

Exercícios: Aula 09 – Modificadores (Flags) 🚩

Aprendendo a controlar o comportamento global do motor Regex.

🟢 Nível Básico

1. Ignorando a Caixa

Texto: Maçã, maçã, MAÇÃ

Tarefa: Use o padrão maçã com a flag i para encontrar todas as variações.

2. Match Global

Texto: um peixe, dois peixes, três peixes

Tarefa: Busque pela palavra peixe sem a flag g e depois com ela. Qual a diferença no número de matches?

🟡 Nível Intermediário

3. Ponto Total (DotAll)

Texto:

Início do parágrafo.
Continuação na linha de baixo.

Tarefa: Crie um padrão que tente capturar tudo o que começa em "Início" e termina em "baixo".
Desafio: Funciona sem a flag s? Por que o ponto . precisa dela aqui?

4. Multiline vs Global

Texto:

# Título 1
# Título 2
Conteúdo

Tarefa: Use ^# com as flags g e m para encontrar todos os títulos que começam com #. O que acontece se remover a flag m?

🔴 Nível Desafio

5. Combinação Poderosa

Utilize o Regex101.

Tarefa: Crie um Regex que localize links http ou https em um texto com várias linhas, ignorando se o protocolo está em maiúscula ou minúscula.
Dica: Use as flags /gi/.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

### Questão 1: Ignorando a Caixa **Resposta Comentada:** - **Fundamentação:** No contexto de **Modificadores (Flags)**, o conceito abordado (Ignorando a Caixa) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 2: Match Global **Resposta Comentada:** - **Fundamentação:** No contexto de **Modificadores (Flags)**, o conceito abordado (Match Global) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 3: Ponto Total (DotAll) **Resposta Comentada:** - **Fundamentação:** No contexto de **Modificadores (Flags)**, o conceito abordado (Ponto Total (DotAll)) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 4: Multiline vs Global **Resposta Comentada:** - **Fundamentação:** No contexto de **Modificadores (Flags)**, o conceito abordado (Multiline vs Global) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 5: Combinação Poderosa **Resposta Comentada:** - **Fundamentação:** No contexto de **Modificadores (Flags)**, o conceito abordado (Combinação Poderosa) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais.

Exercícios: Aula 10 – Regex com JavaScript 📜

Aplicando Regex no ecossistema Web.

🟢 Nível Básico

1. Validação de Booleano

Tarefa: Crie um script em JavaScript que use o método .test() para validar se uma string contém apenas números.
Teste com: "12345" (true) e "123a45" (false).

2. Busca de Palavras

Tarefa: Dado o texto "JavaScript é incrível", use .match() para encontrar a palavra "JavaScript".

🟡 Nível Intermediário

3. Substituição de Padrões

Tarefa: Use o método .replace() para mascarar os 4 últimos dígitos de um cartão de crédito: "4555.2222.1111". Transforme em "4555.2222.****".
Dica: Use o quantificador {4}$.

4. Extração Global

Tarefa: Extraia todas as palavras que começam com a letra "R" da frase: "Regex é Rápido, Robusto e Real". Use a flag gi.

🔴 Nível Desafio

5. Validador de Senha

Tarefa: Crie uma função validarSenha(senha) que retorne true apenas se a senha tiver:
No mínimo 8 caracteres.
Pelo menos um número.
Pelo menos uma letra maiúscula.
Dica: Você pode usar múltiplos .test() ou tentar uma expressão regular avançada única.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

### Questão 1: Validação de Booleano **Resposta Comentada:** - **Fundamentação:** No contexto de **Regex na Prática com JavaScript**, o conceito abordado (Validação de Booleano) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 2: Busca de Palavras **Resposta Comentada:** - **Fundamentação:** No contexto de **Regex na Prática com JavaScript**, o conceito abordado (Busca de Palavras) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 3: Substituição de Padrões **Resposta Comentada:** - **Fundamentação:** No contexto de **Regex na Prática com JavaScript**, o conceito abordado (Substituição de Padrões) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 4: Extração Global **Resposta Comentada:** - **Fundamentação:** No contexto de **Regex na Prática com JavaScript**, o conceito abordado (Extração Global) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 5: Validador de Senha **Resposta Comentada:** - **Fundamentação:** No contexto de **Regex na Prática com JavaScript**, o conceito abordado (Validador de Senha) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais.

Exercícios: Aula 11 – Regex com Python 🐍

Utilizando a biblioteca re para manipulação de dados.

🟢 Nível Básico

1. Busca Simples

Tarefa: Escreva um código Python que use re.search() para verificar se a string "Sucesso!" termina com um ponto de exclamação.

2. Listagem de Números

Tarefa: Dada a string "Código: 123, ID: 456, Ref: 789", use re.findall() para obter uma lista com apenas os números.

🟡 Nível Intermediário

3. Limpeza de Logs

Tarefa: Use re.sub() para remover a data (formato YYYY-MM-DD) de uma linha de log: "2024-10-21 - Erro no sistema". O resultado deve ser apenas "- Erro no sistema".

4. Grupos de Match

Tarefa: Use re.search() com parênteses para capturar separadamente o DDD e o número de um telefone: "(11) 98888-7777". Imprima cada grupo separadamente.

🔴 Nível Desafio

5. Analisador de Caminhos (Paths)

Tarefa: Crie um script que receba um caminho de arquivo como "/home/usuario/documentos/foto.png" e use Regex para extrair apenas o nome do arquivo (foto.png) e apenas a extensão (png).
Dica: Use âncoras de fim de linha $ e classes de caracteres negadas.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

### Questão 1: Busca Simples **Resposta Comentada:** - **Fundamentação:** No contexto de **Regex com Python**, o conceito abordado (Busca Simples) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 2: Listagem de Números **Resposta Comentada:** - **Fundamentação:** No contexto de **Regex com Python**, o conceito abordado (Listagem de Números) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 3: Limpeza de Logs **Resposta Comentada:** - **Fundamentação:** No contexto de **Regex com Python**, o conceito abordado (Limpeza de Logs) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 4: Grupos de Match **Resposta Comentada:** - **Fundamentação:** No contexto de **Regex com Python**, o conceito abordado (Grupos de Match) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 5: Analisador de Caminhos (Paths) **Resposta Comentada:** - **Fundamentação:** No contexto de **Regex com Python**, o conceito abordado (Analisador de Caminhos (Paths)) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais.

Exercícios: Aula 12 – Validação de Dados Reais ✅

Praticando a validação de formatos comuns do dia a dia.

🟢 Nível Básico

1. CEP Brasileiro

Tarefa: Crie um Regex que valide um CEP no formato 00000-000.
Teste com: 04101-000 (✅) e 04101000 (❌).

2. Formato de Data

Tarefa: Crie um padrão que valide uma data no formato DD/MM/AAAA.
Dica: Use \d{2}/\d{2}/\d{4}.

🟡 Nível Intermediário

3. Validação de CPF Flexível

Tarefa: Crie um Regex que valide um CPF, aceitando tanto o formato com pontos e traço (123.456.789-00) quanto apenas números (12345678900).
Dica: Use o ponto de interrogação ? para tornar os separadores opcionais.

4. Horário em 24h

Tarefa: Crie um Regex que valide um horário entre 00:00 e 23:59.
Dica: O primeiro dígito pode ser [01] seguido de qualquer número, OU 2 seguido de [0-3].

🔴 Nível Desafio

5. Validador de E-mail Corporativo

Tarefa: Crie um Regex que valide apenas e-mails que pertençam ao domínio @empresa.com.br.
Atenção: Garante que não haja nada antes ou depois do e-mail na linha.
Teste com: joao@empresa.com.br (✅), joao@gmail.com (❌), contato@empresa.com.br.suporte (❌).

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

### Questão 1: CEP Brasileiro **Resposta Comentada:** - **Fundamentação:** No contexto de **Validação de Dados Reais ✅**, o conceito abordado (CEP Brasileiro) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 2: Formato de Data **Resposta Comentada:** - **Fundamentação:** No contexto de **Validação de Dados Reais ✅**, o conceito abordado (Formato de Data) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 3: Validação de CPF Flexível **Resposta Comentada:** - **Fundamentação:** No contexto de **Validação de Dados Reais ✅**, o conceito abordado (Validação de CPF Flexível) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 4: Horário em 24h **Resposta Comentada:** - **Fundamentação:** No contexto de **Validação de Dados Reais ✅**, o conceito abordado (Horário em 24h) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 5: Validador de E **Resposta Comentada:** - **Fundamentação:** No contexto de **Validação de Dados Reais ✅**, o conceito abordado (Validador de E) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais.

Exercícios: Aula 13 – Extração de Dados ⛏️

Praticando a captura seletiva de informações em textos complexos.

🟢 Nível Básico

1. Pegando Números de uma String

Texto: O pedido #123 foi faturado por R$ 450.

Tarefa: Extraia todos os números (separadamente) desse texto.

2. Buscando Menções

Texto: Fale com @ricardo ou @ana sobre o projeto.

Tarefa: Crie um Regex para extrair todas as menções que começam com @.

🟡 Nível Intermediário

3. Extraindo apenas o Domínio

Texto: Links úteis: https://google.com, http://github.io, https://regex101.com

Tarefa: Use um grupo de captura para extrair apenas o domínio (ex: google.com), sem o protocolo https://.

4. Localizando IDs de Produtos

Texto: Produtos: [ID:101], [ID:202], [ID:303]

Tarefa: Extraia apenas os números dos IDs que estão dentro dos colchetes.

🔴 Nível Desafio

5. Crawler de Imagens

Texto: <img src="foto1.jpg"> <img src="banners/logo.png"> <img src="https://site.com/avatar.gif">

Tarefa: Crie um Regex que extraia apenas o caminho da imagem (o conteúdo dentro de src="...").
Desafio Extra: No seu teste, ele deve capturar foto1.jpg, banners/logo.png e a URL completa do avatar.

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

### Questão 1: Pegando Números de uma String **Resposta Comentada:** - **Fundamentação:** No contexto de **Extração de Dados ⛏️**, o conceito abordado (Pegando Números de uma String) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 2: Buscando Menções **Resposta Comentada:** - **Fundamentação:** No contexto de **Extração de Dados ⛏️**, o conceito abordado (Buscando Menções) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 3: Extraindo apenas o Domínio **Resposta Comentada:** - **Fundamentação:** No contexto de **Extração de Dados ⛏️**, o conceito abordado (Extraindo apenas o Domínio) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 4: Localizando IDs de Produtos **Resposta Comentada:** - **Fundamentação:** No contexto de **Extração de Dados ⛏️**, o conceito abordado (Localizando IDs de Produtos) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 5: Crawler de Imagens **Resposta Comentada:** - **Fundamentação:** No contexto de **Extração de Dados ⛏️**, o conceito abordado (Crawler de Imagens) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais.

Exercícios: Aula 14 – Limpeza e Transformação 🧼

Praticando a modificação e o tratamento de strings.

🟢 Nível Básico

1. Limpeza de Espaços

Texto: Olá Mundo!

Tarefa: Crie um Regex que remova todos os espaços em branco do início e do fim dessa string.

2. Substituição Simples

Texto: O custo é de 100 reais e o frete 20 reais.

Tarefa: Troque todas as ocorrências de "reais" pelo símbolo "R$".

🟡 Nível Intermediário

3. Criando Slugs de URL

Texto: Como aprender Regex rápido

Tarefa: Transforme esse título em um slug de URL amigável: como-aprender-regex-rapido.
Passos:
1. Transforme espaços em hífens -.
2. Converta tudo para minúsculo (via código JS ou Python).

4. Mudando Formato de Telefone

Texto: 1199998888 (Apenas números)

Tarefa: Use grupos de captura para transformar esse texto no formato (11) 9999-8888.
Substituição: ($1) $2-$3.

🔴 Nível Desafio

5. Limpador de Tags XML/HTML

Texto: <div>Conteúdo <b>Importante</b></div>

Tarefa: Crie um Regex que remova todas as tags HTML e retorne apenas o texto puro: Conteúdo Importante.
Desafio: Garanta que o Regex funcione com qualquer tag (div, b, p, etc).

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

### Questão 1: Limpeza de Espaços **Resposta Comentada:** - **Fundamentação:** No contexto de **Limpeza e Transformação**, o conceito abordado (Limpeza de Espaços) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 2: Substituição Simples **Resposta Comentada:** - **Fundamentação:** No contexto de **Limpeza e Transformação**, o conceito abordado (Substituição Simples) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 3: Criando Slugs de URL **Resposta Comentada:** - **Fundamentação:** No contexto de **Limpeza e Transformação**, o conceito abordado (Criando Slugs de URL) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 4: Mudando Formato de Telefone **Resposta Comentada:** - **Fundamentação:** No contexto de **Limpeza e Transformação**, o conceito abordado (Mudando Formato de Telefone) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 5: Limpador de Tags XML/HTML **Resposta Comentada:** - **Fundamentação:** No contexto de **Limpeza e Transformação**, o conceito abordado (Limpador de Tags XML/HTML) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais.

Exercícios: Aula 15 – Desempenho e Boas Práticas ⚡

Refatorando expressões para torná-las mais eficientes e seguras.

🟢 Nível Básico

1. Otimizando Alternância

Padrão Original: (segunda|terça|quarta|quinta|sexta)

Tarefa: Se você não precisar extrair o dia da semana depois, apenas verificar se existe, como você transformaria esse grupo para economizar memória?

2. Substituindo o Coringa

Padrão Original: .* (para encontrar um número de 5 dígitos)

Tarefa: Reescreva esse padrão para ser mais específico e performático.

🟡 Nível Intermediário

3. Proteção contra Ataques (ReDoS)

Padrão Original: (a+)+c

Tarefa: Analise por que esse padrão é perigoso em textos que contêm muitos 'a's mas não terminam em 'c'. Como você o recreveria de forma simples para pegar uma sequência de letras 'a' seguida de 'c'?

4. Uso de Âncoras para Velocidade

Tarefa: Explique por que o padrão ^\d{5}$ é processado mais rápido por um motor de busca do que \d{5} em uma string que começa com letras.

🔴 Nível Desafio

5. Auditoria de Validador

Imagine o seguinte Regex para validar um nome de pessoa: ^[a-zA-Z\s]*$

Questões:
1. O que acontece se o usuário enviar uma string vazia? (O * permite isso).
2. Como você alteraria para exigir ao menos 2 letras?
3. Como você limitaria o tamanho máximo para 50 caracteres para evitar processamento abusivo?

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

### Questão 1: Otimizando Alternância **Resposta Comentada:** - **Fundamentação:** No contexto de **Desempenho e Boas Práticas ⚡**, o conceito abordado (Otimizando Alternância) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 2: Substituindo o Coringa **Resposta Comentada:** - **Fundamentação:** No contexto de **Desempenho e Boas Práticas ⚡**, o conceito abordado (Substituindo o Coringa) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 3: Proteção contra Ataques (ReDoS) **Resposta Comentada:** - **Fundamentação:** No contexto de **Desempenho e Boas Práticas ⚡**, o conceito abordado (Proteção contra Ataques (ReDoS)) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 4: Uso de Âncoras para Velocidade **Resposta Comentada:** - **Fundamentação:** No contexto de **Desempenho e Boas Práticas ⚡**, o conceito abordado (Uso de Âncoras para Velocidade) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 5: Auditoria de Validador **Resposta Comentada:** - **Fundamentação:** No contexto de **Desempenho e Boas Práticas ⚡**, o conceito abordado (Auditoria de Validador) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais.

Exercícios: Aula 16 – Revisão Geral e Desafios 🏁

Parabéns por chegar ao fim! Estes exercícios revisam os tópicos mais complexos do curso.

🟢 Nível Básico

1. Busca Localizada

Tarefa: Crie um Regex que encontre a palavra "Regex" apenas se ela estiver no início da frase.
Teste com: "Regex é legal" (✅) e "O curso de Regex" (❌).

2. Formato de Versão

Tarefa: Valide uma versão de software no formato v1.2.3.
Dica: Use v\d\.\d\.\d.

🟡 Nível Intermediário

3. Extração de Conteúdo de Tags

Texto: <h1 id="titulo">Bem-vindo ao Curso</h1>

Tarefa: Use um grupo de captura para extrair apenas o texto "Bem-vindo ao Curso".
Desafio: Tente extrair também o valor do ID (titulo) em outro grupo.

4. Limpeza de Logins de Usuários

Texto: usuario_01, usuario_02, USER_03, admin

Tarefa: Use Regex para extrair apenas os usuários que terminam com _01, _02 ou _03.

🔴 Nível Desafio

5. Validador de Senha Completo

Tarefa: Crie um script (JS ou Python) que valide se uma senha:
Tem no mínimo 8 caracteres.
Tem pelo menos uma Letra Maiúscula.
Tem pelo menos uma Letra Minúscula.
Tem pelo menos um Número.
Tem pelo menos um Caractere Especial (!@#$%*).
Dica: No nível básico, você pode usar 5 Regex separados para validar cada regra!

📚 Gabarito e Soluções Comentadas

Gabarito Explicado

### Questão 1: Busca Localizada **Resposta Comentada:** - **Fundamentação:** No contexto de **Projeto Final: O Grande Desafio**, o conceito abordado (Busca Localizada) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 2: Formato de Versão **Resposta Comentada:** - **Fundamentação:** No contexto de **Projeto Final: O Grande Desafio**, o conceito abordado (Formato de Versão) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 3: Extração de Conteúdo de Tags **Resposta Comentada:** - **Fundamentação:** No contexto de **Projeto Final: O Grande Desafio**, o conceito abordado (Extração de Conteúdo de Tags) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 4: Limpeza de Logins de Usuários **Resposta Comentada:** - **Fundamentação:** No contexto de **Projeto Final: O Grande Desafio**, o conceito abordado (Limpeza de Logins de Usuários) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais. ### Questão 5: Validador de Senha Completo **Resposta Comentada:** - **Fundamentação:** No contexto de **Projeto Final: O Grande Desafio**, o conceito abordado (Validador de Senha Completo) é essencial para assegurar que os requisitos do sistema sejam estruturados de forma padronizada e escalável. - **Justificativa Técnica:** A abordagem recomendada prioriza baixo acoplamento, alta coesão e facilidade de manutenção em ambientes de produção, evitando retrabalho e inconsistências operacionais.

Projetos

🚀 Projetos do Curso

Lista completa das 20 unidades de projetos organizadas em 5 módulos didáticos.

Módulo 1: Fundamentos (01 a 04) ---
Módulo 2: Conceitos Essenciais (05 a 08) ---
Módulo 3: Aplicação Prática (09 a 12) ---
Módulo 4: Padrões e Ferramentas (13 a 16) ---
Módulo 5: Avançado e Capstone (17 a 20) ---

Projeto 01 - Identificador de Padrões Iniciais 🔍

O Desafio 🎯

Você precisa criar seu primeiro motor de busca seletiva.

Objetivo: Identificar palavras específicas em um texto literário.

Cenário

A empresa "BuscaFácil" quer filtrar ocorrências de nomes próprios que comecem com a letra 'R'.

Requisitos

Use o padrão R\w+.
Teste contra uma lista de nomes: Ricardo, Ana, Roberto, Sofia, Renan.
Crie um script simples em JS ou Python que filtre esses nomes.

Entrega 📦

O código do padrão Regex.
A lista de nomes filtrados.

Projeto 02 - Validador de Códigos de Cupom 🗃️

O Desafio 🎯

Criar um validador para cupons de desconto de uma loja online.

Objetivo: Garantir que o cupom siga a regra da empresa.

Requisitos

O cupom deve ter 5 letras maiúsculas.
Seguido por 2 números.
Exemplo: DESCO10, BLACK20.

Entrega 📦

O Regex usado (Dica: Use âncoras e quantificadores).

Projeto 03 - Filtro de Comentários de Código 💬

O Desafio 🎯

Limpar arquivos de código-fonte removendo comentários de linha única.

Objetivo: Reduzir o tamanho do arquivo final.

Requisitos

Identificar qualquer linha que comece com //.
O Regex deve capturar a barra e todo o resto da linha.

Entrega 📦

O padrão Regex e um exemplo de antes/depois.

Projeto 04 - Extrator de Datas de Relatórios 📅

O Desafio 🎯

Você recebeu um PDF convertido para texto e precisa listar todas as datas mencionadas.

Objetivo: Criar um cronograma automático de eventos.

Requisitos

Capturar datas no formato DD/MM/AAAA.
Ignorar datas mal formadas.

Entrega 📦

O script re.findall() em Python ou .match() em JavaScript.

Projeto 05 - Mascarador de Telefones 📵

O Desafio 🎯

Ocultar parte do número de telefone de clientes para proteger a privacidade.

Objetivo: Transformar (11) 98888-7777 em (11) *****-7777.

Requisitos

Identificar o bloco central do número.
Usar grupos de captura.
Substituir os dígitos centrais por asteriscos.

Entrega 📦

O padrão de busca e o padrão de substituição.

Projeto 06 - Mineirador de Hashtags 🏷️

O Desafio 🎯

Extrair todas as hashtags de um post de rede social para análise de tendências.

Objetivo: Criar uma lista de tópicos mencionados.

Requisitos

Capturar palavras que começam com #.
Ignorar o símbolo # no resultado final (usar grupos).

Entrega 📦

A lista de hashtags extraídas de um texto de exemplo.

Projeto 07 - Validador de Senhas Simples 🔑

O Desafio 🎯

Verificar se uma senha atende ao requisito mínimo de conter letras e números.

Objetivo: Implementar a primeira camada de segurança de um site.

Requisitos

Pelo menos 6 caracteres.
Conter letras (maiúsculas ou minúsculas) E pelo menos um número.

Entrega 📦

O Regex (Dica: Use [a-zA-Z0-9]{6,}).

Projeto 08 - Limpador de Documentos 🧹

O Desafio 🎯

Remover espaços em branco extras de um texto copiado da internet.

Objetivo: Facilitar a leitura e processamento do texto.

Requisitos

Substituir dois ou mais espaços seguidos por apenas um.
Remover espaços no início e no fim de cada parágrafo.

Entrega 📦

O comando de substituição (JS ou Python).

Projeto 09 - Coletor de Links 🔗

O Desafio 🎯

Extrair todas as URLs de uma página HTML de referência.

Objetivo: Criar um índice de referências bibliográficas automático.

Requisitos

Capturar tudo que começa com http:// ou https://.
Capturar até o fim da URL (espaço ou aspas).

Entrega 📦

A lista de domínios encontrados no texto.

Projeto 10 - Identificador de SKUs 📦

O Desafio 🎯

Validar o código de identificação de mercadorias de um estoque.

Objetivo: Evitar erros de digitação na entrada de dados.

Requisitos

Formato: 2 letras (Setor) - 3 números (Categoria) - 1 letra (Cor).
Exemplo: EL-105-B (Eletrônico, Categoria 105, Cor Blue).

Entrega 📦

O Regex completo com âncoras.

Projeto 11 - Analisador de Logs 🧾

O Desafio 🎯

Filtrar apenas as linhas de erro de um arquivo de log gigante.

Objetivo: Identificar falhas críticas rapidamente.

Requisitos

Capturar linhas que contenham [ERROR] ou [CRITICAL].
Usar a flag de ignore case i.

Entrega 📦

O script grep ou código Python que filtra as linhas.

Projeto 12 - Validador de Cores Hexadecimal 🎨

O Desafio 🎯

Validar códigos de cores usados em arquivos CSS.

Objetivo: Garantir que as cores sigam o padrão web.

Requisitos

Começar com #.
Ter exatamente 3 ou 6 caracteres alfanuméricos (0-9, A-F).
Exemplo: #FFF, #000000, #A1B2C3`.

Entrega 📦

O Regex (Dica: Use agrupamento e alternância).

Projeto 13 - Reorganizador de Nomes 👤

O Desafio 🎯

Transformar uma lista de nomes em formato acadêmico para formato simples.

Objetivo: Pires, Ricardo -> Ricardo Pires.

Requisitos

Capturar Sobrenome e Nome separadamente.
Usar grupos de captura.
Inverter a ordem na substituição.

Entrega 📦

O padrão de busca e o padrão de substituição.

Projeto 14 - Extrator de Preços 💰

O Desafio 🎯

Extrair todos os valores em reais de um texto publicitário.

Objetivo: Gerar uma tabela comparativa de preços.

Requisitos

Capturar o padrão R$ 0,00.
Lidar com pontos de milhar (opcional).

Entrega 📦

O script re.findall() e a lista de valores extraídos.

Projeto 15 - Validador de IP (Básico) 🌐

O Desafio 🎯

Verificar se um endereço IP (v4) tem o formato correto.

Objetivo: Validar conexões de rede em um sistema de segurança.

Requisitos

4 blocos de números separados por pontos.
Exemplo: 192.168.1.1.

Entrega 📦

O Regex (Dica: \d{1,3}(\.\d{1,3}){3}).

Projeto 16 - Sanitizador Universal de Dados (Final) 🏆

O Desafio 🎯

Você é o mestre do Regex agora! Sua tarefa final é criar um script completo que processe uma massa de dados brutos e os transforme em um relatório limpo.

Objetivo: Aplicar todos os conceitos do curso (Metacaracteres, Grupos, Âncoras, Flags).

Cenário

Limpe os logs de acesso de um servidor que estão no formato: Data: 2024-10-21 | User: admin | IP: 127.0.0.1 | Msg: Login Successful

Requisitos Finais

Normalizar Datas: Para 21/10/2024.
Extrair Usuários: Criar uma lista única.
Filtrar Sucessos: Identificar apenas logins bem-sucedidos.
Limpeza Geral: Remover qualquer caractere especial nos nomes.

Entrega 📦

O código fonte completo (Python ou JS).
Uma breve explicação de cada Regex utilizado.

Quizzes

🧠 Quizzes de Fixação

Lista completa das 20 unidades de quizzes organizadas em 5 módulos didáticos.

Módulo 1: Fundamentos (01 a 04) ---
Módulo 2: Conceitos Essenciais (05 a 08) ---
Módulo 3: Aplicação Prática (09 a 12) ---
Módulo 4: Padrões e Ferramentas (13 a 16) ---
Módulo 5: Avançado e Capstone (17 a 20) ---

🧠 Quiz 01 – Introdução ao Regex 🔍

Qual é o conceito fundamental e objetivo principal de Introdução ao Regex 🔍?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Introdução ao Regex 🔍?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Introdução ao Regex 🔍, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Introdução ao Regex 🔍?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Introdução ao Regex 🔍 atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Introdução ao Regex 🔍, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em Introdução ao Regex 🔍?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Introdução ao Regex 🔍 estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Introdução ao Regex 🔍 com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Introdução ao Regex 🔍 deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 02 – Estrutura Básica de uma Expressão Regular 🏗️

Qual é o conceito fundamental e objetivo principal de Estrutura Básica de uma Expressão Regular 🏗️?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Estrutura Básica de uma Expressão Regular 🏗️?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Estrutura Básica de uma Expressão Regular 🏗️, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Estrutura Básica de uma Expressão Regular 🏗️?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Estrutura Básica de uma Expressão Regular 🏗️ atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Estrutura Básica de uma Expressão Regular 🏗️, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em Estrutura Básica de uma Expressão Regular 🏗️?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Estrutura Básica de uma Expressão Regular 🏗️ estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Estrutura Básica de uma Expressão Regular 🏗️ com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Estrutura Básica de uma Expressão Regular 🏗️ deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 03 – Metacaracteres Fundamentais 🔣

Qual é o conceito fundamental e objetivo principal de Metacaracteres Fundamentais 🔣?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Metacaracteres Fundamentais 🔣?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Metacaracteres Fundamentais 🔣, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Metacaracteres Fundamentais 🔣?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Metacaracteres Fundamentais 🔣 atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Metacaracteres Fundamentais 🔣, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em Metacaracteres Fundamentais 🔣?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Metacaracteres Fundamentais 🔣 estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Metacaracteres Fundamentais 🔣 com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Metacaracteres Fundamentais 🔣 deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 04 – Conjuntos de Caracteres 📦

Qual é o conceito fundamental e objetivo principal de Conjuntos de Caracteres 📦?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Conjuntos de Caracteres 📦?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Conjuntos de Caracteres 📦, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Conjuntos de Caracteres 📦?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Conjuntos de Caracteres 📦 atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Conjuntos de Caracteres 📦, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em Conjuntos de Caracteres 📦?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Conjuntos de Caracteres 📦 estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Conjuntos de Caracteres 📦 com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Conjuntos de Caracteres 📦 deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 05 – Quantificadores 🔢

Qual é o conceito fundamental e objetivo principal de Quantificadores 🔢?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Quantificadores 🔢?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Quantificadores 🔢, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Quantificadores 🔢?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Quantificadores 🔢 atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Quantificadores 🔢, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em Quantificadores 🔢?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Quantificadores 🔢 estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Quantificadores 🔢 com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Quantificadores 🔢 deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 06 – Âncoras ⚓

Qual é o conceito fundamental e objetivo principal de Âncoras ⚓?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Âncoras ⚓?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Âncoras ⚓, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Âncoras ⚓?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Âncoras ⚓ atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Âncoras ⚓, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em Âncoras ⚓?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Âncoras ⚓ estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Âncoras ⚓ com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Âncoras ⚓ deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 07 – Agrupamentos e Captura 🎯

Qual é o conceito fundamental e objetivo principal de Agrupamentos e Captura 🎯?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Agrupamentos e Captura 🎯?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Agrupamentos e Captura 🎯, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Agrupamentos e Captura 🎯?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Agrupamentos e Captura 🎯 atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Agrupamentos e Captura 🎯, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em Agrupamentos e Captura 🎯?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Agrupamentos e Captura 🎯 estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Agrupamentos e Captura 🎯 com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Agrupamentos e Captura 🎯 deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 08 – Alternância 🔀

Qual é o conceito fundamental e objetivo principal de Alternância 🔀?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Alternância 🔀?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Alternância 🔀, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Alternância 🔀?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Alternância 🔀 atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Alternância 🔀, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em Alternância 🔀?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Alternância 🔀 estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Alternância 🔀 com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Alternância 🔀 deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 09 – Modificadores (Flags) 🚩

Qual é o conceito fundamental e objetivo principal de Modificadores (Flags) 🚩?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Modificadores (Flags) 🚩?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Modificadores (Flags) 🚩, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Modificadores (Flags) 🚩?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Modificadores (Flags) 🚩 atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Modificadores (Flags) 🚩, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em Modificadores (Flags) 🚩?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Modificadores (Flags) 🚩 estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Modificadores (Flags) 🚩 com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Modificadores (Flags) 🚩 deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 10 – Regex na Prática com JavaScript 📜

Qual é o conceito fundamental e objetivo principal de Regex na Prática com JavaScript 📜?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Regex na Prática com JavaScript 📜?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Regex na Prática com JavaScript 📜, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Regex na Prática com JavaScript 📜?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Regex na Prática com JavaScript 📜 atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Regex na Prática com JavaScript 📜, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em Regex na Prática com JavaScript 📜?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Regex na Prática com JavaScript 📜 estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Regex na Prática com JavaScript 📜 com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Regex na Prática com JavaScript 📜 deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 11 – Regex com Python 🐍

Qual é o conceito fundamental e objetivo principal de Regex com Python 🐍?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Regex com Python 🐍?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Regex com Python 🐍, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Regex com Python 🐍?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Regex com Python 🐍 atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Regex com Python 🐍, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em Regex com Python 🐍?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Regex com Python 🐍 estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Regex com Python 🐍 com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Regex com Python 🐍 deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 12 – Validação de Dados Reais ✅

Qual é o conceito fundamental e objetivo principal de Validação de Dados Reais ✅?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Validação de Dados Reais ✅?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Validação de Dados Reais ✅, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Validação de Dados Reais ✅?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Validação de Dados Reais ✅ atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Validação de Dados Reais ✅, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em Validação de Dados Reais ✅?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Validação de Dados Reais ✅ estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Validação de Dados Reais ✅ com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Validação de Dados Reais ✅ deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 13 – Extração de Dados ⛏️

Qual é o conceito fundamental e objetivo principal de Extração de Dados ⛏️?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Extração de Dados ⛏️?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Extração de Dados ⛏️, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Extração de Dados ⛏️?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Extração de Dados ⛏️ atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Extração de Dados ⛏️, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em Extração de Dados ⛏️?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Extração de Dados ⛏️ estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Extração de Dados ⛏️ com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Extração de Dados ⛏️ deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 14 – Limpeza e Transformação 🧼

Qual é o conceito fundamental e objetivo principal de Limpeza e Transformação 🧼?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Limpeza e Transformação 🧼?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Limpeza e Transformação 🧼, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Limpeza e Transformação 🧼?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Limpeza e Transformação 🧼 atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Limpeza e Transformação 🧼, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em Limpeza e Transformação 🧼?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Limpeza e Transformação 🧼 estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Limpeza e Transformação 🧼 com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Limpeza e Transformação 🧼 deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 15 – Desempenho e Boas Práticas ⚡

Qual é o conceito fundamental e objetivo principal de Desempenho e Boas Práticas ⚡?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Desempenho e Boas Práticas ⚡?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Desempenho e Boas Práticas ⚡, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Desempenho e Boas Práticas ⚡?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Desempenho e Boas Práticas ⚡ atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Desempenho e Boas Práticas ⚡, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em Desempenho e Boas Práticas ⚡?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Desempenho e Boas Práticas ⚡ estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Desempenho e Boas Práticas ⚡ com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Desempenho e Boas Práticas ⚡ deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

🧠 Quiz 16 – Projeto Final: O Grande Desafio 🏆

Qual é o conceito fundamental e objetivo principal de Projeto Final: O Grande Desafio 🏆?
( ) Reduzir a segurança do sistema sem análise prévia.
(x) Garantir estruturação, eficiência e qualidade no desenvolvimento de software.
( ) Omitir o tratamento de erros em produção.
( ) Bloquear a execução de rotinas assíncronas.
Qual benefício direto é obtido ao aplicar as melhores práticas de Projeto Final: O Grande Desafio 🏆?
(x) Maior manutenibilidade, legibilidade, desacoplamento e desempenho.
( ) Aumento indeterminado no tempo de latência das chamadas à API.
( ) Incompatibilidade com os compiladores e interpretadores modernos.
( ) Impedir a criação de testes automatizados.
Em relação ao fluxo de execução e arquitetura em Projeto Final: O Grande Desafio 🏆, assinale a alternativa correta:
( ) A lógica opera sem validação de entradas ou saídas.
(x) O fluxo de dados segue validação rigorosa de entrada, processamento coeso e verificação de saída.
( ) As regras de negócio devem ser codificadas diretamente na camada de visualização.
( ) É proibido desacoplar dependências entre módulos.
Qual é a conduta recomendada para manter a legibilidade do código em Projeto Final: O Grande Desafio 🏆?
(x) Seguir convenções de nomenclatura limpa, modularização e documentação clara.
( ) Utilizar variáveis globais sem restrição de acesso.
( ) Substituir nomes descritivos por identificadores de um único caractere.
( ) Desabilitar a checagem de tipos e validação estática.
Como comprovar que a implementação de Projeto Final: O Grande Desafio 🏆 atingiu os critérios de aceitação?
( ) Avaliando visualmente a quantidade total de linhas de código.
(x) Executando suítes de testes unitários e de integração automatizados com cobertura adequada.
( ) Verificando a paleta de cores do editor de texto.
( ) Omitindo os relatórios de execução de testes no CI/CD.
Ao tratar exceções e cenários de falha em Projeto Final: O Grande Desafio 🏆, o desenvolvedor deve:
(x) Capturar erros específicos, registrar logs rastreáveis e fornecer mensagens claras.
( ) Silenciar todas as exceções com blocos vazios.
( ) Encerrar abruptamente o processo do servidor sem notificação.
( ) Modificar variáveis de ambiente do sistema operacional.
Qual o risco de ignorar as convenções e padrões recomendados em Projeto Final: O Grande Desafio 🏆?
(x) Acúmulo de débito técnico, vulnerabilidades de segurança e degradação de desempenho.
( ) Formatação automática de arquivos na IDE.
( ) Aumento espontâneo da velocidade do barramento de memória.
( ) Exclusão de arquivos de configuração do projeto.
O princípio da responsabilidade única aplicado a Projeto Final: O Grande Desafio 🏆 estabelece que:
(x) Cada componente ou módulo deve ter apenas uma única razão para mudar.
( ) Todas as funções do projeto devem residir no mesmo arquivo-fonte.
( ) O banco de dados deve ser executado na mesma thread do frontend.
( ) Os testes automatizados devem ser deletados antes da compilação de produção.
Para integrar Projeto Final: O Grande Desafio 🏆 com outros serviços e módulos do ecossistema, deve-se:
(x) Utilizar interfaces bem definidas, abstrações e contratos claros (APIs/DTOs).
( ) Acessar diretamente estruturas privadas internas de outros módulos.
( ) Trafegar dados confidenciais em texto puro sem criptografia.
( ) Desativar os protocolos de comunicação da rede.
A documentação técnica referente a Projeto Final: O Grande Desafio 🏆 deve conter obrigatoriamente:
(x) Requisitos funcionais, arquitetura, exemplos práticos de uso e instruções de teste.
( ) Apenas a assinatura digital do autor.
( ) Uma lista aleatória de comandos de sistema operacional.
( ) Rascunhos não revisados de reuniões antigas.

Slides

Configuração

Guias de Instalação 🛠️

Prepare seu ambiente para dominar as Expressões Regulares.

Ferramentas Online

A forma mais rápida de começar.
- Setup 01 - Regex101 (Testes Online)
Desenvolvimento Desktop

Integre Regex no seu editor.

Sobre

Sobre o Curso

🎓 Expressões Regulares (Regex)

Este é um curso completo e estruturado de Expressões Regulares (Regex). Desenvolvido para levar você do básico ao avançado, com uma abordagem prática e focada nas necessidades reais do mercado de tecnologia, desde validação de dados até automação de tarefas.

🎯 Objetivos do Curso

Dominar Metacaracteres

Aprender os blocos fundamentais para construir qualquer expressão de busca.
Validação de Dados

Criar regras robustas para validar e-mails, telefones, CPFs e senhas fortes.
Integração Multinível

Aplicar Regex em JavaScript, Python e ferramentas de linha de comando.
Automação e Limpeza

Extrair e transformar grandes volumes de texto de forma automatizada e eficiente.

📚 O Que Você Vai Aprender

Módulo 1 – Fundamentos e Sintaxe

O que são Expressões Regulares
Metacaracteres fundamentais e conjuntos
Quantificadores e Âncoras
Agrupamentos, Captura e Alternância

Módulo 2 – Aplicações Práticas

Regex em JavaScript (test, match, replace)
Regex em Python (biblioteca re)
Validação de formulários reais
Extração de dados e limpeza de textos

🛠️ Metodologia

Aulas Teóricas

Conteúdo explicativo com exemplos práticos e slides interativos com Reveal.js.
Exercícios Progressivos

Listas de 5 exercícios por aula para fixar desde o básico até o desafio final.
Mini-Projetos

Desenvolva soluções práticas de Regex em cada aula do curso.
Quizzes Interativos

Teste seus conhecimentos com 10 questões por aula para garantir o aprendizado.

👨‍🎓 Público-Alvo

Iniciantes em programação que querem dominar a manipulação de texto
Estudantes de TI que buscam ferramentas poderosas para seus projetos
Profissionais de Dados que trabalham com limpeza e extração de informações
Desenvolvedores que precisam validar entradas de usuários de forma segura

📋 Pré-requisitos

Computador com internet
Conhecimento básico de lógica (opcional)
Curiosidade para aprender uma linguagem "dentro das linguagens"
Não é necessário ser um expert em programação!

🎖️ O Que Você Receberá

✅ 16 aulas completas e estruturadas
✅ Slides modernos e interativos
✅ 80 exercícios práticos progressivos
✅ 16 mini-projetos aplicados
✅ 160 questões de quiz para fixação
✅ Desafio de projeto final validador/extrator

🚀 Comece Agora

Pronto para dominar as Expressões Regulares?

Ir para Aula 01 Materiais de Apoio

Dúvidas? Entre em contato ou acesse o plano de ensino.

Materiais

Bem-vindo à seção de materiais complementares do curso. Aqui você encontra recursos adicionais para apoiar seus estudos.

Slides
- Acesse os slides de todas as aulas para revisão.
Exercícios
- Pratique com listas de exercícios para cada módulo.
Quizzes
- Teste seus conhecimentos com quizzes interativos.
Projetos
- Desenvolva projetos práticos para aplicar o que aprendeu.
Setup
- Guias de instalação e configuração do ambiente.

🏷️ Índice de Tags Didáticas

Navegue pelas aulas, exercícios e projetos do curso organizados por temas, tecnologias e conceitos fundamentais:

tags.md:145-167/name

Versão para Impressão

Esta página foi gerada automaticamente para impressão.

Curso de Expressões Regulares (Regex) 🔍

🎯 Por que aprender Regex?

📚 Estrutura do Curso (16 Aulas)

Módulo 1: A Lógica do Padrão (Aulas 01-08)

Módulo 2: Domínio e Aplicações (Aulas 09-16)

Plano de Ensino 🧭

🎯 1. Objetivos do Curso

📚 2. Cronograma de Aulas (Matriz de 20 Semanas)

🧠 3. Metodologia de Ensino

💼 4. Competências e Perfil Desenvolvido

📊 5. Critérios de Avaliação

Aulas

Aulas do Curso

📚 Módulos do Curso

Aula 01 – Introdução ao Regex 🔍

🧐 O que são Expressões Regulares?

🌍 Onde são utilizadas?

📊 Fluxo de Funcionamento

💻 Exemplos Práticos no Dia a Dia

🛠️ Ferramenta Indispensável: Regex101

Como usar:

📝 Exercícios de Aquecimento

🚀 Mini-Projeto: O Primeiro Match

Aula 02 – Estrutura Básica de uma Expressão Regular 🏗️

🔡 Texto Literal

🔠 Sensibilidade (Case Sensitivity)

📊 Diagrama de Fluxo de Busca Literal

💻 Primeiros Testes Práticos em Terminal

📝 Exercícios de Fixação

🚀 Mini-Projeto: Localizador de Erros

Aula 03 – Metacaracteres Fundamentais 🔣

⏺️ O Ponto (.) - O Coringa

🔢 Atalhos de Classes (\d, \w, \s)

📊 Tabela de Correspondências

🛡️ O Caractere de Escape (\)

💻 Exemplo em TermynalJS

📝 Exercícios de Fixação

🚀 Mini-Projeto: Extrator de Versões

Aula 04 – Conjuntos de Caracteres 📦

🔡 O que são Conjuntos?

📏 Usando Intervalos (Ranges)

📊 Visualização de Conjuntos

🚫 Negação ([^...])

💻 Exemplo em TermynalJS

📝 Exercícios de Fixação

🚀 Mini-Projeto: Filtro de Placas (Básico)

Aula 05 – Quantificadores 🔢

➕ Os Quantificadores Básicos

🎯 Quantidade Exata {n,m}

📊 Funcionamento Visual

🧠 Guloso vs. Preguiçoso (Greedy vs Lazy)

💻 Exemplo em TermynalJS

📝 Exercícios de Fixação

🚀 Mini-Projeto: Validador de Usuário

Aula 06 – Âncoras ⚓

🔝 Início da Linha (^)

🔚 Fim da Linha ($)

🛡️ Validação Completa de Campos

📊 Visualização de Âncoras

💻 Exemplo em TermynalJS

📝 Exercícios de Fixação

🚀 Mini-Projeto: Validador de ID

Aula 07 – Agrupamentos e Captura 🎯

📦 Grupos de Captura ()

🔢 Referências Internas (Backreferences)

📊 Estrutura de Grupos

💻 Exemplo em TermynalJS (Substituição)

📝 Exercícios de Fixação

🚀 Mini-Projeto: Extrator de Preços

Aula 08 – Alternância 🔀

🏗️ O Operador |

📦 Alternância com Agrupamento

📊 Árvore de Decisão

💻 Exemplo em TermynalJS

📝 Exercícios de Fixação

🚀 Mini-Projeto: Filtro de Protocolos

Aula 09 – Modificadores (Flags) 🚩

🏳️ As Flags Mais Comuns

🔄 Global (g) vs Single Match

📊 Resumo Visual das Flags

⏺️ O Ponto (`.`) - O Coringa

🔢 Atalhos de Classes (`\d`, `\w`, `\s`)

🛡️ O Caractere de Escape (`\`)

🚫 Negação (`[^...]`)

🎯 Quantidade Exata `{n,m}`

🔝 Início da Linha (`^`)

🔚 Fim da Linha (`$`)

📦 Grupos de Captura `()`

🏗️ O Operador `|`

🔄 Global (`g`) vs Single Match

1. `regex.test(string)`

2. `string.match(regex)`

3. `string.replace(regex, novoTexto)`

📦 A Biblioteca `re`

1. `re.search(padrao, string)`

2. `re.findall(padrao, string)`

3. `re.sub(padrao, substituto, string)`

🏗️ O uso do `r""` (Raw Strings)