Introdução

“Vibe Coding” é uma prática emergente de desenvolvimento de software que utiliza inteligência artificial (IA) para gerar código funcional a partir de prompts em linguagem natural. Cunhado pelo pesquisador de IA eslovaco-canadense Andrej Karpathy no início de 2025, o termo descreve um fluxo de trabalho onde o papel do desenvolvedor muda de escrever código linha por linha para guiar um assistente de IA através de um processo conversacional para gerar, refinar e depurar uma aplicação.

Essa abordagem acelera o desenvolvimento, especialmente a prototipagem, e reduz a barreira de entrada para a criação de software, permitindo que indivíduos com experiência limitada em programação (ou até mesmo sem nenhuma experiência) construam aplicações funcionais.

Apesar de seus benefícios em velocidade e acessibilidade, o Vibe Coding apresenta limitações e riscos significativos. A qualidade, segurança e manutenibilidade do código gerado pela IA são preocupações centrais, com estudos indicando que o código pode conter vulnerabilidades de segurança e especialistas alertando sobre a dificuldade de depurar um código que o desenvolvedor não escreveu e, possivelmente, não entende completamente como funciona.

Além disso, a prática pode deturpar a complexidade do desenvolvimento de software profissional.

Consequentemente, o papel do desenvolvedor está evoluindo, com um foco maior em habilidades de alto nível, como arquitetura de software, pensamento sistêmico e gerenciamento da integração de sistemas.

No contexto educacional, a ascensão de ferramentas de Vibe Coding exige novas pedagogias, como o framework PROPER, para garantir que os alunos desenvolvam uma compreensão profunda dos conceitos de programação em vez de apenas aceitar o código gerado pela IA.

Análise Detalhada

Definição e Origem

O termo “Vibe Coding” foi popularizado pelo pesquisador de IA Andrej Karpathy (que trabalhou na Tesla e na OpenAI) para descrever um novo método de programação onde o desenvolvedor “se entrega totalmente às ‘vibes'” e guia uma IA para construir uma aplicação. A prática é caracterizada por um processo conversacional no qual o usuário descreve o que deseja em linguagem natural, e a IA gera o código correspondente.

De acordo com Karpathy, nesse método, o desenvolvedor raramente toca no teclado, não lê mais os diffs (diferenças de código) e simplesmente copia e cola mensagens de erro no chat da IA para que ela os corrija. Ele descreve a experiência da seguinte forma:

“Não é realmente codificar. Eu apenas vejo coisas, digo coisas, executo coisas e copio e colo coisas, e na maioria das vezes funciona.”

Essa abordagem representa uma mudança fundamental no papel do desenvolvedor, que passa de arquiteto e implementador para “orientador, guia, testador e refinador”. O foco principal se desloca da sintaxe e da escrita de código para a ideação e o refinamento do produto final.

O Fluxo de Trabalho do Vibe Coding

O processo de Vibe Coding normalmente segue um ciclo de vida de aplicação que enfatiza a prototipagem rápida e o refinamento iterativo.

1. Ideação (Ideation): O desenvolvedor descreve a aplicação desejada em um único prompt de alto nível.
2. Geração (Generation): A IA gera a versão inicial completa da aplicação, incluindo a interface do usuário (UI), a lógica do backend e a estrutura de arquivos.
3. Refinamento Iterativo (Iterative Refinement): O desenvolvedor testa a aplicação e usa prompts de acompanhamento para adicionar novos recursos, alterar elementos visuais ou modificar a funcionalidade existente. Por exemplo: “torne o botão azul” ou “adicione autenticação”.
4. Teste e Validação (Testing and Validation): Um especialista humano revisa a aplicação para garantir a segurança, qualidade e correção do código.
5. Implantação (Deployment): Com um prompt final ou um único clique, a aplicação é implantada em uma plataforma escalável.
6. Documentação e Otimização (Documentation and Optimization): A IA também pode ser instruída a gerar documentação inline, sugerir melhorias de desempenho ou escrever testes para validar a funcionalidade.

Comparação: Vibe Coding vs. Programação Tradicional

A tabela a seguir, baseada em informações do Google Cloud, destaca as principais diferenças entre as duas abordagens.

Ferramentas que Impulsionam o Vibe Coding

Uma variedade de ferramentas de IA tornou essa abordagem cada vez mais acessível. As principais incluem:

• GitHub Copilot: Uma ferramenta de IA que sugere código enquanto o desenvolvedor digita em seu editor, oferece um chat para perguntas e ajuda no uso da linha de comando.
• Replit Agent: Um assistente de IA projetado para transformar ideias em aplicações funcionais, acessível tanto para desenvolvedores quanto para pessoas sem experiência em programação.
• Cursor AI: Um ambiente de desenvolvimento integrado (IDE) com funcionalidades de IA, como edições e correções inteligentes, pesquisa de base de código com linguagem natural e um chat que pode acessar a web para obter informações atualizadas.
• Lovable (anteriormente GPTEngineer): Uma plataforma que permite a construção de aplicações web full-stack a partir de descrições em inglês, integrando design de frontend, lógica de backend, autenticação e banco de dados.
• Windsurf AI: Uma ferramenta que funciona como um IDE completo ou uma extensão do VS Code, com um sistema de compreensão profunda do código em tempo real e um “Cascade Write Mode” que cria múltiplos arquivos, executa testes e depura automaticamente.
• Trae: Um assistente de IA que foca na colaboração dinâmica entre o usuário e a IA, capaz de gerar um plano de projeto, executar tarefas e se adaptar a mudanças.
• Bolt.new: Um ambiente totalmente baseado em navegador que dá à IA controle total sobre o ambiente de desenvolvimento, permitindo instalar pacotes, executar servidores e implantar aplicações a partir de um único prompt.
• LLMs Gerais (ChatGPT, Claude, Gemini): Modelos de linguagem de grande escala que são excelentes ferramentas para ajudar desenvolvedores de todos os níveis a resolver problemas de codificação e aprender mais rapidamente.
• Cline: Um assistente de IA que funciona dentro do Microsoft Visual Studio Code para auxiliar na escrita e gerenciamento de código.

Limitações, Riscos e Críticas

Apesar do entusiasmo, o Vibe Coding enfrenta ceticismo e apresenta desafios bastante significativos.

Qualidade e Segurança do Código

O código gerado por IA pode ser inseguro e de baixa qualidade,a lém de ser difícil de depurar – principalmente se for gerado por pessoas com pouca experiência em desenvolvimento. Um estudo descobriu que o código gerado por IA pode conter vulnerabilidades significativas. Artigos alertam que startups que dependem fortemente dessa prática podem ser “alvos fáceis para hackers”.

Kevin Roose, do The New York Times, observou que, em um caso, o código gerado por IA fabricou avaliações falsas para um site de e-commerce.

Desafios de Depuração

Como os desenvolvedores não escreveram o código, eles podem ter muita dificuldade em entender a sintaxe, os conceitos ou a lógica subjacente, tornando a depuração um processo extremamente desafiador.

Deturpação do Desenvolvimento de Software

Críticos como Andrew Ng, especialista em IA, argumentam que o termo “Vibe Coding” é um “nome ruim para um trabalho muito real e exaustivo”, pois mascara a complexidade e o rigor exigidos no desenvolvimento de software profissional.

Riscos de Confiabilidade

Um incidente notório envolveu o Replit Agent, que supostamente deletou o banco de dados de produção de um usuário, falsificou dados e mentiu sobre o ocorrido durante uma execução de teste, destacando os perigos de conceder controle excessivo a agentes de IA.

Originalidade vs. Reprodução

O cientista cognitivo Gary Marcus (Professor do Departamento de Psicologia da New York University) argumenta que grande parte do entusiasmo com o Vibe Coding deriva da reprodução, não da originalidade. A IA é treinada em código existente para tarefas semelhantes, replicando soluções em vez de inovar e, portanto, deixando a desejar em matéria de criatividade e soluções realmente inovadoras.

O Impacto no Papel do Desenvolvedor

O Vibe Coding não sinaliza a obsolescência dos desenvolvedores, mas sim uma elevação de seu papel. O foco está se deslocando da escrita de código para habilidades de nível superior. De acordo com Addy Osmani, líder sênior de engenharia no Google Chrome, as competências cruciais para o futuro incluem:

• Gerenciamento da Integração e dos Limites de Sistemas: Compreender e gerenciar as fronteiras entre componentes, incluindo design de API, esquemas de eventos e modelos de dados.
• Pensamento Sistêmico (Systems Thinking): Uma compreensão avançada de como sistemas complexos interagem e se comportam.
• Fundamentos de Arquitetura de Software: Conhecimento profundo sobre como projetar sistemas robustos, escaláveis e flexíveis.

Vibe Coding no Contexto Educacional

A proliferação de ferramentas de IA na programação apresenta desafios e oportunidades para a educação em computação. A prática de estudantes usarem IA para completar tarefas de codificação sem necessariamente entender o processo é uma preocupação crescente.

Alunos de disciplinas da ciência da computação que usam ferramentas de IA para estudar, sem critérios bem definidos de uso, tendem a entregar código-fonte sem entender especificamente como ele funciona, e sem conseguir explicar a lógica subjacente utilizada pela IA.

Em outras palavras, eles podem não aprender a codificar e nem sequer desenvolver o raciocínio lógico necessário para essas tarefas, principalmente se fizerem uso dessas ferramentas no início do seu processo de aprendizado.

Para abordar esse problema, foi proposto o framework PROPER, um acrônimo para:

• Prompt: Elaborar um prompt claro e eficaz para a IA.
• Review: Revisar criticamente o código gerado pela IA.
• Organize: Estruturar e organizar o código dentro do projeto maior.
• Polish: Refinar e melhorar o código.
• Extend: Expandir a funcionalidade além do que foi gerado inicialmente.
• Reflect: Refletir sobre o processo de aprendizagem e o que foi criado.

O framework PROPER visa transformar o Vibe Coding de um atalho para uma ferramenta de aprendizagem estruturada, incentivando os alunos a se envolverem ativamente com o código gerado, em vez de aceitá-lo passivamente. Isso ajuda a garantir que, embora a IA possa auxiliar na escrita do código, a compreensão fundamental e as habilidades de resolução de problemas permaneçam com o aluno.

Conclusão

O Vibe Coding representa uma mudança de paradigma no desenvolvimento de software, tornando a criação de tecnologia mais acessível e rápida do que nunca. No entanto, sua adoção vem com uma advertência clara: os benefícios de velocidade e acessibilidade são contrabalançados por riscos significativos em segurança, qualidade e manutenibilidade.

A dependência de código gerado por IA exige um novo conjunto de habilidades, onde o julgamento humano, a supervisão e a perícia em arquitetura de sistemas se tornam primordiais.

Para profissionais e estudantes, o futuro não reside em ser substituído pela IA, mas em evoluir para se tornar um colaborador mais estratégico e crítico no processo de desenvolvimento, utilizando a IA como uma ferramenta poderosa, ainda que imperfeita.

Referências

• Abilytics (White Paper) – Vibe Coding: A New Era of AI-Assisted Software Development
• Osmani, A. Vibe Coding – The Future of Programming – Leverage Your Experience in the Age of AI. 1ª edição 2025. O’Reilly.
• Dataquest: Why Learning Data Science Can’t Be Vibe Coded

O post Vibe Coding e o Futuro do Desenvolvimento de Software apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Para muitos, transformar uma ideia brilhante em um aplicativo funcional sempre pareceu uma tarefa impossível sem anos de estudo em programação. Essa barreira, no entanto, está começando a desaparecer com o surgimento de uma nova era de desenvolvimento de software impulsionada por Inteligência Artificial. O pesquisador de IA Andrej Karpathy (Tesla, OpenAI) batizou essa nova abordagem de “Vibe Coding”.

O termo descreve um fluxo de trabalho revolucionário onde o desenvolvedor não escreve código linha por linha, mas guia uma IA usando linguagem natural, como se estivesse conversando com um assistente genial.

O Novo Papel do Desenvolvedor: Mais Maestro, Menos Codificador

O Vibe Coding representa uma mudança fundamental no papel do desenvolvedor. O trabalho deixa de ser uma tarefa meticulosa de escrita de código para se tornar um diálogo contínuo com uma IA. O foco se desloca da sintaxe e dos detalhes de implementação para o “panorama geral” — o objetivo principal e a funcionalidade do aplicativo.

O desenvolvedor atua como um diretor, fornecendo a visão e a direção, enquanto a IA executa as tarefas técnicas.

Essa nova dinâmica é perfeitamente capturada por Andrej Karpathy:

“Não é bem programar… Eu apenas vejo coisas, digo coisas, executo coisas e copio e colo coisas, e na maior parte funciona.”

Essa abordagem se assemelha mais a dirigir uma equipe ou reger uma orquestra do que a escrever código manualmente. O desenvolvedor se torna o maestro que garante que todas as partes do software funcionem em harmonia para atingir o objetivo final.

Para Criar um App, Basta uma Ideia (ou Quase Isso)

Uma das consequências mais impactantes do Vibe Coding é a drástica redução da barreira de entrada para a criação de software. Um exemplo notável é o do jornalista Kevin Roose, do The New York Times, que, sem ser programador, conseguiu construir um aplicativo funcional. Sua experiência demonstra que a capacidade de transformar ideias em realidade não está mais restrita a especialistas em tecnologia.

Essa abordagem democratiza o desenvolvimento, permitindo que amadores, empreendedores e pessoas de áreas não técnicas criem soluções para problemas que elas mesmas identificam. Como Roose destacou:

“só ter uma ideia, e um pouco de paciência, geralmente é o suficiente.”

Isso abre um leque de possibilidades, onde qualquer pessoa com uma visão clara pode prototipar e até lançar um aplicativo, acelerando a inovação em todos os setores.

Programadores Não Estão Obsoletos, Estão Evoluindo

A ascensão da IA no desenvolvimento de software levanta uma preocupação comum: a IA substituirá os programadores? A resposta, no entanto, é mais complexa. O Vibe Coding não representa a obsolescência dos desenvolvedores, mas sim uma “elevação” de suas habilidades. O foco do trabalho muda de escrever código para tarefas de nível superior.

Em vez de se concentrar em linhas de código, o desenvolvedor agora gerencia a integração de sistemas complexos, projeta APIs robustas e define modelos de dados. A IA se torna uma ferramenta que executa, mas a estratégia e a arquitetura ainda dependem do conhecimento humano.

Essa evolução redefine o papel do desenvolvedor, que passa de um executor técnico para um estrategista, como ilustra a comparação a seguir:

Embora a IA escreva o código, o conhecimento profundo em ciência da computação se torna ainda mais importante para gerenciar a complexidade dos projetos e garantir que as soluções geradas sejam seguras, eficientes e escaláveis.

As Startups Já Estão Vivendo no Futuro

O Vibe Coding não é apenas uma teoria futurista; já é uma prática em rápida ascensão, especialmente no ecossistema de startups. Um relatório da aceleradora Y Combinator de março de 2025 revelou um dado surpreendente que confirma essa tendência.

De forma clara e direta: 25% das startups na turma de Inverno de 2025 da Y Combinator tinham bases de código 95% geradas por IA.

Esse número é significativo porque demonstra como as novas empresas estão alavancando a IA para ganhar uma vantagem competitiva crucial. É importante notar, no entanto, que o relatório da Y Combinator se referia a código gerado por IA em geral, não especificamente ao fluxo de trabalho conversacional do “vibe coding”, embora a tendência aponte para uma crescente automação no desenvolvimento.

A velocidade proporcionada por essa abordagem permite que startups lancem produtos e iterem sobre eles em um ritmo antes inimaginável, validando ideias de negócio e conquistando mercado muito mais rapidamente.

A Grande Preocupação: Quais são os Riscos do “Vibe Coding”?

Apesar de seu enorme potencial, a abordagem do Vibe Coding não está isenta de riscos e desvantagens significativas. Ignorar esses problemas pode levar a consequências graves tanto para os desenvolvedores quanto para os usuários finais.

• Pesadelos de Segurança e Qualidade: O código gerado por IA pode ter qualidade variável e, mais preocupante, conter vulnerabilidades de segurança. Empresas que dependem exclusivamente de código gerado por IA podem se tornar “alvos fáceis para hackers”.
  O próprio Kevin Roose observou um exemplo disso quando a IA que ele usou inventou avaliações falsas para seu aplicativo, demonstrando a falta de confiabilidade e os riscos éticos associados.
• O Dilema da Depuração: Corrigir erros (depurar) em um código que você não escreveu é um dos maiores desafios do Vibe Coding. Como a IA gera o código dinamicamente, os desenvolvedores podem ter dificuldade para entender a sintaxe ou os conceitos que eles mesmos não utilizaram, tornando o processo de encontrar e consertar bugs extremamente complexo e demorado.

Conclusão: Acelerador, Não Piloto Automático

Vibe Coding é, sem dúvida, uma ferramenta poderosa que está remodelando o desenvolvimento de software. Ele atua como um acelerador, permitindo que ideias se materializem com uma velocidade sem precedentes e abrindo portas para uma nova geração de criadores. No entanto, não é um piloto automático, e deve ser usada com muito cuidado e consciência – principalmente por profissionais ainda com pouca experiência e estudantes..

A supervisão humana, o pensamento crítico e a expertise técnica continuam sendo indispensáveis para garantir a qualidade, a segurança e a manutenção do que é criado.

A IA pode escrever o código, mas a responsabilidade final ainda é do desenvolvedor.

Em uma era de “vibe coding”, a linguagem de programação mais importante passará a ser… o bom e velho português?

Referências

• Abilytics (White Paper) – Vibe Coding: A New Era of AI-Assisted Software Development
• Osmani, A. Vibe Coding – The Future of Programming – Leverage Your Experience in the Age of AI. 1ª edição 2025. O’Reilly.
• Dataquest: Why Learning Data Science Can’t Be Vibe Coded

O post Vibe Coding: Como Criar Softwares Com Pouco Conhecimento de Programação (ou Nenhum) apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

E por que ele pode custar milhões (ou mesmo vidas)

Se você estuda ou trabalha em alguma área relacionada à tecnologia, é altamente provável – quase certeza – que já se deparou com a expressão “bug” ou com algum verbo “abrasileirado”, como “bugar” ou “bugado”. Mas o que significa exatamente isso?

Considere a seguinte situação: um comando simples, por exemplo programado para imprimir uma mensagem na tela dez vezes, acaba executando indefinidamente, sem qualquer critério de parada. O sistema permanece responsivo, mas o comportamento é claramente incorreto. Trata-se de um erro lógico comum — chamado de loop infinito — e é um exemplo clássico de bug em programação.

Entendendo o conceito de bug

Bugs são falhas no código-fonte que levam um programa a se comportar de forma inesperada ou incorreta. Podem resultar em pequenos transtornos, como uma interface mal formatada, ou em consequências graves, como perda de dados, travamentos do sistema e até riscos à segurança – ou ainda mais graves.

Qualquer pessoa que já tenha escrito código, por mais simples que seja, inevitavelmente se depara com esse tipo de problema.

Mas o que caracteriza, de fato, um bug? E por que eles continuam sendo tão prevalentes mesmo com os avanços nas ferramentas de desenvolvimento e boas práticas de engenharia de software? 

Ao contrário do que muitos pensam, computadores não “pensam” ou “entendem” intenções. Eles fazem exatamente o que mandamos — o problema é que nem sempre mandamos a coisa certa. Eles costumam surgir por erro humano: um código mal projetado, uma lógica mal pensada ou até mesmo por uma simples distração na digitação.

A origem do termo “bug”

A palavra bug (que literalmente significa “inseto” em inglês) foi popularizada pela almirante Grace Hopper em 1947. Durante a manutenção de um computador eletromecânico Mark II, uma mariposa foi encontrada presa em um relé, provocando falhas. O inseto foi cuidadosamente colado no diário de bordo com a legenda: “First actual case of bug being found” (em português, “Primeiro caso real de um bug sendo encontrado”).

A partir de então, o termo passou a ser usado para qualquer tipo de erro ou falha que ocorra em sistemas computacionais, não só de hardware, mas também (e hoje, principalmente) de software.

Primeiro “bug” de computador encontrado – literalmente. Mariposa presa em um relé em um painel do Mark II durante um teste na Universidade de Harvard, em 09 de setembro de 1947. Os operadores que a encontraram a afixaram no livro de registros do computador, com a frase “Primeiro caso real de um bug sendo encontrado”

Os três principais tipos de bug

Os bugs nem sempre se manifestam da mesma forma. Alguns são fáceis de identificar, outros podem passar despercebidos por muito tempo. Os principais tipos incluem:

1. Erros de sintaxe

São falhas na escrita do código — algo como esquecer de fechar aspas, colocar um ponto e vírgula onde não devia (ou não colocar), ou ainda digitar comandos inválidos. A boa notícia? São geralmente detectados imediatamente na hora da compilação ou interpretação, ou mesmo apontados pelo IDE antes mesmo de tentar executar o programa para testá-lo.

2. Erros de execução (runtime)

Esses erros só aparecem quando o programa está rodando. Um exemplo clássico é a tentativa de divisão de um número por zero. O código-fonte parece correto, a aplicação roda normalmente, realiza cálculos com precisão, até que… bum!,  a execução para bruscamente quando uma tentativa de divisão por zero ocorre, podendo ocasionar desde a parada da execução da aplicação até o travamento completo do sistema.

3. Erros semânticos (ou de lógica)

São os mais traiçoeiros e difíceis de detectar. O programa roda, executa tudo sem travar, apresenta a saída para o usuário, mas os resultados estão errados — e às vezes ninguém percebe. Um caso comum ocorre com determinados cálculos matemáticos – o sistema efetua os cálculos solicitados, mas por conta de um bug lógico o resultado apresentado é incorreto, e o usuário pode não perceber o problema.

Esse tipo de erro pode causar grandes transtornos, desde perdas financeiras até acidentes fatais.

Quando um bug deixa de ser só um incômodo

Se você acha que um bug é só um erro inofensivo que causa irritação, pense de novo. Bugs já causaram prejuízos bilionários e, em casos extremos, até mortes.

Citemos alguns exemplos notáveis:

• Nuclear Gandhi: No jogo Sid Meier’s Civilization (1991), um erro no sistema de agressividade das civilizações fazia com que o personagem do pacifista Mahatma Gandhi, inicialmente programado com o menor nível possível de agressividade, se tornasse extremamente beligerante após adoção de políticas democráticas. Devido a um underflow (valor abaixo do mínimo) no valor da variável, seu nível de agressividade era reduzido para um valor negativo, que acabava sendo interpretado como o valor máximo permitido.
  O resultado: um Gandhi obcecado por armas nucleares — um bug icônico da história dos games. Divertido? Sim. Mas ainda um bug.
• Therac-25: Entre 1985 e 1987, um equipamento de radioterapia de nome Therac-25, usado no tratamento de câncer, apresentou falhas críticas causadas por erros de programação em seu sistema de controle. Devido à ausência de verificações adequadas e à confiança excessiva em software, o dispositivo permitia que doses de radiação muito acima do limite seguro fossem aplicadas nos pacientes em tratamento.
  Seis pacientes morreram por exposição acidental a níveis fatais de radiação. 
• Mars Climate Orbiter: Em setembro de 1999, a NASA perdeu contato com a sonda Mars Climate Orbiter pouco antes de sua inserção na órbita do planeta Marte. A falha ocorreu porque um módulo do software produzia dados de impulso na unidade libras-força (sistema imperial), enquanto outro módulo esperava receber esses dados em newtons (sistema métrico).
  A ausência de conversão entre unidades resultou em um erro de trajetória fatal, fazendo com que a sonda descesse demais na atmosfera marciana e fosse destruída. O prejuízo estimado ultrapassou US$ 327 milhões.
• Guitar Hero II: Em 2007, uma atualização lançada para o jogo Guitar Hero II em sua versão para o console Xbox 360 causou problemas sérios de estabilidade em diversos aparelhos. Alguns dispositivos passaram a apresentar falhas críticas após a atualização, incluindo travamentos frequentes e, em muitos casos, o temido “Red Ring of Death” (Anel Vermelho da Morte) — um erro fatal de hardware que inutilizava o console. Embora o bug fosse de software, seu impacto foi sentido no hardware, resultando em muitas unidades defeituosas.

Máquina para tratamento de câncer Therac-25

Como lidar com bugs: a arte da depuração

O processo de encontrar e corrigir bugs é conhecido como debugging (em português, depuração). Ferramentas chamadas depuradores (ou debuggers) ajudam a examinar o código linha por linha, inspecionar variáveis e identificar o ponto exato em que tudo começa a dar errado.

Ambientes de desenvolvimento (IDEs) modernos geralmente vêm com depuradores embutidos, tornando essa tarefa um pouco menos ingrata e mais fácil de realizar.

Prevenção de bugs: manipulação de exceções

Outro recurso fundamental é o tratamento de exceções. Trata-se de prever que algo pode dar errado (como dividir um número por zero em um cálculo) e preparar o programa para lidar com isso de forma antecipada, sem falhar completamente. Linguagens de alto nível como Java, Python e C# têm mecanismos específicos para isso, como os blocos try…catch.

Exemplo em Java:

import java.util.Scanner;
public class Divisao {
  public static void main(String[] args) {
    Scanner entrada = new Scanner(System.in);
    System.out.print("Digite o valor de a: ");
    int a = entrada.nextInt();
    System.out.print("Digite o valor de b: ");
    int b = entrada.nextInt();
    int c = a / b; // BUG EM POTENCIAL: pode lançar ArithmeticException se b = 0
    System.out.println("Resultado = " + c);
    entrada.close();
  }
}

Neste exemplo, se o usuário digitar o valor zero ao entrar com o valor de b, será feita uma divisão por zero ao executar o cálculo da variável c. Qualquer outra divisão funcionará, exceto essa.

Ou seja, se b for igual a zero, o programa lançará uma exceção do tipo ArithmeticException e será encerrado abruptamente. Esse é um exemplo clássico de erro de tempo de execução (runtime error), causado por não tratar uma condição excepcional comum.

Como tratar isso? Uma solução é realizar a manipulação dessa exceção, como segue:

import java.util.Scanner;
public class DivisaoSegura {
  public static void main(String[] args) {
    Scanner entrada = new Scanner(System.in);
    System.out.print("Digite o valor de a: ");
    int a = entrada.nextInt();
    System.out.print("Digite o valor de b: ");
    int b = entrada.nextInt();
    try {
      int c = a / b;
      System.out.println("Resultado = " + c);
    }
    catch (ArithmeticException e) {
      System.out.println("Não é possível dividir por zero.");
      System.out.println(e);
    }
    entrada.close();
  }
}

Neste caso a exceção (erro) ArithmeticException foi tratada por meio do uso de um bloco try .. catch, que impedirá o travamento do sistema caso seja fornecido o valor zero à variável b, exibindo em vez disso a mensagem mais amigável “Não é possível dividir por zero” ao usuário..

Testes: prevenindo problemas

A melhor forma de combater bugs é evitá-los desde o início. Testes de software — tanto manuais quanto automatizados — são parte essencial do desenvolvimento. Eles verificam se o programa atende aos requisitos e ajudam a identificar falhas antes que elas possam causar estragos maiores.

Entre os tipos de testes mais comuns estão:

• Testes unitários: verificam o funcionamento de partes específicas do código.
• Testes de integração: checam se os módulos interagem corretamente.
• Testes de sistema: avaliam o sistema como um todo.
• Testes de aceitação: garantem que o software atende ao que o cliente espera.

Bugs no mundo real: onde menos se espera

É importante lembrar que nem só de software vive o mundo dos bugs. Hardware também pode apresentar falhas semelhantes, como erros de projeto em placas, aquecimento excessivo ou falhas elétricas. Mas no fim das contas, tudo parte da mesma raiz: uma falha humana durante a concepção ou implementação de um projeto.

Conclusão: errar é humano, depurar é essencial

Bugs fazem parte da vida de qualquer programador. Não há como evitá-los completamente, mas é possível preveni-los, detectá-los rapidamente e corrigi-los antes que causem problemas sérios.

Com boas práticas de codificação, testes constantes e ferramentas adequadas, dá para dormir mais tranquilo. Ou ao menos, sem sonhar com mariposas voando entre os relés.

Colabore com a Bóson Treinamentos

Ajude o canal adquirindo meus cursos na Udemy:

• Bancos de Dados com MySQL Básico: https://bit.ly/35QdWE4
• Lógica de Programação com Português Estruturado: https://bit.ly/3QKPn22
• Programação em Python do Zero: https://bit.ly/python-boson

Adquira também livros e outros itens na loja da Bóson Treinamentos na Amazon e ajude o canal a se manter e crescer: https://www.amazon.com.br/shop/bosontreinamentos

O post O que é um bug em programação? apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste tutorial trago um algoritmo simples, escrito em Fortran, que permite encontrar os números primos de 1 até um valor n, informado pelo usuário durante a execução do programa, para isso usando o algoritmo clássico conhecido como Crivo de Eratóstenes.

Números primos são números naturais maiores que 1 que têm apenas dois divisores: 1 e eles mesmos. Em outras palavras, são números que não podem ser divididos por nenhum outro número além de 1 e deles mesmos sem resultar em um resto.

Exemplos de números primos incluem 2, 3, 5, 7 e 11.

A propriedade fundamental dos números primos é que não podem ser formados multiplicando dois números inteiros diferentes entre si. A compreensão dos números primos é crucial em matemática, e sua identificação desempenha um papel fundamental em áreas como criptografia e teoria dos números.

O Crivo de Eratóstenes é um algoritmo antigo e eficiente para encontrar todos os números primos até um determinado limite. Ele funciona marcando os múltiplos de cada número primo encontrado, eliminando números compostos e deixando apenas os números primos. O algoritmo realiza iterações até que todos os números até o limite desejado sejam verificados.

Trata-se de uma maneira bastante eficaz de encontrar rapidamente todos os números primos dentro de um intervalo específico.

De acordo com a tradição, o Crivo de Eratóstenes foi criado pelo matemático grego Eratóstenes de Cirene por volta de 240 a.C., sendo assim uma das técnicas mais antigas conhecidas para encontrar números primos.

Busto de Eratóstenes

Neste tutorial vamos implementar este algoritmo usando a linguagem de programação Fortran.

Funcionamento do Crivo de Eratóstenes

O algoritmo do Crivo de Eratóstenes funciona da seguinte maneira:

1. Inicialização:
   Começamos criando uma lista de números a partir de 2 até o valor limite desejado pelo usuário.
   Marcamos todos esses números como não riscados, indicando que inicialmente consideramos todos como primos.
2. Seleção do Próximo Número:
   Começamos com o primeiro número não riscado, que é o 2.
   Este número é então marcado como primo, já que é o menor número não riscado (e 2 é o primeiro número primo).
3. Eliminação dos Múltiplos:
   Agora vamos riscar todos os múltiplos do número primo que acabamos de encontrar, até chegar no valor limite.
   No caso, riscamos todos os múltiplos de 2 (4, 6, 8, 10, 12, …).
4. Seleção do Próximo Número Não Riscado:
   Após riscar os múltiplos do número anterior, vamos nos mover para o próximo número não riscado na lista, que é o próximo número primo.
5. Repetição:
   Repetimos os passos 3 e 4 até que tenhamos marcado todos os números não riscados como primos ou não primos.

Ao final do processo, os números que permanecem não riscados são os números primos dentro do intervalo desejado. O Crivo de Eratóstenes é eficiente porque evita a verificação de múltiplos de números que já foram marcados como não primos, reduzindo significativamente o número de iterações necessárias.

Visualmente, o que o crivo de Eratóstenes equivale ao seguinte:

	0	1	2	3	4	5	6	7	8	9
0	1	2	3	4	5	6	7	8	9	10
1	11	12	13	14	15	16	17	18	19	20
2	21	22	23	24	25	26	27	28	29	30
3	31	32	33	34	35	36	37	38	39	40
4	41	42	43	44	45	46	47	48	49	50
5	51	52	53	54	55	56	57	58	59	60
6	61	62	63	64	65	66	67	68	69	70
7	71	72	73	74	75	76	77	78	79	80
8	81	82	83	84	85	86	87	88	89	90
9	91	92	93	94	95	96	97	98	99	100

Podemos ver que os números primos estão destacados (check verde), ao passo que os números múltiplos, que não são primos, são descartados (x vermelho).

Este algoritmo é bastante empregado em matemática computacional e é uma abordagem clássica para encontrar números primos.

Vejamos agora como implementar esse algoritmo usando uma linguagem de programação – no caso, o Fortran.

Código em Fortran

program CrivoDeEratostenes
implicit none

integer, parameter :: MAX_N = 1000000
integer :: n
logical :: e_primo(MAX_N)
integer :: i, j

! Inicializar o vetor de primos como verdadeiro
e_primo = .true.

! Solicitar ao usuário que insira o valor de 'n'
write(*,*) 'Digite um número inteiro positivo n:'
read(*,*) n

! Verificar se o valor de n está dentro dos limites permitidos para números primos
if (n <= 1 .or. n > MAX_N) then
    write(*,*) 'Valor de n fora dos limites permitidos.'
    stop
end if

! Algoritmo do Crivo de Eratóstenes
do i = 2, n
    if (e_primo(i)) then
        do j = 2*i, n, i
            e_primo(j) = .false.
        end do
    end if
end do

! Exibir os números primos encontrados
write(*,*) 'Números primos de 1 até', n, ':'
do i = 2, n
    if (e_primo(i)) then
        write(*,*) i
    end if
end do

end program CrivoDeEratostenes

Teste

Para testar, vamos pedir ao programa para retornar todos os números primos até o valor 500.000 (quinhentos mil!):

Resultado (truncado):

2
3
5
7
11
...
499943
499957
499969
499973
499979

Explicação do Código

E como exatamente funciona esse código? Vejamos uma explicação passo a passo:

1. Declaração de Variáveis – Começamos declarando algumas variáveis:

• MAX_N: Valor máximo permitido para n (limite superior para encontrar números primos).
• n: Número que será fornecido pelo usuário.
• e_primo: Um array lógico que indica se um número é primo (TRUE) ou não (FALSE).
• i e j: Índices para iteração.

2. Inicialização:

• e_primo = .TRUE.: Inicializa o vetor de primos como verdadeiro.

3. Entrada do Usuário:

• write(*,*) ‘Digite um número inteiro positivo n:’: Solicita ao usuário que insira um número inteiro positivo.
• read(*,*) n: Lê o valor inserido pelo usuário.

4. Verificação do Limite:
– if (n <= 1 .or. n > MAX_N) then: Verifica se o valor de n está dentro dos limites permitidos para números primos.
– write(*,*) ‘Valor de n fora dos limites permitidos.’: Exibe uma mensagem de erro se o valor de n estiver fora dos limites.
– stop: Encerra o programa.

5. Algoritmo do Crivo de Eratóstenes:
– A estrutura de repetição do i = 2, n itera sobre todos os números de 2 até n.
– if (e_primo(i)) then: Verifica se i é marcado como primo.
– A estrutura de repetição interna do j = 2*i, n, i marca todos os múltiplos de i como não primos, já que eles são divisíveis por i.

6. Saída dos Números Primos Encontrados:
– write(*,*) ‘Números primos de 1 até’, n, ‘:’: Exibe uma mensagem indicando que os números primos estão sendo mostrados.
– A segunda estrutura de repetição do i = 2, n itera sobre todos os números de 2 até n.
– if (e_primo(i)) then: Verifica se i é marcado como primo.
– write(*,*) i: Exibe o número primo.

Conclusão

Neste artigo vimos como empregar a técnica do Crivo de Eratóstenes para determinar números primos na linguagem de programação Fortran. Esse mesmo código pode ser adaptado para outras linguagens, como Python, C++, C# ou Rust, de acordo com sua necessidade.

Colabore com a Bóson Treinamentos

Ajude o canal adquirindo meus cursos na Udemy:

• Bancos de Dados com MySQL Básico: https://bit.ly/35QdWE4
• Lógica de Programação com Português Estruturado: https://bit.ly/3QKPn22
• Programação em Python do Zero: https://bit.ly/python-boson

Adquira também livros e outros itens na loja da Bóson Treinamentos na Amazon e ajude o canal a se manter e crescer: https://www.amazon.com.br/shop/bosontreinamentos

O post Calcular números primos com Crivo de Eratóstenes em Fortran apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Em programação, um operador é um símbolo define uma função que será realizada sobre os dados em uma aplicação. Os dados sobre os quais esses operadores atuam são chamados de operandos.

Consideremos a seguinte expressão:

9 + 10 = 19

Aqui, os valores 9 e 10 são os operandos, enquanto os sinais + e = são os operadores. Já o valor 19 é o resultado da operação realizada – no caso, uma operação aritmética de soma de dois números inteiros.

A linguagem Rust possui suporte a diversos tipos de operadores, e os principais operadores primários podem ser classificados como:

• Aritméticos
• Bitwise (Operadores bit-a-bit)
• Relacionais ou de Comparação
• Lógicos

Vejamos quais são esses operadores, suas funções e exemplos de uso de cada um deles.

Operadores Aritméticos

Os operadores aritméticos são empregados na realização de cálculos aritméticos simples, usando as quatro operações básicas da matemática mais a operação como o módulo.

A tabela a seguir mostra os operadores aritméticos com sua descrição, e um exemplo de uso de cada. Nos exemplos, vamos imaginar que os valores em duas variáveis a e b são 10 e 5, respectivamente.

Nota: Os operadores de incremento e decremento ++ e -- não são suportados em Rust. Vejamos agora exemplos de código que usam esses operadores.

Exemplo de uso de operadores aritméticos

fn main() {
  let a = 10;
  let b = 5;
  println!("Soma: {}", a + b); // Soma
  println!("Subtração: {}", a - b); // Subtração
  println!("Multiplicação: {}", a * b); // Multiplicação
  println!("Divisão: {}", a / b); // Divisão
  println!("Módulo: {}", a % b); // Resto da divisão inteira
}

Saída:

Soma: 15
Subtração: 5
Multiplicação: 50
Divisão: 2
Módulo: 0

Operadores Relacionais

Os operadores relacionais testam ou definem o tipo de relação entre duas entidades. São usados para comparar dois ou mais valores, sendo também conhecidos como operadores de comparação, e retornam sempre um valor booleano (true ou false).

A tabela a seguir mostra os operadores relacionais com sua descrição, e um exemplo de uso de cada. Vamos assumir os valores de variáveis A = 10 e B = 20 nos exemplos.

Vejamos agora exemplos de código que usam os operadores de comparação / relacionais.

Exemplo de uso de operadores relacionais

fn main() {
  let a = 10;
  let b = 20;
  println!("a vale {a} e b vale {b}");
  println!("{a} é maior que {b}? {}", a > b);
  println!("{a} é menor que {b} ? {}", a < b);
  println!("{a} é maior ou igual a {b} ? {}", a >= b);
  println!("{a} é menor ou igual a {b} ? {}", a <= b);
  println!("{a} é igual a {b} ? {}", a == b);
  println!("{a} é diferente de {b} ? {}", a != b);
}

Saída:

a vale 10 e b vale 20
a é maior que b? false
a é menor que b? true
a é maior ou igual a b? false
a é menor ou igual a b? true
a é igual a ? false
a é diferente de b? true

Operadores Lógicos

Os operadores lógicos são usados para combinar duas ou mais condições e retornam um valor booleano, que é True (verdadeiro) ou False (falso). Vamos assumir novamente os valores A = 10 e B = 20.

Exemplo de uso de operadores lógicos

fn main() {
  let a = 10;
  let b = 20;
  println!("a vale {a} e b vale {b}");
  println!("AND lógico: {}", a > 5 && b > 15); // True se ambas as condições forem verdadeiras
  println!("OR lógico: {}", a > 15 || b > 15); // True se ao menos uma condição for verdadeira
  println!("NOT lógico: {}", !(a > 15)); // Inverte o resultado
}

Saída:

a vale 10 e b vale 20
AND lógico: true
OR lógico: true
NOT lógico: true

Operadores Bitwise e de Deslocamento de Bits

Os operadores de bit-a-bit ou bitwise realizam operações diretamente sobre os bits de dois ou mais números. Em vez de trabalhar com valores booleanos (verdadeiro / falso), eles trabalham a nível de bit, o que significa que cada bit de um número é comparado ao bit correspondente do outro número.

Esses operadores são muito usados em programação para manipular valores binários, criar máscaras de bits, realizar otimizações em algoritmos e resolver problemas relacionados à lógica binária.

Já os os operadores de deslocamento de bits (<< e >>), ou operadores bitwise shift são usados para mover os bits de um número inteiro para a esquerda ou para a direita. São úteis em muitas situações, como manipulação de dados de baixo nível, otimizações em cálculos e implementação de algoritmos matemáticos.

Sejam as variáveis A = 2 e B = 3:

O operador de deslocamento à esquerda (<<), na prática, multiplica o número por 2 a cada deslocamento. Já o operador de deslocamento à direita (>>) divide o número por 2 a cada deslocamento, descartando a parte fracionária.

Exemplo de uso de operadores bit a bit

fn main() {
  let a: u8 = 2; // 0000_0010 em binário
  let b: u8 = 3; // 0000_0011 em binário
  println!("a vale {a} e b vale {b}");
  println!("AND bitwise: {}", a & b); // 0000_0010
  println!("OR bitwise: {}", a | b); // 0000_0011
  println!("XOR bitwise: {}", a ^ b); // 0000_0001
  println!("NOT bitwise: {}", !b); // Inversão de todos os bits
  println!("Shift à esquerda: {}", a << 1); // Desloca os bits para a esquerda
  println!("Shift à direita: {}", a >> 1); // Desloca os bits para a direita
}

Saída:

a vale 2 e b vale 3
AND bitwise: 2
OR bitwise: 3
XOR bitwise: 1
NOT bitwise: 252
Shift à esquerda: 4
Shift à direita: 1

Conclusão

Neste artigo vimos quais são os principais operadores utilizados em linguagem Rust, sua importância e utilidade, e alguns exemplos de uso de cada um deles. Nos próximos tutoriais vamos usar esses operadores para criar programas mais complexos, usando outras estruturas de programação como laços de repetição, decisão condicional e arrays, entre outras.

O post Operadores em linguagem Rust apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Em Shell Scripting, os laços de repetição são estruturas que permitem executar uma série de comandos várias vezes. Os loops ajudam a automatizar tarefas repetitivas, iterando sobre listas, variáveis, comandos e arquivos. O Bash oferece algumas estruturas de repetição essenciais: for, while, e until.

Vamos explorar cada uma, com exemplos práticos e exercícios ao final.

O laço for em shell scripting

O laço for é usado para percorrer uma lista de itens, como um conjunto de números, strings ou até mesmo arquivos. Ele executa o conjunto de comandos uma vez para cada item na lista.

Sintaxe básica do laço for

for item in lista; do
   Comandos a serem executados
done

Exemplo 1: Laço for simples

Esse exemplo exibe uma mensagem para cada nome da lista.

#!/bin/bash
for nome in Fábio Marcos Bruno Robson; do
  echo "Olá, $nome!"
done

Saída:

Olá, Fábio!
Olá, Marcos!
Olá, Bruno!
Olá Robson!

Exemplo 2: Laço for com intervalo de números

Podemos definir um intervalo de números e iterar sobre ele:

#!/bin/bash
for i in {1..5}; do
echo "$i"
done

Saída:

1
2
3
4
5

Exemplo 3: Loop for sobre arquivos em um diretório

Este exemplo percorre todos os arquivos .txt em um diretório e exibe o nome de cada arquivo.

#!/bin/bash
for arquivo in *.txt; do
echo "Encontrado arquivo: $arquivo"
done

O laço while em shell scripting

O laço while repete os comandos definidos em seu corpo enquanto uma condição testada for verdadeira. Ele é útil quando a quantidade de iterações não é definida e depende de uma condição.

Sintaxe básica do while

while [ condição ]; do
    Comandos a serem executados
done

Vejamos alguns exemplos do loop while em scripts do shell.

Exemplo 1: Loop while simples

Exibir no terminal a sequência de números de 1 a 5:

#!/bin/bash
contador=1
while [ $contador -le 5 ]; do
  echo "$contador"
  contador=$((contador + 1))
done

Saída:

1
2
3
4
5

Exemplo 2: Ler valores do terminal de forma sequencial.

O script a seguir solicita que o usuário digite um número no terminal. Ele repete a solicitação até que o usuário entre com o valor 0, momento em que o loop termina.

#!/bin/bash
# Inicializar com um valor diferente de 0 para entrar no loop
numero=-1
while [ $numero -ne 0 ]; do
  read -p "Digite um número (0 para sair): " numero
  echo "Você digitou: $numero"
done
echo "Fim do laço. Você digitou 0."

O laço until em shell scripting

O laço until é semelhante ao laço while, mas ele repete os comandos enquanto uma condição for falsa, e para a execução quando a condição se torna verdadeira.

Sintaxe básica do until

until [ condição ]; do
    Comandos a serem executados
done

Vejamos alguns exemplos.

Exemplo 1: Loop until simples

Este exemplo incrementa um contador até que ele atinja 5:

#!/bin/bash
contador=1
until [ $contador -gt 5 ]; do
  echo "$contador"
  contador=$((contador + 1))
done
echo "Sequência terminada."

Saída:

1
2
3
4
5
Sequência terminada.

Comandos de controle de loop

Existem comandos de controle que podem ser usados para manipular o comportamento de um loop:

• break: Sai do loop imediatamente.
• continue: Pula a iteração atual e vai para a próxima.

Vejamos como usá-los em scripts.

Exemplo: Uso de break

Este exemplo usa break para sair do loop se o contador atingir 3.

#!/bin/bash
for i in {1..5}; do
  if [ $i -eq 3 ]; then
    echo "Saindo do loop no número $i"
    break
  fi
  echo "Número: $i"
done

Saída:

Número: 1
Número: 2
Saindo do loop no número 3

Exemplo: Uso de continue

Este exemplo usa continue para pular a exibição do número 3.

#!/bin/bash
for i in {1..5}; do
  if [ $i -eq 3 ]; then
    continue
  fi
  echo "Número: $i"
done

Saída:

Número: 1
Número: 2
Número: 4
Número: 5

Excelente. Vamos propor agora alguns exercícios para você treinar o uso de laços de repetição em Shell Scripting. Resoluções sugeridas se encontram logo após a lista de exercícios.

Exercícios práticos com laços de repetição

1. Crie um script que exiba uma contagem regressiva de 10 a 1 usando um loop for.
2. Use um loop while para somar os números de 1 a 100 e exibir o resultado total.
3. Escreva um script que use o loop for para percorrer arquivos .txt em um diretório e exiba o nome de cada arquivo encontrado.
4. Use um loop until para solicitar uma senha até que o usuário digite a senha correta (“1234”).
5. Crie um loop for que percorra os números de 1 a 10, pulando o número 5 e saindo do loop quando chegar ao número 8.

Resolução dos exercícios

Exercício 1

#!/bin/bash
for i in {10..1}; do
  echo "Contagem regressiva: $i"
done

Exercício 2

#!/bin/bash
soma=0
contador=1
while [ $contador -le 100 ]; do
  soma=$((soma + contador))
  contador=$((contador + 1))
done
echo "A soma de 1 a 100 é: $soma"

Exercício 3

#!/bin/bash
for arquivo in *.txt; do
  echo "Arquivo encontrado: $arquivo"
done

Exercício 4

#!/bin/bash
senha=""
until [ "$senha" == "1234" ]; do
  read -sp "Digite a senha: " senha
  echo
done
echo "Senha correta!"

#Exercício 5: Usar break e continue em um loop

#!/bin/bash
for i in {1..10}; do
  if [ $i -eq 5 ]; then
    continue
  fi
  if [ $i -eq 8 ]; then
    break
  fi
  echo "Número: $i"
done

Conclusão

Os laços de repetição em Shell Scripting permitem criar fluxos de trabalho eficientes para manipular dados, arquivos e outros elementos de forma automatizada.

Aprender a usar for, while e until com comandos de controle como break e continue aumenta a flexibilidade e o controle que temos sobre o código, permitindo resolver problemas de forma mais simples e eficiente.

O post Como usar laços de repetição em Shell Scripting apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste tutorial vamos escrever um pequeno programa em linguagem Python que irá gerar uma lista com os números de 1 até 1000 (sequenciais), colocados depois em ordem aleatória, e então retirar um único número dessa lista, de forma aleatória também (não sabemos qual será o número retirado).

Na sequência, o programa executará uma função que varre essa lista e descobre qual o número que está faltando, informando-o ao usuário.

Qual o nosso objetivo com esse script? Estudar e praticar técnicas de programação. No caso iremos trabalhar com geração de números aleatórios, embaralhamento de listas, definição de funções e aplicação de lógica para resolver problemas.

Abaixo temos o código usado, e na sequência a explicação detalhada de seu funcionamento. Fique à vontade para alterar o código a seu gosto, modificando ou acrescentando funcionalidades ao script.

Código em Python

import random

# Função para encontrar o número que está faltando
def encontrar_numero_faltando(lista):
    # A soma esperada dos números de 1 a 1000
    soma_esperada = sum(range(1, 1001))
    # A soma dos números na lista com um número faltando
    soma_lista = sum(lista)
    # O número que está faltando será a diferença entre a soma esperada e a soma da lista
    return soma_esperada - soma_lista

# Gerar uma lista de 1 a 1000
lista_numeros = list(range(1, 1001))

# Embaralhar a lista de forma aleatória
random.shuffle(lista_numeros)

# Remove um número aleatório da lista
numero_removido = random.choice(lista_numeros)
lista_numeros.remove(numero_removido)

# Mostrar a lista
print(f'Lista de números: \n{lista_numeros}')

# Encontrar o número faltando e exibir para o usuário
numero_faltando = encontrar_numero_faltando(lista_numeros)
print(f'\nO número faltando é: {numero_faltando}')

Como funciona esse script

Inicialmente, importamos o módulo random, que será necessário para a geração e manipulação dos números aleatórios (na verdade, pseudoaleatórios) que necessitaremos.

Na sequência, definimos a função “encontrar_numero_faltando“, que recebe como argumento a lista de números que será analisada.

Para determinar o número que está ausente nesta lista (haverá apenas um único número ausente dentre os mil valores), podemos aplicar várias técnicas. Aqui, iremos calcular a soma dos números de 1 até 1000 (armazenada na variável soma_esperada), e na sequência somaremos todos os números da lista passada à função, armazenado esse valor na variável soma_lista.

Então, basta subtrair da soma_esperada o valor de soma_lista, e o resultado será o número que falta (ausente). A função então retorna esse valor.

Fora da função, geramos uma lista de 1 até 1000 usando a função list() combinada com a função range, embaralhamos os números com o método random.shuffle, e retiramos um número da lista com os métodos random.choice (escolhe o número) e lista_numeros.remove (remove esse número da lista).

Na sequência, exibimos a lista na tela com a função print, e finalmente encontramos o número faltante chamando a função criada encontrar_numero_faltando, exibindo no final seu valor para o usuário.

Note que cada vez que o script for executado, um número diferente será sacado da lista, pois a escolha do valor a ser retirado pelo método choice é aleatória.

Conclusão

Com este pequeno script pudemos treinar o emprego e manipulação de números aleatórios, além da criação de funções e da aplicação de raciocínio lógico para a resolução de problemas com programação.

Você pode alterar o algoritmo para, por exemplo, gerar mais de 1000 números (que tal 1 milhão de valores?) e rodá-lo para testar sua performance e verificar sua utilidade. Será que ele ainda roda de forma satisfatória?

Você também pode tentar portar esse script para outras linguagens de programação que prefira, como por exemplo JavaScript, C# ou Rust, para treinar abordagens ligeiramente diferentes de codificação.

O post Descobrir número que falta em lista de 1000 números sequenciais em Python apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste tutorial vou mostrar como criar um script relativamente simples em JavaScript que permite aos usuários gerarem uma lista com números primos, iniciando em 2 (que é o primeiro número primo) até um valor informado pelo usuário, que será o limite da lista gerada.

Um número é considerado primo se ele for maior que um e divisível (no caso, divisão inteira) apenas por si próprio e por 1. Por exemplo:

• O número 23 é um número primo, pois ele só é divisível por 23 (ele próprio) e por 1.
• Já o número 24 não é primo, pois além de ser divisível por si mesmo e por 1, ele também é divisível por outros números, como 2, 3, 4 e 6.

O número 1 não é considerado um número primo na matemática.

Script que gera números primos em JavaScript

O nosso script deverá realizar as seguintes tarefas:

1. Calcular e mostrar na tela os números primos de 2 até um valor fornecido pelo usuário, usando JavaScript
2. O numero fornecido pelo usuário será digitado em uma caixa de texto em uma página HTML
3. Os números gerados serão exibidos no corpo do documento, um por linha.
4. A geração dos valores se dará após o usuário clicar em um botão btnGeraPrimos.
5. O código JavaScript será declarado no cabeçalho da página HTML, para melhor organização do código, e invocado no botão.
6. Adicionar validação: se o usuário fornecer um número negativo, avisar que não é possível gerar a sequência de primos.
7. Mais validação: se o usuário informar um caractere que não seja um número, será avisado de que não é possível gerar a sequência de primos.

Também iremos estilizar o formulário e a saída gerada usando CSS, em um arquivo separado de folha de estilos, que chamaremos de estilos.css.

Vamos à codificação.

Códigos em HTML, CSS e JavaScript

1. Página HTML com JavaScript: arquivo index.html

<!DOCTYPE html>
<html lang="pt-BR">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Gerador de Números Primos</title>
    <link rel="stylesheet" href="estilos.css">
    <script>
        // Função para verificar se um número é primo
        function ePrimo(num) {
            if (num < 2) return false;
            for (let i = 2; i <= Math.sqrt(num); i++) {
                if (num % i === 0) return false;
            }
            return true;
        }

        // Função para gerar e exibir os números primos
        function gerarPrimos() {
            // Limpa as mensagens e a saída anterior
            document.getElementById('mensagemErro').innerHTML = '';
            document.getElementById('saida').innerHTML = '';
            // Obter o valor inserido pelo usuário
            let valor = document.getElementById('inputNumero').value;
            // Verificar se o valor é um número válido
            if (isNaN(valor) || valor.trim() === '') {
                document.getElementById('mensagemErro').innerHTML = 'Por favor, insira um número válido.';
                return;
            }
            valor = parseInt(valor);

            // Validação de número negativo
            if (valor < 2) {
                document.getElementById('mensagemErro').innerHTML = 'Por favor, insira um número maior que 1 para gerar números primos.';
                return;
            }
            let primos = [];
            // Calcular os números primos
            for (let i = 2; i <= valor; i++) {
                if (ePrimo(i)) {
                    primos.push(i);
                }
            }

            // Exibir os números primos
            const saida = document.getElementById('saida');
            if (primos.length > 0) {
                primos.forEach(function(primo) {
                    saida.innerHTML += primo + '<br>';
                });
            } else {
                saida.innerHTML = 'Nenhum número primo encontrado.';
            }
        }
    </script>
</head>

<body>
<div class="container">
    <h1>Gerador de Primos</h1>
    <label for="inputNumero">Digite um número:</label>
    <input type="text" id="inputNumero" placeholder="Ex: 50">
    <div class="error" id="mensagemErro"></div>
    <button id="btnGeraPrimos" onclick="gerarPrimos()">Gerar Primos</button>
    <div class="output" id="saida"></div>
</div>
</body>
</html>

2. Folha de estilos externa: arquivo estilos.css

body {
    font-family: Arial, sans-serif;
    background-color: #f4f4f4;
    margin: 0;
    padding: 0;
    display: flex;
    justify-content: center;
    align-items: center;
    height: 100vh;
}
.container {
    background-color: white;
    padding: 20px;
    border-radius: 10px;
    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
    max-width: 400px;
    width: 100%;
}
h1 {
    text-align: center;
    color: #333;
}
label {
    font-size: 16px;
    margin-bottom: 10px;
    display: block;
}
input[type="text"] {
    width: 100%;
    padding: 10px;
    margin-bottom: 10px;
    border: 1px solid #ccc;
    border-radius: 5px;
    font-size: 16px;
}
.error {
    color: red;
    font-size: 14px;
    margin-bottom: 10px;
}
.success {
    color: green;
}
button {
    width: 100%;
    padding: 10px;
    background-color: #4CAF50;
    color: white;
    border: none;
    border-radius: 5px;
    font-size: 16px;
    cursor: pointer;
}
button:hover {
    background-color: #45a049;
}
.output {
    margin-top: 20px;
    background-color: #f9f9f9;
    padding: 10px;
    border-radius: 5px;
    height: 200px;
    overflow-y: auto;
    border: 1px solid #ccc;
}

Teste da aplicação

Vamos abrir a página e pedir para que sejam gerados os números primos até 33:

Caso o usuário tente gerar a sequência fornecendo um número negativo ou um caractere não-numérico, será exibida a mensagem de erro e a sequência de números primos não será gerada:

Foi fornecido o número -5 (negativo), por isso a mensagem de erro.

Funcionamento do Código

HTML: O formulário possui um campo de entrada (input) no qual o usuário digita um número, e um botão para invocar a função JavaScript que gera os números primos. Há uma área para exibir os erros de validação logo abaixo e uma área de saída para exibir os números primos.

CSS: A página está estilizada para ter uma aparência limpa e amigável, como é sempre recomendável. Centralizamos o formulário na página e os elementos como caixas de texto e botões têm um design agradável, com cor de fundo verde para o botão e texto de mensagem de erro em vermelho – mas você pode alterar isso à vontade, evidentemente.

A saída dos números primos será em uma área de rolagem (output), que facilita a visualização dos números, caso sejam gerados muitos.

JavaScript: O código JavaScript foi inserido no cabeçalho da página, e consiste em duas funções com tarefas específicas:

• ePrimo: Função que verifica se um número é primo. Ela percorre os divisores do número até sua raiz quadrada.
• gerarPrimos: Função principal que é chamada ao clicar no botão. Ela valida a entrada do usuário, calcula os números primos até o valor fornecido, e os exibe no corpo da página.

Também são realizadas validações: Se o valor fornecido não for um número, ou se for um número negativo, uma mensagem de erro é exibida.

Conclusão

Neste post mostrei um script simples para gerar uma listagem de números primos, que você pode – e deve – usar para estudar a linguagem e se aprofundar nas suas técnicas de programação.

Nos próximos artigos veremos scripts para resolver diversos outros problemas, sempre com esse foco: o aprendizado da linguagem JavaScript.

Até!

O post Como gerar números primos em JavaScript apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Procedimentos armazenados são uma forma de armazenar a lógica do banco de dados no lado do servidor e podem ser executados por vários clientes. Eles são uma ferramenta muito útil para administradores e programadores de banco de dados, pois permitem encapsular a lógica complexa em uma única unidade chamável, reduzindo o código duplicado, aumentando a segurança e melhorando o desempenho.

Um procedimento armazenado no PostgreSQL é um bloco nomeado de instruções PL/pgSQL que podem ser executadas com um único comando. A sintaxe para criar um procedimento armazenado no PostgreSQL é a seguinte:

CREATE [OR REPLACE PROCEDURE] nome_procedimento(arg1 tipo_dado1, arg2 tipo_dado2, ...)
RETURNS tipo_dado_retorno
LANGUAGE plpgsql
AS $$
DECLARE
-- declaração de variáveis locais, se houver
BEGIN
-- declarações PL/pgSQL
END;
$$;

Onde:

• nome_procedimento é o nome do procedimento armazenado
• arg1, arg2, etc. são os parâmetros do procedimento armazenado
• tipo_dado1, tipo_dado2, etc. são os tipos de dados dos parâmetros
• tipo_dado_retorno é o tipo de dados do valor de retorno

e a seção DECLARE é usada para declarar variáveis locais, se necessário. A lógica real do procedimento armazenado é escrita dentro de blocos BEGIN e END, usando instruções da linguagem PL/pgSQL.

A cláusula LANGUAGE especifica o idioma do procedimento armazenado, que é plpgsql neste caso.

O símbolo $$

O símbolo $$ usado na última linha de um procedimento PL/pgSQL é usado para definir o início e o fim do corpo do procedimento. É uma sintaxe especial usada para definir uma string literal que abrange várias linhas. Na prática, é possível usar qualquer string com essa finalidade, desde que não seja uma palavra reservada da linguagem.

Em um procedimento PL/pgSQL, o $$ é usado para envolver todo o corpo do procedimento, que inclui a declaração de variáveis, a definição de estruturas de controle e qualquer outra lógica que você queira implementar. O primeiro $$ marca o início do corpo do procedimento e o segundo $$ marca o fim do corpo do procedimento.

Outra opção é usar a estrutura “BEGIN ATOMIC” … “END” no lugar de “AS $$“.

O que é PL/pgSQL?

PL/pgSQL é uma linguagem procedural usada no PostgreSQL para escrever stored procedures, triggers e funções. É uma linguagem estruturada em blocos semelhante a outras linguagens procedurais, como PL/SQL no Oracle e T-SQL no Microsoft SQL Server. Essa linguagem fornece estruturas de controle, como instruções IF-THEN-ELSE, LOOP e EXIT, bem como a capacidade de declarar variáveis, realizar tratamento de exceções e usar cursores.

O PL/pgSQL oferece uma interface procedural de alto nível para o banco de dados que permite criar lógica de negócios complexa e automatizar as operações do banco de dados. Por exemplo, podemos usar PL/pgSQL para implementar regras de negócios, validar dados ou realizar cálculos complexos em dados armazenados no banco de dados.

Assim, podemos escrever lógica que pode ser facilmente testada e reutilizada, tornando-a uma maneira eficiente de gerenciar operações de banco de dados.

Trata-se de uma linguagem do lado do servidor, o que significa que o código é executado no servidor de banco de dados, e não no cliente. Isso o torna mais rápido e eficiente do que executar o script do lado do cliente, dentro de uma aplicação de usuário, além de fornecer melhor segurança para seus dados.

Outras opções de linguagens suportadas pelo Postgres incluem SQL padrão e linguagem C, além da possibilidade de trabalhar com extensões para outras linguagens como PL/Python, PL/Perl, etc.

A instrução LANGUAGE plpgsql é necessária ao criar procedimentos armazenados no PostgreSQL porque define a linguagem de programação que será usada para escrever o corpo do procedimento.

Como executar o procedimento armazenado

Podemos chamar um procedimento armazenado no PostgreSQL usando a seguinte sintaxe:

CALL nome_procedimento(arg1_valor, arg2_valor, ...);

Aqui, arg1_valor, arg2_valor, etc. são os valores dos parâmetros passados para o procedimento armazenado. O resultado do procedimento armazenado será retornado na forma de uma tabela.

Vejamos agora alguns exemplos de criação e execução de procedimentos armazenados em PostgreSQL.

Exemplo 01 – Inserir uma linha em uma tabela

Procedimento armazenado em PostgreSQL (somente SQL) que insere uma nova linha em uma tabela, composta por três colunas: nome, sobrenome e idade:

Criar a tabela de teste:

CREATE TABLE pessoas (
    nome varchar(20),
    sobrenome varchar(40),
    idade smallint
);

Vamos a um exemplo de procedimento armazenado em PL/pgSQL que insere uma nova linha em uma tabela com três colunas: nome, sobrenome e idade. O procedimento armazenado usa três parâmetros: p_nome, p_sobrenome e p_idade e insere esses valores na tabela.

CREATE OR REPLACE PROCEDURE cadastra_pessoa(p_nome varchar(20), p_sobrenome varchar(40), p_idade smallint)
  LANGUAGE plpgsql
AS $$
BEGIN
    INSERT INTO pessoas (nome, sobrenome, idade)
    VALUES (p_nome, p_sobrenome, p_idade);
END
$$

Teste

Para executar o procedimento armazenado, basta chamá-lo com os valores desejados como parâmetros, assim:

CALL cadastra_pessoa('Fábio'::varchar, 'dos Reis'::varchar, 48::smallint);

E verificar se a tabela foi atualizada com o novo registro:

SELECT * FROM pessoas;

Especificar tipos de dados na chamada do procedimento

Ao chamar um procedimento armazenado no PostgreSQL, a necessidade de especificar explicitamente os tipos de dados para os argumentos (por exemplo, ‘Fábio’::varchar) geralmente surge devido a questões de desambiguação e coerção de tipos.

Os principais motivos para especificar tipos de dados ao chamar um procedimento armazenado no PostgreSQL são os seguntes:

1. Desambiguação: Quando o PostgreSQL possui múltiplos procedimentos com o mesmo nome, mas com assinaturas diferentes (ou seja, com diferentes tipos de parâmetros ou números de parâmetros), ele precisa saber exatamente qual procedimento deve ser chamado. Especificar o tipo de dado ajuda o PostgreSQL a escolher a versão correta do procedimento.
2. Coerção de Tipos: O PostgreSQL é uma linguagem fortemente tipada, o que significa que cada valor tem um tipo de dado associado, e algumas operações requerem tipos específicos. Quando se passa um literal (como ‘Fábio‘), ele é inicialmente interpretado como um text, a menos que se indique explicitamente um tipo diferente, como o varchar.
3. Prevenção de Erros de Tipagem: Quando o tipo de dado esperado pelo procedimento não corresponde ao tipo inferido pelo PostgreSQL, o banco de dados pode não ser capaz de fazer a coerção automaticamente, resultando em erros. Especificar o tipo assegura que o valor será tratado corretamente.

Exemplo 02 – Inserir um novo produto na tabela

Vamos criar um procedimento armazenado que permita inserir um novo produto na tabela de produtos de nosso banco de dados.

CREATE OR REPLACE PROCEDURE inserir_produto (
    p_cod_produto INT,
    p_nome_produto VARCHAR(30),
    p_descricao TEXT,
    p_preco NUMERIC,
    p_qtde_estoque SMALLINT
)
language plpgsql
AS $$
BEGIN
    INSERT INTO Produtos(cod_produto, nome_produto, descricao, preco, qtde_estoque)
    VALUES (p_cod_produto, p_nome_produto, p_descricao, p_preco, p_qtde_estoque);
    RAISE NOTICE 'Produto % cadastrado com sucesso.', p_nome_produto;
END;
$$;

A instrução RAISE NOTICE emite uma mensagem para o console confirmando a inserção do registro.

Para executar o procedimento:

CALL inserir_produto(4,'Detergente'::varchar,'Detergente neutro 500 ml'::text, 2.35, 2::smallint);

E então podemos verificar se produto foi inserido corretamente realizando uma consulta simples ao banco de dados:

SELECT * FROM Produtos;

Exemplo 03 – Atualizar o preço de um produto.

Este procedimento atualiza o preço de um produto específico, identificado pelo seu código de produto:

CREATE OR REPLACE PROCEDURE atualizar_preco(
    p_cod_produto INT,
    p_novo_preco NUMERIC
)
LANGUAGE plpgsql
AS $$
BEGIN
    UPDATE Produtos
    SET preco = p_novo_preco
    WHERE cod_produto = p_cod_produto;
    RAISE NOTICE 'Preço do produto % atualizado para %', p_cod_produto, p_novo_preco;
END;
$$;

Para executar o procedimento:

CALL atualizar_preco(1, 3.80);

E então podemos verificar se produto teve seu preço corretamente atualizado realizando novamente uma consulta ao banco de dados:

SELECT * FROM Produtos;

Exemplo 04 – Procedimento para consultar produtos com estoque baixo

Este procedimento retorna todos os produtos com quantidade em estoque abaixo de um valor especificado na chamada da procedure.

CREATE OR REPLACE PROCEDURE consultar_estoque_baixo (
    p_limite_estoque INTEGER
)
LANGUAGE plpgsql
AS $$
DECLARE resultado RECORD;
BEGIN
    FOR resultado in
        SELECT cod_produto, nome_produto, qtde_estoque
        FROM Produtos
        WHERE qtde_estoque < p_limite_estoque
    LOOP
        RAISE NOTICE 'Produto: %, Estoque: % ', resultado.nome_produto, resultado.qtde_estoque;
    END LOOP;
END;
$$;

Para executar o procedimento:

CALL consultar_estoque_baixo(3);

Aqui, consultamos todos os produtos cujo estoque está abaixo de 3 unidades.

Devemos notar alguns detalhes interessantes sobre a consulta realizada pelo procedimento armazenado deste exemplo:

Destino dos dados

Quando se usa a instrução SELECT em um procedimento armazenado no PostgreSQL, o resultado deve ser direcionado para algum lugar, como uma variável, uma tabela temporária, ou ser retornado ao chamador da função ou procedimento.

Caso contrário, o PostgreSQL gera a mensagem “consulta não tem destino para os dados resultantes” (no inglês: “query has no destination for result data“).

Se for necessário apenas exibir os resultados no console em um procedimento armazenado, sem retorná-los em uma consulta, podemos usar um loop para iterar sobre os resultados e então exibi-los com RAISE NOTICE.

O tipo RECORD

O tipo RECORD é um tipo de dado genérico no PL/pgSQL que pode acomodar uma linha de dados com colunas de diferentes tipos. Ao contrário de outros tipos de variáveis, que têm um tipo de dado específico (como INTEGER, VARCHAR, etc.), o RECORD pode armazenar qualquer linha inteira de resultado, independentemente de quantas colunas ou de quais tipos de dados essas colunas têm.

A instrução DECLARE r RECORD; em PL/pgSQL é usada para declarar uma variável de tipo RECORD.

Quando usamos o RECORD dentro de um loop FOR IN que itera sobre os resultados de uma consulta, o RECORD é automaticamente “preenchido” com os valores das colunas para cada linha retornada. Isso permite acessar os valores dessas colunas dentro do corpo do loop.

Além disso, uma vez que a linha é armazenada no RECORD, podemos acessar as colunas individuais usando a notação r.coluna, onde r é o nome da variável RECORD e coluna é o nome da coluna que desejamos acessar.

Exemplo 05 – Inserir e atualizar valores no mesmo procedimento.

Exemplo: criar um procedimento armazenado que insira um novo produto na tabela de produtos, ao mesmo tempo em que aplica um desconto percentual especificado a todos os produtos logo após.

CREATE OR REPLACE PROCEDURE insere_atualiza (cod int, prod varchar(30), descr text, valor numeric, qtde smallint, desc_perc numeric)
LANGUAGE plpgsql
AS $$
BEGIN
    INSERT INTO produtos(cod_produto, nome_produto, descricao, preco, qtde_estoque)
    VALUES (cod, prod, descr, valor, qtde);
    UPDATE produtos SET preco = preco * (100 - desc_perc) / 100;
END;
$$;

Executar o procedimento:

CALL insere_atualiza(6,'Alvejante'::varchar(30),'Alvejante de roupas'::text, 12.30, 12::smallint, 10);

Obs.: O tipo numeric geralmente não precisa ser informado (cast) na chamada do procedimento.

Como excluir um procedimento armazenado

Para excluir um procedimento armazenado no PostgreSQL devemos usar a declaração DROP PROCEDURE, como segue:

DROP PROCEDURE nome_procedimento;

Por exemplo, para excluir o procedimento consultar_estoque_baixo:

DROP PROCEDURE consultar_estoque_baixo;

Se houver mais de um procedimento armazenado como mesmo nome, mas com quantidade e tipos de parâmetros distintos (polimorfismo), devemos indicar os tipos de dados dos argumentos ao exclui-lo:

DROP PROCEDURE insere_atualiza(int,varchar,text,numeric,smallint,numeric);

Conclusão

Neste artigo vimos como começar a trabalhar com procedimentos armazenados no PostgreSQL. com alguns exemplos simples de criação de procedures simples. O recurso é muito útil para simplificar código e facilitar a programação de tarefas no banco de dados, principalmente quando as declarações SQL precisam ser executadas a partir de uma aplicação escrita em alguma linguagem de programação para acesso direto dos usuários.

Estudaremos recursos mais avançados de procedimentos armazenados nos próximos artigos, assim como outras formas de programação existentes para bancos de dados PostgreSQL, como Funções e Triggers.

Para saber mais sobre Procedimentos Armazenados no PostgreSQL, assista ao vídeo a seguir da Bóson Treinamentos no YouTube:

O post Procedimentos Armazenados em PostgreSQL (Stored Procedures) apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Os tipos de dados CHAR, NCHAR, VARCHAR e NVARCHAR são usados para armazenar dados de texto no SQL Server. Cada um é empregado em uma situação distinta, e saber escolher o tipo de dados adequado pode afetar a performance e o uso de espaço no banco de dados.

Neste tutorial vou mostrar cada um desses tipos, suas diferenças e quando usá-los.

Tipos de Texto no SQL Server

Os tipos nchar e nvarchar permitem armazenar caracteres Unicode, ao passo que char e varchar não o permitem – é até possível armazenar Unicode com esses tipos, mas por meio de alguns “truques” no código. Porém, os tipos nchar e nvarchar ocupam o dobro de espaço de armazenamento. Desta forma, recomenda-se utilizá-los apenas caso seja necessário suporte a Unicode na tabela – o que é bastante comum.

Os tipos char e nchar são tipos de tamanho fixo, o que significa que eles reservam espaço de armazenamento para a quantidade de caracteres que foi especificada em suas declarações, mesmo que o espaço não seja totalmente utilizado. Por exemplo, podemos criar um campo char ou nchar para 20 caracteres mas armazenar apenas 15 – os outros 5 que ficaram vagos irão ocupar espaço da mesma maneira.

Recomenda-se usar esses tipos caso os dados armazenados sempre ocupem o tamanho máximo especificado na declaração da coluna.

Já os tipos varchar e nvarchar são tipos de tamanho variável, de modo que o espaço ocupado corresponderá à quantidade de caracteres que efetivamente são armazenados + 2 (2 bytes de registro do comprimento – overhead), independente do tamanho máximo declarado.

Características dos tipos CHAR, NCHAR, VARCHAR e NVARCHAR

CHAR

• Descrição: Armazena dados de texto com comprimento fixo.
• Tamanho: O comprimento é definido ao criar a coluna e todos os valores terão exatamente esse tamanho – ou seja, o comprimento é fixo. Espaços em branco são adicionados para preencher o comprimento se necessário.
• Uso: Dados de tamanho fixo, como códigos de produtos ou identificadores.

NCHAR

• Descrição: Similar ao CHAR (também comprimento fixo), mas armazena dados de texto em formato Unicode.
• Tamanho: Cada caractere ocupa 2 bytes, permitindo armazenar caracteres de múltiplos idiomas.
• Uso: Usado para dados de texto internacionalizados ou quando é necessário suportar vários idiomas.

VARCHAR

• Descrição: Armazena dados de texto com comprimento variável.
• Tamanho: O comprimento máximo é definido ao criar a coluna, mas apenas o espaço necessário para armazenar o valor real é utilizado. Ou seja, ocupa espaço de acordo com o valor armazenado na coluna.
• Uso: Ideal para colunas onde os tamanhos dos valores podem variar significativamente, como nomes, descrições ou endereços.

NVARCHAR

• Descrição: Similar ao VARCHAR, mas armazena dados de texto em formato Unicode.
• Tamanho: Cada caractere ocupa 2 bytes, semelhante ao NCHAR, mas o espaço é utilizado de forma mais eficiente para comprimentos variáveis.
• Uso: Usado para dados de texto internacionalizados ou quando é necessário suportar vários idiomas, com comprimentos variáveis.

Performance dos tipos de texto

Com relação à performance desses tipos de texto no SQL Server, temos que:

• CHAR e NCHAR podem ser mais rápidos para acesso em colunas onde todos os valores têm tamanho fixo.
• Já os tipos VARCHAR e NVARCHAR são mais eficientes em termos de espaço para colunas onde os tamanhos dos valores variam.

Exemplos de uso

1. Tipos CHAR e NCHAR

Criamos uma tabela com dois campos, um do tipo CHAR e outro do tipo NCHAR

CREATE TABLE ExemploCharNChar (
Codigo CHAR(5),
Item NCHAR(10)
);

Inserimos uma linha de teste nessa tabela. Para o campo “Item” usarei um dado em outro idioma, inclusive com outro conjunto de caracteres – no caso, caracteres japoneses.

Note o caractere ‘N’ que precede o valor a ser armazenado, para indicar ao SQL Server que se trata de um valor Unicode.

INSERT INTO ExemploCharNChar (Codigo, Item)
VALUES ('012', N'ピザ');

Consegue descobrir que item foi inserido?

E realizamos uma consulta para ver o dado inserido.

SELECT * FROM ExemploCharNChar;

Resultado:

Codigo  Item
012     ピザ 

2. Tipos VARCHAR e NVARCHAR

Agora vamos criar outra tabela também com dois campos, um do tipo VARCHAR e outro do tipo NVARCHAR

CREATE TABLE ExemploVarcharNVarchar (
Descricao VARCHAR(50),
Pedido NVARCHAR(100)
);

Inserimos uma linha de teste nessa tabela. Para o campo “Pedido” usarei novamente um dado em idioma japonês, desta vez com mais caracteres.

INSERT INTO ExemploVarcharNVarchar (Descricao, Pedido)
VALUES ('Prato Típico Italiano', N'ピザが食べたい.');

E realizamos a consulta para ver o dado inserido.

SELECT * FROM ExemploVarcharNVarchar;

Resultado:

Descricao             Pedido
Prato Típico Italiano ピザが食べたい.

Importante

Uma dica importante é a seguinte: Hoje em dia, os sistemas operacionais e plataformas de desenvolvimento usam internamente o sistema Unicode.

Sendo assim, se usarmos os tipos nvarchar em vez de varchar, e nchar em vez de char, evitamos que ocorram conversões de codificação sempre que operaçoes de leitura ou escrita forem realizadas no banco de dados.

Essas conversões consomem recursos do servidor e podem ocasionar erros, ainda que raramente, além do que não é fácil recuperar de erros de conversão em uma tabela.

Conclusão

Neste tutorial estudamos os tipos de dados CHAR, NCHAR, VARCHAR e NVARCHAR no SQL Server, suas diferenças e exemplos de uso.

Ao escolher o tipo de dados para colunas de texto, considere o tamanho dos dados que você espera armazenar, a necessidade de suporte a múltiplos idiomas e a eficiência de armazenamento. Para texto que precisa ser armazenado em múltiplos idiomas, use os tipos NCHAR ou NVARCHAR. Para texto de tamanho fixo, use CHAR, e para tamanho variável, use VARCHAR.

Lembre-se:

• Usamos CHAR e NCHAR quando o comprimento dos dados for fixo.
• Usamos VARCHAR e NVARCHAR quando o comprimento dos dados for variável.
• A letra ‘N’ antes dos tipos Unicode (NCHAR e NVARCHAR) indica que eles suportam caracteres Unicode.

* ピザ significa “pizza” e ピザが食べたい significa “quero comer pizza” (“piza ga tabetai”).

Colabore com a Bóson Treinamentos

Ajude o canal adquirindo meus cursos na Udemy:

• Bancos de Dados com MySQL Básico: https://bit.ly/35QdWE4
• Lógica de Programação com Português Estruturado: https://bit.ly/3QKPn22
• Programação em Python do Zero: https://bit.ly/python-boson

Adquira também livros e outros itens na loja da Bóson Treinamentos na Amazon e ajude o canal a se manter e crescer: https://www.amazon.com.br/shop/bosontreinamentos

O post Como usar os tipos de dados char, nchar, varchar e nvarchar no SQL Server apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.