DEV Community: rodrigozan

Como ler scripts SQL Server grandes com Python

rodrigozan — Wed, 07 May 2025 11:00:00 +0000

Como Criar um Script Python para Ler Scripts Grandes do SQL Server Gerados no SQL Management Studio

Recentemente precisei trabalhar com alguns scripts grandes de SQL Server. Isso se mostrou um grande desafio, especialmente quando você precisa analisar ou manipular esses scripts automaticamente.

A solução que encontrei foi usar um script Python para ler e processar esses arquivos. Isso facilitou o gerenciamento e a análise de dados de maneira eficiente.

Neste artigo, vou compartilhar como criei um script Python que lê grandes arquivos SQL gerados pelo SQL Management Studio (SSMS).

Atenção: se você ainda não tem o Python instalado no seu computador, considere ler o artigo abaixo para instalá-lo:

Como instalar o Python no Windows, Linux e Mac

Pré-requisitos

Python 3.x instalado em seu sistema.
Conhecimento básico de Python e SQL Server.
Ter o SQL Server Management Studio instalado, caso queira gerar scripts diretamente de lá.

Passo 1: Instalar as Bibliotecas Necessárias

A primeira coisa que vamos precisar é de algumas bibliotecas Python. Para lidar com arquivos SQL e SQL Server de forma geral, você pode instalar bibliotecas como pyodbc para conexão com o banco de dados e os para manipulação de arquivos.

Abra o terminal e instale o pyodbc com o seguinte comando:

pip install pyodbc

Passo 2: Conectar ao SQL Server

Se você deseja executar esses scripts diretamente no SQL Server, o pyodbc será uma ótima opção. O código abaixo mostra como se conectar ao SQL Server utilizando pyodbc:

import pyodbc

# Parâmetros de conexão
server = 'localhost'  # Substitua pelo seu servidor SQL
database = 'master'  # Substitua pelo nome do banco de dados
username = 'sa'  # Substitua pelo seu nome de usuário
password = 'senha'  # Substitua pela sua senha

# Conectar ao SQL Server
conn = pyodbc.connect(f'DRIVER={{ODBC Driver 17 for SQL Server}};SERVER={server};DATABASE={database};UID={username};PWD={password}')

# Criar um cursor para executar comandos SQL
cursor = conn.cursor()

Passo 3: Ler o Script SQL do Arquivo

Agora, vamos criar um script para ler um arquivo SQL grande gerado no SQL Server Management Studio. Usaremos a função open() do Python para abrir o arquivo, ler seu conteúdo e armazená-lo em uma variável.

def ler_arquivo_sql(caminho_arquivo):
    with open(caminho_arquivo, 'r', encoding='utf-8') as file:
        sql_script = file.read()
    return sql_script

A função ler_arquivo_sql abre o arquivo SQL em modo leitura ('r'), define o encoding como utf-8 (um padrão comum para evitar problemas com caracteres especiais) e lê todo o conteúdo com file.read().

Passo 4: Executar o Script SQL no SQL Server

Com o script carregado, agora podemos enviar o conteúdo para o SQL Server para execução. Você pode dividir o script SQL em comandos individuais, mas para fins deste exemplo, vamos executar o script inteiro de uma vez.

def executar_script_sql(cursor, sql_script):
    try:
        cursor.execute(sql_script)
        cursor.commit()
        print("Script executado com sucesso.")
    except Exception as e:
        print(f"Erro ao executar o script: {e}")

O método cursor.execute() envia o script SQL para o SQL Server. Se houver algum erro, ele será capturado pela exceção e uma mensagem de erro será exibida.

Passo 5: Combinar Tudo em Um Script Python

Agora, vamos combinar as partes anteriores em um único script Python que lê o arquivo SQL, conecta ao banco de dados, executa o script e exibe o resultado.

import pyodbc

# Função para ler o script SQL do arquivo
def ler_arquivo_sql(caminho_arquivo):
    with open(caminho_arquivo, 'r', encoding='utf-8') as file:
        sql_script = file.read()
    return sql_script

# Função para executar o script SQL no SQL Server
def executar_script_sql(cursor, sql_script):
    try:
        cursor.execute(sql_script)
        cursor.commit()
        print("Script executado com sucesso.")
    except Exception as e:
        print(f"Erro ao executar o script: {e}")

# Parâmetros de conexão com o SQL Server
server = 'localhost'  # Substitua pelo seu servidor SQL
database = 'master'  # Substitua pelo nome do banco de dados
username = 'sa'  # Substitua pelo seu nome de usuário
password = 'senha'  # Substitua pela sua senha

# Conectar ao SQL Server
conn = pyodbc.connect(f'DRIVER={{ODBC Driver 17 for SQL Server}};SERVER={server};DATABASE={database};UID={username};PWD={password}')
cursor = conn.cursor()

# Caminho do arquivo SQL
caminho_arquivo = 'caminho/do/seu/script.sql'  # Substitua pelo caminho do seu arquivo

# Ler o script SQL
sql_script = ler_arquivo_sql(caminho_arquivo)

# Executar o script SQL
executar_script_sql(cursor, sql_script)

# Fechar a conexão
cursor.close()
conn.close()

Passo 6: Rodando o Script

Após criar seu script Python, basta executá-lo em seu terminal:

python seu_script.py

Isso irá carregar o script SQL do arquivo e executá-lo no SQL Server.

Dicas para Lidar com Arquivos SQL Grandes

Erros são algo muito comum de acontecerem quando lidamos com scripts muito grandes. Recentemente tive que lidar com um arquivo que tinha mais de 130 mil linhas. Não rodava no SQL Server Management Studio de jeito nenhum. Por isso, tive que buscar alternativas para ler e executar as operações do script passo a passo.

Vamos aprimorar o script que criamos para lidar com arquivos SQL grandes, adicionando de um sistema de monitoramento de erros:

Passo 1: Leitura em Blocos

Em vez de carregar todo o arquivo de uma vez, vamos ler o arquivo em blocos menores. Isso economiza memória, especialmente se o script SQL for muito grande. Podemos usar readline() ou readlines(), como mencionei anteriormente.

Passo 2: Dividir o Script SQL

Para lidar com múltiplos comandos SQL no mesmo arquivo, podemos dividir o conteúdo usando o delimitador ; (ponto e vírgula), que é usado para separar comandos SQL em um script.

Passo 3: Monitoramento de Erros

Adicionar um sistema de logs que grava as mensagens de erro e sucesso, para que você possa acompanhar a execução do script.

Código Atualizado

Com base no que comentei acima, vamos atualizar nosso programa Python.

import pyodbc
import logging

# Configuração do Logger
logging.basicConfig(filename='executar_script.log', level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger()

# Função para ler o script SQL em blocos menores
def ler_arquivo_sql_em_blocos(caminho_arquivo, tamanho_bloco=1024):
    """Lê o arquivo SQL em blocos menores para economizar memória."""
    with open(caminho_arquivo, 'r', encoding='utf-8') as file:
        while True:
            bloco = file.read(tamanho_bloco)
            if not bloco:
                break
            yield bloco  # Retorna um bloco de cada vez

# Função para dividir o script SQL em instruções individuais
def dividir_script_em_comandos(sql_script):
    """Divide o script SQL em comandos separados por ponto e vírgula."""
    comandos = sql_script.split(';')
    return [comando.strip() for comando in comandos if comando.strip()]  # Remove espaços e comandos vazios

# Função para executar o script SQL no SQL Server
def executar_script_sql(cursor, sql_script):
    """Executa um script SQL no SQL Server e captura erros."""
    try:
        cursor.execute(sql_script)
        cursor.commit()
        logger.info("Script executado com sucesso.")
    except Exception as e:
        logger.error(f"Erro ao executar o script: {e}")
        print(f"Erro: {e}")

# Função principal para rodar o script SQL
def rodar_script_sql(caminho_arquivo):
    """Roda o script SQL dividido em blocos e comandos SQL separados."""
    # Parâmetros de conexão com o SQL Server
    server = 'localhost'  # Substitua pelo seu servidor SQL
    database = 'master'  # Substitua pelo nome do banco de dados
    username = 'sa'  # Substitua pelo seu nome de usuário
    password = 'senha'  # Substitua pela sua senha

    # Conectar ao SQL Server
    conn = pyodbc.connect(f'DRIVER={{ODBC Driver 17 for SQL Server}};SERVER={server};DATABASE={database};UID={username};PWD={password}')
    cursor = conn.cursor()

    # Inicializar o script SQL
    sql_script = ""

    # Lê o arquivo SQL em blocos e armazena o conteúdo
    for bloco in ler_arquivo_sql_em_blocos(caminho_arquivo):
        sql_script += bloco

    # Dividir o script em comandos SQL separados
    comandos_sql = dividir_script_em_comandos(sql_script)

    # Executar cada comando SQL
    for comando in comandos_sql:
        executar_script_sql(cursor, comando)

    # Fechar a conexão
    cursor.close()
    conn.close()

# Caminho do arquivo SQL
caminho_arquivo = 'caminho/do/seu/script.sql'  # Substitua pelo caminho do seu arquivo

# Rodar o script SQL
rodar_script_sql(caminho_arquivo)

Explicações Detalhadas de Cada Dica Implementada:

1. Leitura em Blocos (Função `ler_arquivo_sql_em_blocos`)

Essa função permite que o arquivo SQL seja lido em partes menores, o que é útil para economizar memória quando o arquivo é muito grande. A função yield permite que o arquivo seja lido de forma eficiente, sem carregar todo o conteúdo na memória de uma vez.

Tamanho do bloco: O parâmetro tamanho_bloco define quantos bytes serão lidos por vez. No exemplo, estamos usando 1024 bytes por vez, mas você pode ajustar conforme necessário.
Uso de yield: A palavra-chave yield permite que a função retorne partes do arquivo à medida que são lidas, sem carregar todo o conteúdo de uma vez.

2. Divisão do Script SQL em Comandos Individuais (Função `dividir_script_em_comandos`)

Quando temos um script com múltiplos comandos SQL, podemos usar o delimitador ; para dividir o script em comandos individuais. Isso nos permite executar cada comando separadamente, o que pode ser útil para identificar e depurar falhas em partes específicas do script.

Função split(';'): A função divide o script completo em várias partes sempre que encontra um ponto e vírgula (;), removendo espaços em branco antes e depois dos comandos.

3. Monitoramento de Erros (Uso do Logger)

Estamos usando o módulo logging para monitorar a execução do script e gravar logs de erros e sucessos em um arquivo chamado executar_script.log.

logging.basicConfig(): Configura o logger para escrever os logs em um arquivo com nível de log INFO (para mensagens normais) e ERROR (para erros).
logger.info() e logger.error(): Usamos esses métodos para registrar as mensagens de sucesso e erro durante a execução dos comandos SQL.

4. Execução do Script SQL (Função `executar_script_sql`)

Agora, para cada comando SQL no arquivo, tentamos executá-lo com cursor.execute(). Se ocorrer algum erro durante a execução de qualquer comando, ele será capturado pela exceção e registrado no log.

Passo 4: Rodando o Script

Para rodar o script, basta chamar a função rodar_script_sql(caminho_arquivo), onde caminho_arquivo é o caminho para o arquivo SQL. O Python irá ler o arquivo em blocos, dividir os comandos e executá-los um a um, registrando o sucesso ou falha de cada execução.

Teste e Logs

Ao rodar o script, um arquivo executar_script.log será criado, onde você poderá verificar as mensagens de sucesso e qualquer erro que ocorrer.

2025-05-05 12:30:45,678 - INFO - Script executado com sucesso.
2025-05-05 12:32:05,123 - ERROR - Erro ao executar o script: [Microsoft][ODBC Driver 17 for SQL Server]A sintaxe SQL está incorreta.

Esses logs irão ajudar a identificar rapidamente qual comando falhou, caso isso aconteça.

Resumindo...

Este script Python agora está otimizado para lidar com arquivos SQL grandes, dividindo o conteúdo em blocos menores e executando os comandos de forma eficiente. Além disso, o sistema de logs ajuda no monitoramento de erros e sucesso durante a execução, tornando o processo de automatização mais robusto e fácil de gerenciar.

Eliminando linhas de comentários e comandos irrelevantes

Ao exportar um banco de dados do SQL Server Management Studio, é comum que os scripts venham com comandos GO, que é específico do SQL Server Management Studio e não deve ser executado diretamente como um comando SQL.

Para validar isso, linhas vazias, e linha de comentários, vamos implementar algumas verificações dentro do nosso script.

Passos para implementar as validações

1. Ignorar Comentários (--): Podemos verificar se uma linha começa com -- (comentários no SQL Server) e ignorá-la.

2. Ignorar Linhas Vazias: Podemos verificar se a linha está vazia ou contém apenas espaços em branco e ignorá-la.

3. Ignorar o Comando "GO": O comando "GO" é usado no SQL Server para dividir batches de comandos, mas não é um comando SQL válido por si só. Devemos ignorá-lo ou usá-lo como um ponto de divisão para executar um bloco de SQL acumulado.

import pyodbc
import logging

# Configuração do Logger
logging.basicConfig(filename='executar_script.log', level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger()

# Função para ler o script SQL em blocos menores
def ler_arquivo_sql_em_blocos(caminho_arquivo, tamanho_bloco=1024):
    """Lê o arquivo SQL em blocos menores para economizar memória."""
    with open(caminho_arquivo, 'r', encoding='utf-8') as file:
        while True:
            bloco = file.read(tamanho_bloco)
            if not bloco:
                break
            yield bloco  # Retorna um bloco de cada vez

# Função para dividir o script SQL em comandos individuais, ignorando comentários e 'GO'
def dividir_script_em_comandos(sql_script):
    """Divide o script SQL em comandos separados, ignorando comentários e 'GO'."""
    comandos = []
    sql_block = []  # Acumula o SQL entre 'GO'

    # Processa linha por linha
    for line in sql_script.splitlines():
        clean_line = line.strip()

        # Ignora linhas vazias e comentários
        if not clean_line or clean_line.startswith("--"):
            continue

        # Verifica se é o comando 'GO' (ignorar)
        if clean_line.upper() == "GO":
            if sql_block:
                comandos.append('\n'.join(sql_block))
                sql_block = []  # Limpar o bloco
        else:
            sql_block.append(clean_line)  # Acumula linhas no bloco

    # Se restar algum SQL no bloco, adiciona à lista de comandos
    if sql_block:
        comandos.append('\n'.join(sql_block))

    return comandos

# Função para executar o script SQL no SQL Server
def executar_script_sql(cursor, sql_script):
    """Executa um script SQL no SQL Server e captura erros."""
    try:
        cursor.execute(sql_script)
        cursor.commit()
        logger.info("Script executado com sucesso.")
    except Exception as e:
        logger.error(f"Erro ao executar o script: {e}")
        print(f"Erro: {e}")

# Função principal para rodar o script SQL
def rodar_script_sql(caminho_arquivo):
    """Roda o script SQL dividido em blocos e comandos SQL separados."""
    # Parâmetros de conexão com o SQL Server
    server = 'localhost'  # Substitua pelo seu servidor SQL
    database = 'master'  # Substitua pelo nome do banco de dados
    username = 'sa'  # Substitua pelo seu nome de usuário
    password = 'senha'  # Substitua pela sua senha

    # Conectar ao SQL Server
    conn = pyodbc.connect(f'DRIVER={{ODBC Driver 17 for SQL Server}};SERVER={server};DATABASE={database};UID={username};PWD={password}')
    cursor = conn.cursor()

    # Inicializar o script SQL
    sql_script = ""

    # Lê o arquivo SQL em blocos e armazena o conteúdo
    for bloco in ler_arquivo_sql_em_blocos(caminho_arquivo):
        sql_script += bloco

    # Dividir o script em comandos SQL separados, ignorando comentários, linhas vazias e 'GO'
    comandos_sql = dividir_script_em_comandos(sql_script)

    # Executar cada comando SQL
    for comando in comandos_sql:
        executar_script_sql(cursor, comando)

    # Fechar a conexão
    cursor.close()
    conn.close()

# Caminho do arquivo SQL
caminho_arquivo = 'caminho/do/seu/script.sql'  # Substitua pelo caminho do seu arquivo

# Rodar o script SQL
rodar_script_sql(caminho_arquivo)

O script irá:

Ignorar os comentários (linhas começando com --).
Ignorar o comando GO e tratá-lo como um ponto de divisão.
Executar os comandos SELECT e INSERT separadamente, como blocos distintos.

Conclusão

Neste tutorial, mostramos como criar um script Python que lê e executa scripts SQL grandes gerados pelo SQL Server Management Studio. Essa abordagem pode ser extremamente útil para automatizar o processo de execução de scripts no SQL Server, especialmente quando estamos lidando com arquivos grandes.

Ao usar Python e bibliotecas como pyodbc, você pode integrar o seu processo de desenvolvimento com a flexibilidade do Python, tornando a administração de banco de dados mais eficiente.

Como instalar o Python no Windows, Linux e Mac

rodrigozan — Mon, 05 May 2025 12:31:26 +0000

Você já pensou em criar um site, automatizar tarefas do dia a dia, programar um robô ou até desenvolver um sistema de inteligência artificial? Pois é, tudo isso é possível com uma linguagem poderosa e acessível: o Python.

Tenho usado muito o Python e me surpreendido com sua versatilidade e poder para ajudar no meu dia a dia como programador. Minha única tristeza é não ter começado a utilizá-lo antes.

O Python é uma das linguagens de programação mais populares do mundo. Sei que você sabe disso. Ele é fácil de aprender, gratuito, de código aberto e está presente em diversas áreas como:

Desenvolvimento web (com frameworks como Django e Flask)
Análise de dados e ciência de dados
Inteligência artificial e machine learning
Automação de tarefas
Criação de bots
Jogos e aplicativos

Não importa se você é iniciante ou já experiente em programação, instalar o Python é o primeiro passo para dar vida às automações e ideias incríveis. E o melhor: ele funciona em praticamente todos os sistemas operacionais. Neste guia, eu vou te mostrar como instalar o Python no Windows, Linux e Mac, de forma simples e direta.

Como instalar o Python no Windows

No Windows, instalar o Python é bem fácil. Siga o passo a passo:

Acesse o site oficial: https://www.python.org/downloads/
Clique em "Download Python 3.x.x" (o site detecta automaticamente a versão ideal).
Execute o instalador baixado.
Importante: marque a opção "Add Python to PATH" antes de clicar em “Install Now”.
Aguarde a instalação.
Abra o Prompt de Comando (cmd) e digite:

   python --version

Se aparecer algo como Python 3.12.0, deu tudo certo!

Agora você pode usar o IDLE (editor padrão do Python) ou instalar o VS Code para começar seus projetos.

Como instalar o Python no Linux

No Linux, muitas distribuições já vêm com o Python instalado. Para verificar, abra o terminal e digite:

python3 --version

Se o comando retornar a versão do Python, está tudo certo. Caso contrário, você pode instalar com o gerenciador de pacotes da sua distribuição.

Ubuntu / Debian / Linux Mint

sudo apt update
sudo apt install python3

Fedora

sudo dnf install python3

Arch Linux / Manjaro

sudo pacman -S python

Depois da instalação, confirme com:

python3 --version

Você também pode rodar o interpretador diretamente com:

python3

E começar a testar comandos, como:

print("Olá, mundo!")

Como instalar o Python no Mac

O macOS vem com o Python 2.x instalado por padrão, mas a versão recomendada é o Python 3. A melhor forma de instalar é usando o gerenciador de pacotes Homebrew.

1. Instalar o Homebrew (caso ainda não tenha)

Abra o Terminal e digite:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

2. Instalar o Python com o Homebrew

brew install python

3. Verificar a instalação

python3 --version

Com isso, o Python está pronto para ser usado no seu Mac. Você pode abrir o terminal e digitar python3 para usar o interpretador interativo, ou instalar editores como o VS Code e começar a programar de forma mais completa.

Agora que você tem o Python instalado no seu sistema, que tal começar com um projeto simples? Você pode automatizar o envio de e-mails, criar gráficos com dados do Excel, desenvolver um site pessoal ou até um bot para o Telegram.

🛠️ Criando uma API Node.js com Express + CORS e consumindo com HTML + Bootstrap

rodrigozan — Tue, 22 Apr 2025 14:31:01 +0000

Neste artigo, vamos aprender a criar uma API básica em Node.js utilizando o framework Express e o middleware CORS. Em seguida, vamos consumir essa API em uma página HTML que permite realizar operações CRUD (Criar, Ler, Atualizar e Deletar) usando a Fetch API e o Bootstrap para estilização.

🤖 O que é uma API?

API significa Application Programming Interface (em português, Interface de Programação de Aplicações).

Em resumo, uma API é um conjunto de regras que permite que dois sistemas diferentes "conversem" entre si.

🧠 Uma explicação simples

Pense na API como um garçom em um restaurante:

Você (cliente) olha o cardápio (interface).
Faz um pedido (requisição).
O garçom (API) leva seu pedido para a cozinha (o sistema).
Depois, ele traz a comida pronta (resposta).

Você não precisa saber como a cozinha funciona, apenas como fazer o pedido certo. A API cuida do resto.

🛠 Em termos técnicos

Uma API define rotas/endpoints e métodos (como GET, POST, PUT, DELETE) para:

Buscar dados
Criar dados
Atualizar dados
Deletar dados

Exemplo de chamadas:

Método	URL	Ação
GET	/api/items	Pega todos os itens
POST	/api/items	Cria um novo item
PUT	/api/items/:id	Atualiza um item
DELETE	/api/items/:id	Deleta um item

📱 Exemplo do dia a dia

Um site de clima pode usar uma API para buscar:

Temperatura atual
Previsão dos próximos dias

Já um app de delivery pode usar várias APIs:

Para mostrar restaurantes
Para processar pagamentos
Para rastrear entregas

🧑‍💻 Em Node.js, como veremos, criamos APIs com Express para:

Criar servidores rápidos e leves
Definir rotas e respostas
Trabalhar com dados no formato JSON

Agora que já entendemos o que é uma API, vamos parar de teoria e colocar a mão na massa.

🧰 Configurando o Ambiente

Primeiro, você precisa ter o Node.js instalado em sua máquina. Você pode baixá-lo aqui:

Node.js Downloader

Depois de instalar o Node.js, criremos a estrutura da API.

📁 Estrutura da API

crud-api/
├── server.js
├── package.json

Server.js

O arquivo server.js é o arquivo principal da aplicação. Nele fica o código do servidor Node.js, que geralmente usa o Express para criar rotas e endpoints da API.

Ele é o ponto de entrada do projeto, ou seja, quando você roda node server.js, é esse arquivo que será executado.

Package.json

Este arquivo é o coração do projeto Node.js. Ele contém:

As informações do projeto (nome, versão, descrição, autor).

A lista de dependências (como express, cors etc.).

Scripts que você pode executar com npm run.

Outras configurações para o projeto.

Exemplo básico de package.json:

{
  "name": "crud-api",
  "author": "Rodrigo Zandonadi",
  "version": "1.0.0",
  "main": "server.js",
  "scripts": {
    "start": "node server.js"
  },
  "dependencies": {
    "cors": "^2.8.5",
    "express": "^4.18.2"
  }
}

Veremos um exemplo de criação do arquivo server.js abaixo.

1️⃣ Iniciando o projeto

Vamos criar um novo diretório para o seu projeto e inicializar um novo projeto Node.js:

mkdir crud-api
cd crud-api
npm init -y

O comando npm init -y cria um arquivo package.json, que é o start de um projeto node.js.

2️⃣ Instalando Dependências

📦 O que são dependências em um projeto Node.js?

As dependências são bibliotecas externas (ou pacotes) que seu projeto precisa para funcionar corretamente.

Por exemplo:

Se você quer criar um servidor web mais facilmente (que é o nosso caso), você usa o pacote express.

Se você precisa permitir que sua API seja acessada de outros domínios, você usa cors.

Se for conectar a um banco MongoDB, pode usar mongoose.

Essas bibliotecas são instaladas via npm (Node Package Manager), com o comando:

npm install <nome-do-pacote>

Instale as dependências necessárias: Express e CORS.

npm install express cors

Caso prefira, você pode utilizar o yarn para manipular as dependências. Para isso você precisa instalar o globalmente na sua máquina, com o comando npm install --global yarn, e, em seguida, rodar no diretório da sua API:

yarn add express cors

📁 Onde as dependências ficam?

Elas são baixadas e salvas na pasta node_modules (automaticamente).

Também são listadas no arquivo package.json, dentro da chave "dependencies":

"dependencies": {
  "express": "^4.18.2",
  "cors": "^2.8.5"
}

🛠 Exemplo prático

Quando você instala algo assim:

npm install express cors

O package.json fica assim:

"dependencies": {
  "express": "^4.18.2",
  "cors": "^2.8.5"
}

E no seu código (server.js), você pode usar assim:

const express = require('express');
const cors = require('cors');

⚠️ Dica Importante

A pasta node_modules não deve ser enviada para o Git. Por isso, você geralmente inclui ela no arquivo .gitignore.

É só criar um arquivo .gitignore e adicionar node_modules nele.

node_modules

3️⃣ Criando a Estrutura da API

Crie um arquivo chamado server.js e adicione o seguinte código:

const express = require('express'); // insere o módulo do express na variável express


const app = express(); // Cria uma instância do servidor Express.
const PORT = 3000; // Define a porta do seu computador onde o servidor vai rodar. No caso, a porta 3000 é usada por __default__ (padrão) ao trabalhar com Node.js

app.use(express.json()); // Permite que o Express entenda requisições com body em formato JSON (como em POST e PUT).

// O código abaixo inicia o servidor na porta 3000.
app.listen(PORT, () => {
    console.log(`Servidor rodando em http://localhost:${PORT}`);
});

Abaixo temos o código completo do server.js:

const express = require('express');
const cors = require('cors'); 

const app = express();
const PORT = 3000;

app.use(cors());
app.use(express.json());

let items = [];

// Criar um item
app.post('/api/items', (req, res) => {
    const item = req.body;
    items.push(item);
    res.status(201).json(item);
});

// Ler todos os itens
app.get('/api/items', (req, res) => {
    res.json(items);
});

// Atualizar um item
app.put('/api/items/:id', (req, res) => {
    const { id } = req.params;
    const updatedItem = req.body;
    items[id] = updatedItem;
    res.json(updatedItem);
});

// Deletar um item
app.delete('/api/items/:id', (req, res) => {
    const { id } = req.params;
    items.splice(id, 1);
    res.status(204).send();
});

app.listen(PORT, () => {
    console.log(`Servidor rodando em http://localhost:${PORT}`);
});

Agora vou explicar passo a passo esse arquivo.

Explicação

🔌 1. Importando bibliotecas

const express = require('express');
const cors = require('cors');

express: Framework que simplifica a criação de servidores HTTP com Node.js.
cors: Middleware que habilita o CORS (Cross-Origin Resource Sharing), permitindo que seu servidor aceite requisições de diferentes origens (por exemplo, de um frontend rodando em outro domínio).

🚀 2. Inicializando o app

const app = express();
const PORT = 3000;

app: Cria uma instância do servidor Express.
PORT: Define a porta onde o servidor vai rodar.

⚙️ 3. Middlewares globais

app.use(cors());
app.use(express.json());

app.use(cors()): Permite que qualquer domínio acesse a API (útil para consumir com o frontend).
app.use(express.json()): Permite que o Express entenda requisições com body em formato JSON (como em POST e PUT).

📦 4. Base de dados simulada

let items = [];

Simula um "banco de dados em memória" com um array de objetos.

Os dados serão perdidos ao reiniciar o servidor (útil para testes simples).

📩 5. Criar um item (POST)

app.post('/api/items', (req, res) => {
    const item = req.body;
    items.push(item);
    res.status(201).json(item);
});

Rota POST /api/items

Lê os dados do corpo da requisição (req.body), adiciona ao array items, e retorna o item criado com status 201 (Created).

📥 6. Ler todos os itens (GET)

app.get('/api/items', (req, res) => {
    res.json(items);
});

Rota GET /api/items

Retorna todos os itens do array items como JSON.

✏️ 7. Atualizar um item (PUT)

app.put('/api/items/:id', (req, res) => {
    const { id } = req.params;
    const updatedItem = req.body;
    items[id] = updatedItem;
    res.json(updatedItem);
});

Rota PUT /api/items/:id

Atualiza um item com o índice (id) informado na URL, substituindo pelo novo conteúdo do req.body.

⚠️ Aqui o id é o índice do array (não um ID único real). Cuidado com isso em projetos reais!

🗑️ 8. Deletar um item (DELETE)

app.delete('/api/items/:id', (req, res) => {
    const { id } = req.params;
    items.splice(id, 1);
    res.status(204).send();
});

Rota DELETE /api/items/:id

Remove o item com índice id do array.

Retorna status 204 (No Content) para indicar que foi deletado com sucesso.

🔊 9. Iniciando o servidor

app.listen(PORT, () => {
    console.log(`Servidor rodando em http://localhost:${PORT}`);
});

Inicia o servidor na porta 3000.

Exibe uma mensagem no console para indicar que o servidor está ativo.

4️⃣ Testando a API

Inicie o servidor com o comando:

node server.js

Ou crie um script no package.json na seção scripts, acima de dependencies:

"scripts": {
  "start": "node server.js"
},
"dependencies": {
  "express": "^4.18.2",
  "cors": "^2.8.5"
}

Então, rode o script no terminal:

npm start

Se quiser testar os endpoints separadamente, use ferramentas como Insomnia ou Postman.

Agora, você pode fazer requisições para http://localhost:3000/api/items.

Se você não souber como fazer esse passo, fique tranquilo. Faremos os testes após criar a página HTML direto no navegador.

5️⃣ Criando a Página HTML

Crie uma página HTML dentro de um projeto frontend para consumir os dados de sua API:

📁 Estrutura da API

crud-frontend/
├── index.html
├── assets/css/styles.css (opicional)
├── assets/js/scripts.css (opicional)

Crie um arquivo chamado index.html e adicione o seguinte código:

<!DOCTYPE html>
<html lang="pt-BR">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>CRUD com API</title>
    <link href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
    <div class="container">
        <h1 class="mt-5">CRUD com API</h1>
        <form id="itemForm" class="mt-3">
            <input type="text" id="itemInput" class="form-control" placeholder="Digite um item" required>
            <button type="submit" class="btn btn-primary mt-2">Adicionar Item</button>
        </form>
        <ul id="itemList" class="list-group mt-3"></ul>
    </div>

    <script>
        const form = document.getElementById('itemForm');
        const itemInput = document.getElementById('itemInput');
        const itemList = document.getElementById('itemList');

        const fetchItems = async () => {
            const response = await fetch('http://localhost:3000/api/items');
            const items = await response.json();
            itemList.innerHTML = '';
            items.forEach((item, index) => {
                const li = document.createElement('li');
                li.className = 'list-group-item d-flex justify-content-between align-items-center';
                li.textContent = item;
                li.appendChild(createDeleteButton(index));
                itemList.appendChild(li);
            });
        };

        const createDeleteButton = (id) => {
            const button = document.createElement('button');
            button.className = 'btn btn-danger btn-sm';
            button.textContent = 'Deletar';
            button.onclick = async () => {
                await fetch(`http://localhost:3000/api/items/${id}`, { method: 'DELETE' });
                fetchItems();
            };
            return button;
        };

        form.onsubmit = async (e) => {
            e.preventDefault();
            const item = itemInput.value;
            await fetch('http://localhost:3000/api/items', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify(item),
            });
            itemInput.value = '';
            fetchItems();
        };

        fetchItems();
    </script>
</body>
</html>

6️⃣ Testando a Aplicação

Abra o arquivo index.html em um navegador. Você deve ver um formulário onde pode adicionar itens. Os itens adicionados aparecerão em uma lista abaixo, e você poderá deletá-los.

Recaptilando

Baixe o Node.js
Crie um diretório para a api
Baixe as dependências
Crie o arquivo da API
Teste a API
Crie o projeto HTML
Crie a página HTML
Abra a página html em um navegador
Teste a API através da página HTML

Conclusão

Neste artigo, você aprendeu a criar uma API básica em Node.js usando Express e CORS, além de consumir essa API em uma página HTML com operações CRUD. Essa é uma base sólida para desenvolver aplicações mais complexas.

Sinta-se à vontade para expandir essa aplicação, adicionando funcionalidades como edição de itens ou persistência em um banco de dados.

Se quiser se aprofundar na criação de APIs com Node.js utilizando um banoc de dados não-relacional bem poderoso, recomendo a leitura do artigo:

Como criar uma API com Node.js e MongoDB usando ES6

E se tiver alguma dúvida, é só comentar que ajudo no que conseguir.

Como instalar e configurar o Bootstrap no Angular

rodrigozan — Thu, 03 Apr 2025 18:36:58 +0000

Se você está desenvolvendo uma aplicação web moderna com Angular, provavelmente vai querer adicionar um framework de CSS robusto para acelerar o design e garantir responsividade. É aí que entra o Bootstrap, uma das bibliotecas front-end mais populares do mundo. Ele oferece uma ampla variedade de componentes prontos, como botões, formulários, grids e muito mais, todos otimizados para funcionar bem em dispositivos móveis.

Integrar o Bootstrap ao Angular pode parecer complicado à primeira vista, especialmente por conta da estrutura modular do Angular. Mas, na prática, o processo é direto e leva apenas alguns minutos com os comandos certos. O importante é entender a diferença entre instalar apenas o CSS do Bootstrap e integrar também os scripts JavaScript, o que exige um pouco mais de configuração.

Guia para Instalar o Bootstrap em um Aplicativo React

Neste artigo, vou te mostrar passo a passo como instalar e configurar o Bootstrap corretamente em um projeto Angular, garantindo que tudo funcione como esperado, tanto visualmente quanto funcionalmente. Vamos lá?

Passo 1: Criando o projeto Angular (caso ainda não tenha)

Se você ainda não criou seu projeto Angular, basta usar o Angular CLI para iniciar um novo. No terminal, execute o seguinte comando:

ng new meu-projeto

Durante a criação, o CLI pode perguntar se você deseja adicionar o routing e qual formato de CSS deseja usar (SCSS, Less, etc.). Responda conforme sua preferência. Depois de criado, navegue até o diretório do projeto:

cd meu-projeto

Agora sim, podemos começar a instalação do Bootstrap.

E se você quer aprender a trabalhar com Angular do zero, seguindo um passo a passo didático que te economizará tempo e pesquisa em fóruns e no ChatGPT, te recomendo o Curso Angular Completo da Danki Code.

Passo 2: Instalando o Bootstrap via NPM

Com o projeto Angular já criado e aberto, você pode instalar o Bootstrap com o seguinte comando NPM:

npm install bootstrap

Esse comando adiciona o Bootstrap à pasta node_modules do seu projeto.

Agora que o Bootstrap está instalado, precisamos garantir que o Angular reconheça os arquivos de estilo.

Passo 3: Importando o Bootstrap no angular.json

Para que o CSS do Bootstrap seja aplicado à sua aplicação, você deve adicioná-lo ao arquivo angular.json. Localize a seção "styles" e adicione o caminho para o CSS do Bootstrap:

"styles": [
  "node_modules/bootstrap/dist/css/bootstrap.min.css",
  "src/styles.css"
],

Se quiser também os scripts JavaScript do Bootstrap (necessários para modals, dropdowns, carousels, etc.), adicione também na seção "scripts":

"scripts": [
  "node_modules/bootstrap/dist/js/bootstrap.bundle.min.js"
],

Depois disso, salve o arquivo e reinicie o servidor de desenvolvimento com:

ng serve

Agora, ao abrir seu navegador, você já poderá ver os estilos do Bootstrap aplicados ao seu projeto Angular.

Conclusão

Adicionar o Bootstrap ao Angular é uma maneira inteligente de acelerar o desenvolvimento da interface e garantir uma boa experiência do usuário desde os primeiros protótipos. Com apenas alguns comandos e configurações no angular.json, é possível usar os estilos e componentes do Bootstrap em conjunto com a estrutura poderosa do Angular.

Para saber quais estilos do Bootstrap você pode usar no seu projeto, acesse a documentação.

Lembre-se de que, apesar do Bootstrap ser uma ferramenta excelente, é importante manter a personalização e identidade visual da sua aplicação. Use os componentes como base, mas não tenha medo de criar seus próprios estilos quando necessário.

Desenvolver componentes reutilizáveis em seu projeto torna seu código mais limpo e facilita a manutenção.

Reduzindo a redundância do arquivo de rotas - Node.js, ES6 e TypeScript

rodrigozan — Fri, 26 Jul 2024 11:20:41 +0000

Essa dica simples e rápica te ajudará a reduzir a redundância do seu arquivo de rotas usado no Node.js com ES6 **e **TypeScript.

Quando me toquei disso eu quase caí para trás.

Fala galera, tudo tranquilo? Rod Zandonadi na área. E hoje eu quero falar sobre rotas. Antes de ler esse artigo, fique atento que estou trabalhando com node.js e typescript. Porém, como você vai reparar nos códigos abaixo, essa implementação não depende de tipagem. Nesse caso, se você estiver usando ES6 sem typescript, essa solução vai funcionar muito bem

Meu código, apesar de limpo, estava redundante e gerando uma alta manutenibilidade. Ou seja: toda vez que eu precisava criar uma nova rota, precisava atualizar esse arquivo.

Esse e o formato que meu router.ts estava anteriormente:

import { Router } from 'express'

import user from './routes/UserRoutes'
import auth from './routes/AuthRoutes'
import changePassword from './routes/ChangePasswordRoutes'
import post from './routes/PostRoutes'
import scales from './routes/ScalesRoutes'
import songs from './routes/SoungRotes'

const router = Router()

router.use(user)
router.use(auth)
router.use(changePassword)
router.use(post)
router.use(scales)
router.use(songs)

export default router

Cada solicitação tinha seu próprio arquivo de rotas no diretório routes. O objetivo do router.ts é centralizar essas rotas e enviá-las ao app.ts, onde eu seto a rota '/api' para que todas elas fiquem filhas dessa rota principal.

Agora, se eu uso o mesmo diretório para todas as rotas, porque raios estou quebrando a cabeça atualizando o arquivo routes.ts o tempo todo?

Olha só o estado que meu router.ts está, depois de analisar e pesquisar formas de otimizá-lo:

Redundância: Os imports de rotas individuais repetem-se e ocupam espaço desnecessário.
Manutenibilidade: Adicionar novas rotas exige modificação constante do arquivo.
Princípio DRY (Don't Repeat Yourself): O código atual repete o padrão de importação e uso de rotas.

Mas vamos parar de enrolação e vamos melhorar esse trem. Afinal, trabalhar com Node.js e ES6 (sem esquecer do TypeScript) tem inumeras vantagens

Comecemos com a importação. No lugar de importar toooodas as rotas da api (e, convenhamos, dependendo do projeto, como esse meu que só cresce, o número de rotas cresce de forma devastadora), vamos usar import * as.

import { Router } from 'express'
import * as routes from './routes'

Legal, mas como fazemos com o resto do código?

Vamos criar um array com todos os valores do objeto routes. No caso, routes é um objeto que contém todas as rotas importadas. Então é só exportar routes para o app.ts.

const router = Router()

Object.values(routes).forEach(route => router.use(route))

export default router

O resultado é um arquivo de rotas com código limpo, organizado e de 0 (eu disse zero) manutenção.

Segue o código completo do nosso arquivo de rotas da nossa API Node.js com ES6 e TypeScript:

import { Router } from 'express'
import * as routes from './routes'

const router = Router()

Object.values(routes).forEach(route => router.use(route))

export default router

Atenção: para isso funcionar, é necessário a criação de mais um arquivo. Um index.ts no diretório de rotas.

Pô cara, fez eu ler até aqui pra dizer que tem que fazer outro arquivo?

Calma, pequeno padawan.

Este arquivo apenas exportará os modulos de rotas da nossa aplicação. Se tiver que criar uma nova rota, é só exportar nele e pronto.

Saca só:

export { default as user } from './UserRoutes'
export { default as auth } from './AuthRoutes'
export { default as changePassword } from './ChangePasswordRoutes'
export { default as post } from './PostRoutes'
export { default as scales } from './ScalesRoutes'
export { default as songs } from './SoungRotes'

Viu, cabra apressado? Código limpo e de fácil manutenção.

Se eu quiser adicionar uma nova rota, no exemplo da minha aplicação, ministers, basta vir a esse arquivo e acrescentar a exportação:

export { default as user } from './UserRoutes'
export { default as auth } from './AuthRoutes'
export { default as changePassword } from './ChangePasswordRoutes'
export { default as post } from './PostRoutes'
export { default as scales } from './ScalesRoutes'
export { default as songs } from './SoungRotes'

/* New rote ministers */
export { default as ministers } from './MinistersRotes'

É isso povo bonito. Otimização de código nas rotas de uma API desenvolvida em Node.js, ES6 e TypeScript (lembrando que essa otimização, o TypeScript é opcional, mas não funciona com Common Modules).

Curtiu? Se sim, deixa um comentário aí, filho de Deus.

Abração galera! Até a próxima!

Python para Desenvolvedores JavaScript: Iniciando uma Nova Jornada

rodrigozan — Tue, 14 Nov 2023 12:22:08 +0000

Aprender uma nova linguagem de programação é uma aventura repleta de desafios e descobertas. Após anos imerso no universo do JavaScript, decidi expandir meus horizontes e embarcar na jornada de desvendar os mistérios do Python.

Este artigo é o primeiro de uma série onde compartilharei, de forma transparente e sincera, cada passo dessa transição, desde as dificuldades enfrentadas até as conquistas alcançadas. Se você, assim como eu, está considerando aprender Python ou simplesmente tem curiosidade sobre como é migrar de uma linguagem para outra, convido-o a acompanhar esta experiência. Juntos, exploraremos as nuances do Python sob a perspectiva de um desenvolvedor acostumado ao ecossistema JavaScript.

Porque Python

Eu sempre quis aprender Python. Já vi alguma coisa na faculdade, mas nada interessante. Só a lógica básica mesmo, o que vou reproduzir neste artigo. Além de ser uma linguagem popular atualmente, com ela posso investir em outra área que tenho olhado há algum tempo: data science.

E, como disse atualmente, Python está no auge. Nesse ano (2023) ela está em segundo lugar nas linguagens mais populares do Github, atrás apenas do JavaScript.

Por isso, bora aprender esse trem.

Sobre a Python

Sempre considerei interessante contextualizar um pouco o conhecimento. Acho legal saber como as coisas surgiram e etc. Se você não gosta, só pular para as explicações iniciais, na seção Primeiros passos com Python, mais abaixo.

A linguagem Python foi criada por Guido van Rossum, e teve seu primeiro lançamento em 1991. O Python se tornou tão popular porque, além de ser usada para desenvolvimento web, também é usada para scrpits de sistema, desenvolvimento de software e matemática.

Vantagens de utilizar a Python:

como no Node.js, você pode criar um servidor para criar aplicações;
conexão com bancos de dados, criando e modificando arquivos;
pode ser usado para lidar com big data e realizar matemática complexa;
para prototipagem rápida ou para desenvolvimento de software pronto para produção.

Motivos para utilizar a Python

Python é uma linguagem de programação versátil e amplamente utilizada, conhecida por sua compatibilidade com diversas plataformas, incluindo Windows, Mac, Linux e Raspberry Pi. Essa característica torna Python uma escolha ideal para desenvolvedores que trabalham em ambientes de computação variados. Além disso, Python se destaca por sua sintaxe simples e intuitiva, que se assemelha à língua inglesa. Essa simplicidade facilita o aprendizado e a leitura do código, tornando Python uma opção popular tanto para programadores iniciantes quanto para os mais experientes.

MongoDB Descomplicado: O Guia Definitivo para Iniciantes em MongoDB

Outro aspecto notável do Python é sua eficiência em termos de escrita de código. Os desenvolvedores podem expressar conceitos complexos em menos linhas de código em comparação com outras linguagens de programação, o que aumenta a produtividade e reduz o tempo necessário para o desenvolvimento de software. Python opera em um sistema de interpretação, permitindo que o código seja executado imediatamente após ser escrito. Isso facilita a prototipagem rápida, um recurso valioso em ambientes de desenvolvimento ágil. Além disso, Python é extremamente flexível, suportando programação procedural, orientada a objetos e funcional, o que permite aos desenvolvedores escolher a abordagem mais adequada para cada projeto.

Sobre tipagem

Para a galera que fica na dúvida sobre a tipagem do Python...

A linguagem Python é frequentemente descrita como uma linguagem de tipagem dinâmica. Porém, é importante esclarecer que ela também é fortemente tipada.

Certo, confundiu tudo aqui, imagino.

Vamos melhorar essa resposta.

Isso significa que, embora Python não exija que você declare explicitamente os tipos de dados das variáveis no momento da sua criação (uma característica da tipagem dinâmica), ela não permite operações que são incompatíveis com os tipos de dados envolvidos, o que é uma característica de linguagens fortemente tipadas.

Por exemplo, em Python, você não pode concatenar diretamente uma string e um número sem uma conversão explícita, pois são tipos de dados diferentes. Isso demonstra a natureza de tipagem forte da linguagem, onde o tipo de cada valor é importante e é mantido de forma rigorosa durante a execução do programa.

Primeiros passos com Python

Agora que estamos devidamente contextualizados, vamos codar. Caso você não queira baixar a linguagem na sua máquina, pode seguir esse básico tutorial utilizando o Docker ou o site Online Python, onde é possível rodar código da linguagem direto no navegador.

Rodando Python no Docker

Para utilizar Python no Docker, rode o comando docker run -it --name estudos-de-python -vC:\\endereço-da-pasta-onde-estarão-seus-arquivos:/app -p8080 python. Troque C:\endereço-da-pasta-onde-estarão-seus-arquivos pelo caminho da sua máquina onde você quer salvar seus arquivos python. A escolha da porta é de preferência pessoal. Ah sim! estudos-de-python é uma sugestão de nome para seu container docker. Fique a vontade para escolher o nome que quiser.

Hello World

Só para seguir a convenção mundial, vamos criar o famoso hello world.

Dentro do seu ambiente Python, crie o arquivo hello-world.py (py é a extensão usada para arquivos Python).

No arquivo hello-world.py, vamos printar o texto Hello World_ usando o método print, do Python:

print('Hello World')

Se você rodar o comando python hello-world.py, verá escrito no terminal a string Hello World.

Variáveis

Vamos melhorar nosso código, adicionando o texto Hello World à uma variável do tipo String.

Se você prestou atenção no texto introdutório, já sabe que não declaramos o tipo da variável em sua criação. Também não temos uma palavra reservada, como var ou const para declarar que aquele dado é uma variável. Precisamos apenas escrever o nome da variável e atribuir a ela o devido valor.

No nosso exemplo, podemos escrever:

text = 'Hello World'
print(text)

Para melhorar a legibilidade do código, podemos mudar o nome da variável, declarando qual a sua intenção, e comentar o código:

# usamos # (hashtag, jogo da velha, sustenido...) para criar comentários em Python
welcome = 'Hello World' # a variável welcome deixa claro que o texto se trata de uma mensagem de boas vindas
print(welcome) # a função print imprime no terminal a mensagem atribuída à variável welcome

Operadores

Como todas as linguagens, a Python possui operadores que facilitam (e muito) o desenvolvimento:

Aritméticos: +, -, , /, % (módulo), * (potência)
Comparação: ==, !=, >, <, >=, <=
Lógicos: and, or, not

Identação

Antes de entrarmos nas estruturas, acho válido comentar sobre a identação da linguagem.

A indentação em Python é mais do que apenas uma questão de estilo de codificação; é uma parte fundamental da sintaxe da linguagem. Em Python, a indentação é usada para definir blocos de código. Isso é diferente de muitas outras linguagens de programação, onde chaves {} ou palavras-chave específicas são usadas para esse propósito.

Aqui estão alguns pontos importantes sobre a indentação em Python:

Blocos de Código: Em Python, blocos de código sob estruturas de controle como if, for, while, e definições de funções (def) e classes (class) são definidos pela indentação. Todo o código dentro de um bloco deve ser indentado uniformemente.

Consistência: A quantidade de espaço usado para a indentação é flexível, mas deve ser consistente em todo o bloco. O padrão mais comum é usar quatro espaços por nível de indentação, e esta é a convenção recomendada pela PEP 8 (o guia de estilo para Python).

Indentação vs. Tabs: Embora você possa usar tabs para indentação, é altamente recomendado usar espaços, e nunca misturar tabs e espaços no mesmo bloco de código, pois isso pode levar a erros que são difíceis de diagnosticar.

Erros de Indentação: Se um bloco de código não estiver corretamente indentado, Python lançará um IndentationError. Isso ajuda a manter a legibilidade e a uniformidade do código.

Exemplo de Indentação:

Não precisa se preocupar em entender as questões de estrutura condicional e de repetição. Esse exemplo é apenas para você visualizar a importância da identação na linguagem Python.

def minha_funcao():
    for i in range(5):
        if i > 2:
            print("Maior que 2")
        else:
            print("Menor ou igual a 2")

Neste exemplo, o corpo da função minha_funcao, o loop for, e as estruturas condicionais if e else têm suas próprias indentações para indicar quais linhas de código pertencem a cada bloco.

A indentação é uma parte crucial da sintaxe Python e ajuda a tornar o código Python legível e organizado. Ao seguir as convenções de indentação, os programadores podem evitar erros comuns e tornar seu código mais acessível para outros desenvolvedores.

Estruturas Condicionais

Estruturas condicionais são um conceito fundamental na programação, usadas para executar diferentes ações com base em diferentes condições. Em outras palavras, elas permitem que um programa tome decisões e siga caminhos diferentes de execução dependendo de certos critérios ou condições.

Aqui estão os elementos principais das estruturas condicionais:

If: Esta é a estrutura condicional mais básica. Ela permite que o programa execute um bloco de código apenas se uma determinada condição for verdadeira. Por exemplo, em Python, você pode ter algo como if x > 0:, onde o código subsequente é executado somente se x for maior que zero.

if idade > 18:
    print("Adulto")

Else: Frequentemente usada em conjunto com if, a cláusula else especifica um bloco de código a ser executado se a condição if for falsa. Por exemplo, if x > 0: seguido de else: - o bloco de código sob else é executado se x não for maior que zero.

if idade > 18:
    print("Adulto")
else:
    print("Menor de idade")

Elif (Else If): Usada para verificar múltiplas condições, uma após a outra. Se a condição do if for falsa, o programa verifica a condição do elif, e assim por diante. Isso permite criar uma cadeia de verificações de condições.

if x > 10:
    print("x é maior que 10")
elif x > 5:
    print("x é maior que 5 mas não maior que 10")
else:
    print("x é 5 ou menor")

Switch Case: Alguns idiomas oferecem uma estrutura switch case, que é uma maneira de simplificar uma série de if-else quando todas as condições dependem do valor de uma única variável. Python não tem uma estrutura switch case nativa, mas o mesmo comportamento pode ser simulado com uma série de if-elif-else.

As estruturas condicionais são essenciais para a lógica de programação, permitindo que os programas sejam dinâmicos e reativos a diferentes entradas e situações.

def case1(): # a palavra reservada 'def' é usada em Python para definir uma função
    return "Caso 1"

def case2():
    return "Caso 2"

def default():
    return "Caso padrão"

switch = {
    1: case1,
    2: case2
}

# Usando o 'switch'
case = switch.get(x, default)()
print(case)

Estrutura de Repetição - Loops

As estruturas de repetição são cruciais em toda linguagem de programação. No Python não seria diferente.

Também conhecidas como laços ou loops, as estruturas de repetição são fundamentais na programação, pois permitem que um bloco de código seja executado repetidamente sob certas condições. Em Python, as principais estruturas de repetição são o for e o while.

For Loop: O loop for é usado para iterar sobre uma sequência (que pode ser uma lista, uma tupla, um dicionário, um conjunto ou uma string). Com cada iteração, o loop acessa o próximo item na sequência. O for é frequentemente usado quando o número de iterações é conhecido ou definido por uma coleção.

Exemplo em Python:

   for i in range(5):
       print(i)

Este código imprimirá os números de 0 a 4. A função range(5) gera uma sequência de números de 0 a 4, e o loop for itera sobre essa sequência.

While Loop: O loop while executa um conjunto de instruções enquanto uma condição é verdadeira. Diferente do for, o while é usado quando o número de iterações não é necessariamente conhecido de antemão; o loop continuará a executar até que a condição especificada se torne falsa.

Exemplo em Python:

   i = 0
   while i < 5:
       print(i)
       i += 1

Este código também imprimirá os números de 0 a 4. O loop continua a executar enquanto i for menor que 5.

Ambos os tipos de loops são essenciais para tarefas que requerem repetição, como processamento de dados, execução de cálculos repetitivos, automação de tarefas, entre outros. É importante gerenciar cuidadosamente as condições de loop para evitar loops infinitos, onde o loop nunca atinge uma condição de término.

Funções

Em Python, funções são blocos de código que são projetados para realizar uma tarefa específica e podem ser reutilizados em diferentes partes do programa. As funções ajudam a tornar o código mais modular, organizado e manutenível. Elas são definidas usando a palavra-chave def, seguida pelo nome da função e parênteses, que podem conter parâmetros.

Aqui estão alguns pontos-chave sobre funções em Python:

Definição de Função

Para criar uma função, você usa a palavra-chave def, seguida do nome da função e parênteses. Os parâmetros da função são especificados dentro dos parênteses. O corpo da função começa na linha seguinte e deve ser indentado.

   def minha_funcao():
       print("Olá, esta é minha função!")

Parâmetros e Argumentos

As funções podem ter parâmetros, que são variáveis listadas entre os parênteses na definição da função. Quando você chama a função, você fornece valores, chamados argumentos, para esses parâmetros.

   def saudacao(nome):
       print(f"Olá, {nome}!")

   saudacao("Alice")  # Chama a função com o argumento "Alice"

Retorno de Valores

Uma função pode retornar um valor usando a palavra-chave return. O valor retornado pode ser resultado de uma operação, uma expressão ou qualquer objeto Python. Após a execução do return, a função é encerrada.

   def somar(a, b):
       return a + b

   resultado = somar(5, 3)
   print(resultado)  # Imprime 8

Escopo de Variáveis

As variáveis definidas dentro de uma função têm escopo local, ou seja, elas só podem ser acessadas dentro da função. Variáveis definidas fora de todas as funções têm escopo global e podem ser acessadas em qualquer lugar do programa.

Funções Anônimas (Lambda)

Python também suporta a criação de funções anônimas (ou expressões lambda), que são funções pequenas e sem nome, definidas com a palavra-chave lambda.

   multiplicar = lambda x, y: x * y
   print(multiplicar(2, 3))  # Imprime 6

As funções são uma parte crucial da programação em Python, permitindo a reutilização de código, a organização lógica e a manutenção mais fácil do código.

Conclusão

Como vimos, apesar de suas particulariedades, entender Python não é muito complexo.

É claro que, ao se aprofundar na linguagem, será necessário gastar tempo estudando. Vimos apenas uma pequena introdução do Python.

Eu vou seguir estudando e compartilhando meu conhecimento aqui com vocês. Me digam aí o que acham.

Guia para Instalar o Bootstrap em um Aplicativo React

rodrigozan — Thu, 19 Oct 2023 18:53:16 +0000

Introdução

Você está pronto para melhorar o visual do seu aplicativo React com o Bootstrap? Atendendo a alguns pedidos no meu artigo Como adicionar o Bootstrap ao Next.js, mostrarei nesse guia como você pode instalar o Bootstrap de forma simples e eficaz para aprimorar a interface do seu aplicativo.

Caso queira dar um fork no repositório deste tutorial, basta acessar o link abaixo:

Repositório React Bootstrap

E ainda utilizar o JavaScript do Bootstrap no projeto, ou seja, usar componentes como o Modal, que necessita do JavaScript do framework Bootstrap para funcionar.

Preparação

Antes de começarmos, é importante garantir que você tenha o seu ambiente de desenvolvimento React configurado e o seu projeto já em andamento. Certifique-se de estar usando o Node.js e o npm (ou yarn) para gerenciar suas dependências.

Se você ainda não tiver um projeto React em andamento, pode criar um novo com o seguinte comando:



npx create-react-app meu-app

Instalação do Bootstrap

Para instalar o Bootstrap no seu projeto React, você pode utilizar o npm. Abra o terminal no diretório do seu projeto e execute o seguinte comando:



npm install bootstrap

Caso prefira utilizar o yarn, rode o comando:



yarn add bootstrap

Isso irá baixar e instalar o Bootstrap e suas dependências no seu projeto.

Importando o Bootstrap

Depois de instalar o Bootstrap, você precisa importá-lo no seu código. No seu arquivo index.js, ou nos arquivos onde você deseja usar o Bootstrap, adicione a seguinte linha no topo:



import 'bootstrap/dist/css/bootstrap.min.css';

Isso importará o arquivo CSS do Bootstrap e permitirá que você utilize os estilos e componentes em seu aplicativo React.

Exemplo de como ficará seu arquivo index.js:



import React from 'react';
import ReactDOM from 'react-dom/client';

import App from './App';

import 'bootstrap/dist/css/bootstrap.min.css';
import './index.css';


const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(
  <React.StrictMode>
    <App />
  </React.StrictMode>
);

Utilizando Componentes Bootstrap

Agora que o Bootstrap está integrado ao seu projeto, você pode começar a usar seus componentes. Por exemplo, você pode adicionar um botão Bootstrap ao seu aplicativo com o seguinte código:



// App.js
import React from 'react';

import './App.css';

function App() {
  return (
    <div className="container">
        <h1>React Bootstrap</h1>

        <button className="btn btn-primary">Clique em Mim</button>
    </div>
  );
}

export default App;

Ou printar informações do banco de dados em uma tabela:



// App.js
import React from 'react';

import './App.css';

function App() {
  return (
    <div className="container">
        <h1>React Bootstrap</h1>

        <table class="table">
            <thead>
                <tr>
                <th scope="col">#</th>
                <th scope="col">First</th>
                <th scope="col">Last</th>
                <th scope="col">Handle</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                <th scope="row">1</th>
                <td>Mark</td>
                <td>Otto</td>
                <td>@mdo</td>
                </tr>
                <tr>
                <th scope="row">2</th>
                <td>Jacob</td>
                <td>Thornton</td>
                <td>@fat</td>
                </tr>
                <tr>
                <th scope="row">3</th>
                <td colspan="2">Larry the Bird</td>
                <td>@twitter</td>
                </tr>
            </tbody>
        </table>
    </div>
  );
}

export default App;

Importando o Bootstrap JavaScript

Se você deseja usar os recursos JavaScript do Bootstrap (como modais, carrosséis, etc.), você pode importar o JavaScript no seu componente.

Vamos importar o JavaScript do Bootstrap no componente App.js e usar um modal (lembrando que já importamos o arquivo bootstrap css no arquivo index.js):



// App.js
import React from 'react';

import 'bootstrap/dist/js/bootstrap.bundle.min.js';

import './App.css';

function App() {
  return (
    <div className="container">
        <h1>React Bootstrap</h1>

        <button type="button" class="btn btn-primary" data-bs-toggle="modal" data-bs-target="#exampleModal">
        Launch demo modal
        </button>

        <div class="modal fade" id="exampleModal" tabindex="-1" aria-labelledby="exampleModalLabel" aria-hidden="true">
        <div class="modal-dialog">
            <div class="modal-content">
            <div class="modal-header">
                <h1 class="modal-title fs-5" id="exampleModalLabel">Modal title</h1>
                <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
            </div>
            <div class="modal-body">
                ...
            </div>
            <div class="modal-footer">
                <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Close</button>
                <button type="button" class="btn btn-primary">Save changes</button>
            </div>
            </div>
        </div>
        </div>
    </div>
  );
}

export default App;

Personalização (Opcional)

Se você deseja personalizar o tema ou os estilos do Bootstrap para corresponder à identidade visual do seu aplicativo, o Bootstrap oferece diversas variáveis de CSS que podem ser sobrescritas. Você pode criar um arquivo CSS personalizado e importá-lo após o CSS do Bootstrap para aplicar suas modificações.

Para fazer isso, crie um novo arquivo CSS personalizado dentro do diretório src. Por exemplo, você pode chamá-lo de meu-bootstrap.css. Este arquivo conterá suas modificações e estilos personalizados.

Exemplos de estilos personalilzados:



/* meu-bootstrap.css */

/* Modificações no botão Bootstrap */
.btn-primary {
    background-color: purple;
    border: solid 1px white;
}

/* Estilo personalizado para um elemento específico */
.minha-classe {
    font-size: 18px;
    color: #333;
    text-decoration: underline;
}

/* Estilo personalizado para a tag strong dentro da classe minha-classe */
.minha-classe strong {
    color: purple;
}

Importe o arquivo CSS personalizado

Para garantir que seu arquivo CSS personalizado meu-bootstrap.css seja aplicado após o CSS do Bootstrap, você deve importá-lo em seu aplicativo React. Você pode fazer isso no componente onde deseja usar os estilos personalizados. Por exemplo, no arquivo App.js:



import React, { Component } from 'react';
import 'bootstrap/dist/css/bootstrap.css'; // Importando o CSS do Bootstrap
import './meu-bootstrap.css'; // Importando o seu arquivo CSS personalizado meu-bootstrap.css

function App() {
    return (
      <div className="container">
            <h1>React Bootstrap</h1>
            <p className="minha-classe">Este parágrafo tem o estilo da <strong>classe minha classe</strong></p>
            <button className="btn btn-primary">Clique em Mim</button>
        </div>
    );
}

export default App;

Conclusão

Agora você sabe como instalar e utilizar o Bootstrap em um aplicativo React. Isso abrirá um mundo de possibilidades para melhorar o design e a usabilidade do seu aplicativo. Lembre-se de explorar a documentação do Bootstrap para descobrir todos os componentes e recursos disponíveis.

Com o Bootstrap, você pode criar interfaces atraentes e responsivas de forma mais eficiente.

CSS Tips - Responsive Columns

rodrigozan — Tue, 17 Oct 2023 12:00:00 +0000

Fala galera, Rodrigo Zan na área.

Mais um artigo para o quadro CSS Tips. A ideia é trazer todos os dias algumas dicas de CSS para aprimorar suas habilidades de design e tornar suas web pages ainda mais incríveis.

Dica do Dia: responsive columns

Hoje, vamos explorar a propriedade columns no CSS. Essa propriedade define o número de colunas a serem usadas ao desenhar o conteúdo de um elemento, bem como a largura dessas colunas.

Quando trabalhamos com texto, como por exemplo, um artigo, podemos utilizar a propriedade columns para definir um número de colunas para o texto. Por exemplo, se você quiser que o texto do artigo tenha 2 colunas fixas.


.article-content {
    columns: 2;
}

Porém, para um texto responsivo que se adapta 100% ao tamanho da tela, você pode usar o valor auto, e especificar a largura ideal para cada coluna. Dessa forma o navegador ficará responsável por calcular de forma automatica o número de colunas que deem preencher o espaço disponível.


.article-content {
    columns: auto 10rem;
}

Acima foi definido que o texto terá o número de colunas automático, e que o tamanho de cada coluna será de 10rem. Para transformar em pixels o valor de rem, imagine que 10rem é 10 vezes o tamanho da fonte raiz, que é, por padrão, definida na tag de uma página HTML. Se o tamanho da fonte raiz for 16px, 10rem seria igual a 160 pixels, 10 x 16.

Curtiu essa dica? Se gostou desse quadro, me dá um toque nos comentários.

Abração e até amanhã!

CSS Tips - Where()

rodrigozan — Mon, 16 Oct 2023 12:57:35 +0000

Fala galera, Rodrigo Zan na área.

Hoje iniciaremos o quadro CSS Tips. A ideia é trazer todos os dias algumas dicas de CSS para aprimorar suas habilidades de design e tornar suas web pages ainda mais incríveis.

Dica do Dia: a pseudoclasse `:where()`

Hoje, vamos explorar a função de pseudoclasse where no CSS. Essa função é uma ferramenta incrivelmente útil quando se trata de selecionar elementos com base em uma lista de seletores. O que torna o where especial é sua capacidade de aplicar estilos a elementos que correspondem a qualquer um dos seletores em sua lista. Vamos dar uma olhada em como usá-lo.

Suponha que você deseje aplicar um estilo a todos os elementos <span> dentro da tag <p> da sua aplicação. Normalmente você escreveria:

p span { /* estilo */ }

Uma forma de declarar que o span é um elemento filho direto do p, é utilizando o sinal de maior.

p > span { /* estilo */ }

Porém, se eu tiver três parágrafos, cada um com uma classe que adiciona estilos diferentes, mas tiver algum estilo que queira passar para todos eles, posso trabalhar da seguinte forma:

p.first > span,
p.second > span,
p.third > span {
   /*  estilo para os spans dentro de todos os parágrafos */
}

p.first span { 
    /* estilo o span dentro de p.first */ 
}

p.second span { 
    /* estilo o span dentro de p.second */ 
}

p.third span { 
    /* estilo o span dentro de p.third */ 
}

Para tornar o CSS menos verboso, podemos utilizar a pseudoclasse :where():

:where(p.first, p.second, p.third) > span { 
    /*  estilo para os spans dentro de todos os parágrafos */ 
}

p.first span { 
    /* estilo o span dentro de p.first */ 
}

p.second span { 
    /* estilo o span dentro de p.second */ 
}

p.third span { 
    /* estilo o span dentro de p.third */ 
}

Curtiu essa dica? Se gostou desse quadro, me dá um toque nos comentários.

Abração e até amanhã!

Introdução ao JavaScript: Variáveis, Tipos de Dados e Operadores

rodrigozan — Tue, 10 Oct 2023 18:22:39 +0000

O JavaScript é uma linguagem de programação amplamente utilizada no desenvolvimento de páginas da web interativas e dinâmicas. Neste artigo, exploraremos os conceitos básicos do JavaScript, incluindo variáveis, tipos de dados e operadores.

O que é o JavaScript?

O JavaScript é uma linguagem de script leve, que permite aos desenvolvedores criar elementos interativos em páginas da web. Ele é frequentemente usado em conjunto com HTML e CSS para fornecer uma experiência mais envolvente aos usuários. Com o JavaScript, podemos criar formulários dinâmicos, efeitos visuais, animações e até mesmo manipular conteúdo em tempo real.

Como programar em JavaScript

Aprender a programar em JavaScript é muito simples. Basta você ter um computador para acessar console do seu navegador preferido.

Mas o quer raios é um console?

Calma, pequeno gafanhoto. Vou explicar. E não, não é um console de video-game.

O console do navegador é uma ferramenta de desenvolvedor integrada aos navegadores da web que permite aos desenvolvedores interagirem com páginas da web e executarem comandos em JavaScript diretamente no navegador. Ele fornece uma interface onde você pode visualizar mensagens de depuração, erros, avisos e resultados de códigos executados em tempo real.

A principal função do console do navegador é facilitar o processo de desenvolvimento e depuração de sites e aplicativos da web. Ele permite que os desenvolvedores inspecionem e analisem o código HTML, CSS e JavaScript em uma página, bem como façam testes e modifiquem o comportamento do código sem a necessidade de editar diretamente os arquivos fonte.

Variáveis em JavaScript

As variáveis são usadas para armazenar dados que podem ser usados mais tarde em nosso código. Em JavaScript, podemos declarar variáveis usando as palavras-chave var, let ou const. Por exemplo:



var idade = 30;
let nome = "Maria";
const PI = 3.14;

Aqui, idade, nome e PI são as variáveis, e atribuímos a elas um valor numérico, uma string e uma constante, respectivamente.

Vamos falar sobre a diferença entre os três tipos de variáveis do JavaScript futuramente. Por enquanto, vamos codar.

Abra uma nova janela, ou uma nova guia de seu navegador preferido (recomendamos o Google Chrome, Mozilla Firefox ou Microsoft Edge). Pressione a tecla F12 ou clique com o botão direito do mouse na página e selecione Inspecionar ou Inspeccionar elemento (dependendo do navegador).

Isso abrirá a ferramenta de desenvolvedor do navegador. Procure a guia Console ou Consola na janela que se abriu.

No console, você verá um prompt onde pode digitar seu código JavaScript. O símbolo > geralmente indica que você pode começar a digitar.

Vamos digitar no console a primeira variável que vimos acima:



var idade = 30;

Tecle enter. Agora digite o nome da variável.



idade

O número 30 será printado no console.

Repita o exercício com let nome e const PI.

Tipos de Dados em JavaScript

JavaScript é uma linguagem dinamicamente tipada, o que significa que o tipo de dado de uma variável é determinado automaticamente com base no valor atribuído a ela. Se você já programou em linguagens estaticamente tipadas, como Java ou C, sentirá certa diferença na declaração de variáveis.

Alguns dos tipos de dados em JavaScript incluem:

Números: usado para representar valores numéricos, como 10, 3.14, etc.
Strings: uma sequência de caracteres, como "Olá, mundo!".
Booleanos: representando verdadeiro (true) ou falso (false).
Arrays: uma coleção de elementos que podem ser de diferentes tipos.
Objetos: representam entidades com propriedades e métodos.

Operadores em JavaScript

Os operadores em JavaScript são usados para realizar ações em variáveis e valores. Alguns dos operadores mais comuns incluem:

Operadores Aritméticos: como adição (+), subtração (-), multiplicação (*), divisão (/) e outros.
Operadores de Atribuição: como "=" para atribuir valores a variáveis.
Operadores de Comparação: como "==", "!=", "<", ">" para comparar valores.
Operadores Lógicos: como "&&" (E), "||" (OU), "!" (NÃO) para realizar operações lógicas.

Exemplo de Uso de Operadores

Bom, não adianta ficar só de lero, lero. Como dizem, a prática leva a perfeição.

No console, crie as seguintes variáveis (lembre-se de teclar enter depois de criar cada variável):



let a = 5;
let b = 10;

let soma = a + b; // Resultado: 15
let subtracao = a - b; // Resultado: -5
let comparacao = a == b; // Resultado: false
let logica = (a < 0) && (b > 0); // Resultado: false

Agora, em qualquer momento que você digitar uma das variáveis, o resultado será printado na tela.

Conclusão

O JavaScript é uma poderosa linguagem de programação que desempenha um papel crucial no desenvolvimento web moderno. Neste artigo, abordamos alguns conceitos fundamentais, como variáveis, tipos de dados e operadores, que são essenciais para começar a escrever códigos JavaScript. Agora, você pode se aventurar na criação de interatividade e dinamismo em suas páginas da web usando o JavaScript!

Espero que este artigo tenha sido útil e que você esteja empolgado para continuar aprendendo mais sobre essa incrível linguagem de programação. No próximo artigo nós vamos falar de Estruturas de controle. Até mais!

MongoDB Descomplicado: O Guia Definitivo para Iniciantes em MongoDB

rodrigozan — Wed, 12 Jul 2023 16:25:37 +0000

MongoDB Descomplicado: O Guia Definitivo para Iniciantes em MongoDB

O MongoDB é um dos bancos de dados NoSQL mais populares do mundo. Sua flexibilidade e escalabilidade o tornam uma escolha ideal para projetos de todos os tamanhos.

Neste tutorial, iremos explorar os conceitos básicos do MongoDB e fornecer uma introdução abrangente para iniciantes, criando uma simples aplicação em Node.js.

O que é o MongoDB

O MongoDB é um banco de dados orientado a documentos, o que significa que ele armazena dados em formato de documentos BSON (Binary JSON). Esses documentos são semelhantes a objetos JSON, tornando o MongoDB fácil de entender e usar.

Vantagens do MongoDB

Existem muitas vantagens em se usar o MongoDB no desenvolvimento de APIs e aplicações:

Flexibilidade do esquema: O MongoDB é um banco de dados NoSQL orientado a documentos, o que significa que não requer um esquema rígido como nos bancos de dados relacionais. Isso permite que você armazene documentos com estruturas diferentes no mesmo banco de dados, facilitando a adaptação às necessidades em constante mudança do seu projeto.

Escalabilidade horizontal: O MongoDB foi projetado para ser altamente escalável. Ele permite a distribuição dos dados em vários servidores, possibilitando um aumento de desempenho à medida que a carga de trabalho aumenta. É possível adicionar mais servidores conforme necessário, tornando o MongoDB adequado para aplicações com grande volume de dados e tráfego intenso.

Desempenho rápido: O MongoDB possui um mecanismo de indexação eficiente e acesso direto aos dados, o que contribui para um desempenho rápido. Ele suporta consultas complexas e pode manipular grandes quantidades de dados de forma eficiente, garantindo uma resposta rápida às solicitações.

Modelo de dados flexível: O MongoDB permite que você armazene dados complexos e estruturas aninhadas de forma nativa. Isso facilita a representação e o acesso aos dados, especialmente em cenários onde a estrutura dos dados pode variar entre documentos.

Comunidade e suporte ativos: O MongoDB possui uma comunidade ativa de desenvolvedores e uma empresa por trás dele que oferece suporte e atualizações frequentes. Isso significa que você terá acesso a recursos, documentação e suporte técnico de qualidade para auxiliá-lo na construção e manutenção de seus projetos.

Desvantagens de se usar o MongoDB

Como em toda tecnologia, existem pontos desfavoráveis no uso do MongoDB.

Consumo de recursos: O MongoDB pode consumir mais recursos do sistema em comparação com alguns bancos de dados relacionais. Isso ocorre devido ao seu modelo de armazenamento flexível e indexação intensiva, o que pode exigir mais memória e capacidade de processamento.

Complexidade de consultas: Embora o MongoDB seja poderoso em termos de consultas, às vezes pode ser mais complexo de usar do que bancos de dados relacionais tradicionais. Consultas complexas podem exigir um conhecimento mais aprofundado da sintaxe e recursos específicos do MongoDB.

Ausência de transações ACID: O MongoDB não suporta transações ACID (Atomicidade, Consistência, Isolamento, Durabilidade) em todas as operações. Isso pode ser um problema em cenários onde a integridade dos dados é fundamental e transações complexas são necessárias.

Falta de aderência a um esquema fixo: Embora a flexibilidade do esquema seja uma vantagem, também pode ser uma desvantagem em certos casos. Em projetos com requisitos estritamente definidos e relacionamentos complexos entre os dados, a falta de um esquema fixo pode dificultar a manutenção e a consistência dos dados.

Curva de aprendizado: Para desenvolvedores acostumados com bancos de dados relacionais, o MongoDB pode exigir uma curva de aprendizado inicial. É necessário compreender os conceitos específicos do MongoDB e suas melhores práticas para aproveitar ao máximo o seu potencial.

Você deve pesar as vantagens e desvantagens na utilização desse banco de dados NoSQL em seus projetos.

Como começar com o MongoDB

Para começar a usar o MongoDB, você precisa seguir algumas etapas simples:

Passo 1: Instalação

Faça o download do MongoDB no site oficial e siga as instruções de instalação adequadas ao seu sistema operacional.

Se quiser, pode seguir este tutorial que ensina a instalar o MongoDB nos sistemas operacionais Windows, Linux e Mac:

Como instalar o MongoDB: Guia Passo a Passo para Windows, Mac e Linux

Passo 2: Conectar ao MongoDB

Após a instalação, você precisa se conectar ao MongoDB. O MongoDB usa o conceito de banco de dados e coleções. O banco de dados é o recipiente principal que armazena suas coleções.

Vamos usar o Windows como exemplo para nos conectarmos ao MongoDB.

Abra o menu Iniciar e pesquise por "Variáveis de ambiente".
Selecione a opção "Editar as variáveis de ambiente do sistema".
Na janela "Propriedades do Sistema", clique no botão "Variáveis de Ambiente".
Na seção "Variáveis do sistema", selecione a variável "Path" e clique em "Editar".
Clique em "Novo" e adicione o caminho do diretório bin do MongoDB. O caminho padrão é "C:\Program Files*MongoDB\Server{versão}\bin". Encontrando o **MongoDB* em Program Files e acessando a pasta bin, basta copiar o endereço do Explorer.
Clique em "OK" em todas as janelas para salvar as alterações.

Agora basta abrir o terminal do Windows (CMD ou Power Shell) e executar o comando :

mongod

O servidor será iniciado e estará pronto para aceitar conexões.

Em seguida, abra uma nova janela do terminal do Windows e digite o comando abaixo para se conectar ao MongoDB:

mongo

Isso abrirá o shell do MongoDB, onde você pode executar comandos e consultas.

Agora você está conectado ao MongoDB local no Windows. Você pode criar bancos de dados, coleções, inserir dados e realizar várias operações usando comandos do MongoDB.

Comandos básicos do MongoDB

Vamos criar um banco de dados para uma biblioteca, uma coleção para livros e uma coleção para membros.

Criação de um banco de dados:

O comando para se criar bancos de dados no MongoDB é use nome_do_banco_de_dados. Nosso banco de dados se chamará biblioteca. Então, o comando para a criação será:

use biblioteca

Ver todos os bancos de dados:

show databases

show dbs

Criação de uma coleção:

Uma coleção seria o equivalente, em um banco de dados relacional, a uma tabela.

Ao usarmos db antes da função, estamos criando uma coleção no banco de dados que foi definido no comando anterior, ou seja, no banco biblioteca.

db.createCollection("livros")

E agora vamos criar a coleção de usuários, que, como definimos anteriormente, se chamará membros:

db.createCollection("membros")

Inserir um documento:

Um documento do MongoDB seria o equivalente, em um banco de dados relacional, aos registros de uma tabela. O comando para inserção de um documento seria insertOne:

db.nome_da_colecao.insertOne({campo1: valor1, campo2: valor2, ...})

Para inserir os dados de um livro em um documento, nosso comando, além de usar o db, precisa declarar a qual a coleção o documento pertence. Então o comando se inicia com db.nome_da_coleção, e só depois o insertOne é acrescentado.

db.livros.insertOne({titulo: "Percy Jackson e o Ladrão de Raios", autor: "Rick Riordan", editora: "Pendragon", lancamento: new Date("2023-07-12")})

Vamos inserir mais um livro.

db.livros.insertOne({titulo: "Pega-pega com Folclóricos", autor: "Rod Zandonadi", editora: "Griots", lancamento: new Date("2022-08-12")})

Listar documentos no MongoDB:

Agora temos dois livros cadastrados em nosso banco de dados. Para listá-los, usamos o comando find.

db.livros.find()

Inserir mais de um documento no MongoDB:

Vamos, agora, criar alguns usuários, os membros da nossa biblioteca. Porém, para não precisarmos usar o comando insertOne várias vezes, vamos utilizar um novo comando. O comando insertMany, que nos permite inserir vários documentos de uma vez.

Da mesma forma, usaremos db e o nome da coleção antes do comando, no caso, a coleção será a de membros.

db.membros.insertMany([
  { nome: "Rodrigo Estagiário", dataNasc: "new DAte("1991-10-28")", sexo: "M", escola: "Eitor Freitas" },
  { nome: "João Estagiário", dataNasc: "new DAte("1992-12-13")", sexo: "M", escola: "Possidônio" },
  { nome: "Alysson Estagiário", dataNasc: "new DAte("1990-11-15")", sexo: "M", escola: "Possidônio" },
  { nome: "Bruna Estagiária", dataNasc: "new DAte("1995-12-26")", sexo: "F", escola: "Eitor Freitas" },
  { nome: "Aymin Estagiária", dataNasc: "new DAte("1990-08-28")", sexo: "F", escola: "Eitor Freitas" },
  { nome: "Nicole Estagiária", dataNasc: "new DAte("2000-03-27")", sexo: "F", escola: "Eitor Freitas" },
])

Rode novamente o comando find para listar todos os membros. Não se esqueça de trocar a coleção para membros:

db.membros.find()

CRUD no MongoDB

Como todo bom tutorial de desenvolvimento web, é imprescindível termos um CRUD. Vamos realizar então um CRUD de livros.

CRUD de Livros

Inserir um documento:

db.livros.insertOne({titulo: "A Filha do Tempo e os Descendentes de Etherion", autor: "Rod Zandonadi", editora: "Griots", lancamento: new Date("2021-02-07")})

db.livros.insertOne({titulo: "O pior Rei Artur de todos os tempos", autor: "Rod Zandonadi", editora: "", lancamento: new Date("2021-02-07")})

Como vimos anteriormente, o comando insertOne insere um documento na coleção especificada no MongoDB. Você pode usar insertMany() para inserir vários documentos de uma vez:

db.membros.insertMany([
  {titulo: "A Filha do Tempo e as Armas Primervas", autor: "Rod Zandonadi", editora: "Griots", lancamento: new Date("2022-02-07")},
  {titulo: "A Filha do Tempo e os Escolhidos dos Primeiros", autor: "Rod Zandonadi", editora: "Griots", lancamento: new Date("2023-02-07")},
  {titulo: "Por Nidavellir", autor: "Rod Zandonadi", editora: "Griots", lancamento: new Date("2022-02-07")},
  {titulo: "Percy Jackson e o Último Olimpiano", autor: "Rick Riordan", editora: "Pendragon", lancamento: new Date("2023-07-12")}
])

Consultar documentos no **MongoDB:**

db.livros.find()

Já aprendemos o comando find retorna todos os documentos na coleção especificada.

Consultar documentos com filtro no **MongoDB:**

db.nome_da_colecao.find({campo: valor})

Isso retorna os documentos que correspondem ao filtro especificado. Por exemplo, {editora: "Griots"} retornará os documentos com o campo editora igual a Griots.

db.livros.find({editora: "Griots"})

Podemos consultar também os autores:

db.livros.find({autor: "Rick Riordan"})

Ou qualquer outro campo que exista na coleção.

Atualizar um documento no **MongoDB:**

db.nome_da_colecao.updateOne({filtro}, {$set: {campo: novo_valor}})

Esse comando atualiza um documento que corresponda ao filtro especificado. Um uso comum é realizar a atualização pelo ID. Você pode pegar esse ID com o comando find, que lista todos os documentos da coleção. Vamos supor que você queria listar todos os livros da editora Griots:

db.livros.find({editora: "Griots"})

Agora é só escolher o documento que você quer atualizar, e inserir o valor do _id no comando updateOne.

Para copiar o ID do terminal, selecione o ID, clique com o botão direito sobre a seleção e escolha copiar; ou, depois de selecionar o ID, aperte as teclas CTRL + SHIFT + C.

Para colar a informação no terminal, repita os passos anteriores, mas escolha colar depois de clicar com o botão direito; e use CTRL + SHIFT + V para colar.

db.livros.updateOne(
  { _id: ObjectId("id_do_documento") },
  { $set: { campo: novo_valor } }
)

Use updateMany() para atualizar vários documentos. Vamos supor que você queira adicionar o campo ilustrador a todos os livros da editora Griots:

 db.minha_colecao.updateMany(
  { editora: "Griots" },
  { $set: { ilustrador: "Rodzanart" } }
)

Excluir documentos no **MongoDB:**

db.nome_da_colecao.deleteOne({filtro})

O comando deleteOne exclui um documento que corresponda ao filtro especificado. Vamos criar um livro com o nome errado, e excluí-lo com base no nome.

db.livros.insertOne({titulo: "Livro para excluir", autor: "Rod Zandonadi", editora: "Forgus", lancamento: new Date("2021-02-07")})

E agora usaremos o comando deleteOne.

db.livros.deleteOne({ titulo: "Livro para excluir" })

Que tal confirmarmos com o comando find, filtrando pela editora Forgus?

db.livros.find({editora: "Forgus"})

Vamos usar insertMany para criar três livros e deletá-los usando deleteMany().

db.membros.insertMany([
  {titulo: "Livro para excluir I", autor: "Rod Zandonadi", editora: "Forgus", lancamento: new Date("2022-02-07")},
  {titulo: "Livro para excluir II", autor: "Rod Zandonadi", editora: "Forgus", lancamento: new Date("2023-02-07")},
  {titulo: "Livro para excluir III", autor: "Rod Zandonadi", editora: "Forgus", lancamento: new Date("2022-02-07")},
])

db.minha_colecao.deleteMany({ editora: "Forgus" })

Falta agora conferir se todos os livros da editora Forgus foram excluí-dos, com o comando find:

db.livros.find({editora: "Forgus"})

Contar documentos no **MongoDB:**

Esse é um bônus no nosso CRUD.

O comando countDocuments retorna o número de documentos que correspondem ao filtro especificado.

db.minha_colecao.countDocuments({filtro})

Para saber quantos livros da editora Griots temos em nosso sistema, basta usar o comando da seguinte forma:

db.livros.countDocuments({editora: "Griots"})

Esses são apenas alguns comandos básicos do MongoDB para começar. O *MongoDB* oferece uma ampla variedade de recursos e comandos avançados para manipulação de dados. Se vocês gostarem do artigo, trarei mais tutoriais para nos aprofundarmos no MongoDB.

Abração pessoal, e até a próxima.

Como adicionar o Bootstrap ao Next.js

rodrigozan — Mon, 01 May 2023 13:00:00 +0000

Neste artigo você aprenderá como adicionar corretamente o Bootstrap ao seu projeto Next.js.

O Bootstrap é um framework front-end de código aberto amplamente utilizado para desenvolvimento de sites e aplicações web responsivas. Ele é projetado para ajudar os desenvolvedores a criar interfaces de usuário mais rapidamente e com menos esforço, fornecendo uma série de componentes pré-construídos, como botões, formulários, menus, tabelas, entre outros.

O framework é baseado em HTML, CSS e JavaScript, e é compatível com os principais navegadores web. Ele utiliza uma grade de 12 colunas para ajudar a criar layouts responsivos e adaptáveis a diferentes tamanhos de tela e dispositivos móveis. Além disso, o Bootstrap também oferece uma ampla variedade de plugins e extensões que podem ser adicionados para estender suas funcionalidades.

Como adicionar o Bootstrap ao Next.js

Primeiro crie um projeto Next.js com npm ou yarn.

npx create-next-app my-app
# ou 
yarn create next-app my-app

Entre no diretório my-app e siga as instruções da instalação.

cd my-app

Abra um novo terminal, navegue até o diretório my-app e instale o bootstrap.

npm install bootstrap 
ou 
yarn add bootstrap

Depois criamos uma página _app.js no diretório Pages.

touch pages/_app.js

Adicione o código a seguir no _app.js. Preste atenção, pois o Bootstrap deve ser importado antes do seu arquivo CSS.


import "bootstrap/dist/css/bootstrap.min.css";
import "../css/customcss.css";
import Head from "next/head";

function MyApp({ Component, pageProps }) {
  return (
    <>
      <Head>
        <meta name="viewport" content="width=device-width, initial-scale=1" />
      </Head>
      <Component {...pageProps} />
    </>
  );
}

export default MyApp;

Atente para a tag meta="viewport", responsável pela responsividade da aplicação.

Conclusão

Espero que esse rápido artigo tenha te ajudado a utilizar o Bootstrap no Next.js.

DEV Community: rodrigozan

Como ler scripts SQL Server grandes com Python

Pré-requisitos

Passo 1: Instalar as Bibliotecas Necessárias

Passo 2: Conectar ao SQL Server

Passo 3: Ler o Script SQL do Arquivo

Passo 4: Executar o Script SQL no SQL Server

Passo 5: Combinar Tudo em Um Script Python

Passo 6: Rodando o Script

Dicas para Lidar com Arquivos SQL Grandes

Passo 1: Leitura em Blocos

Passo 2: Dividir o Script SQL

Passo 3: Monitoramento de Erros

Código Atualizado

Explicações Detalhadas de Cada Dica Implementada:

1. Leitura em Blocos (Função ler_arquivo_sql_em_blocos)

2. Divisão do Script SQL em Comandos Individuais (Função dividir_script_em_comandos)

3. Monitoramento de Erros (Uso do Logger)

4. Execução do Script SQL (Função executar_script_sql)

Passo 4: Rodando o Script

Teste e Logs

Resumindo...

Eliminando linhas de comentários e comandos irrelevantes

Passos para implementar as validações

1. Ignorar Comentários (--): Podemos verificar se uma linha começa com -- (comentários no SQL Server) e ignorá-la.

2. Ignorar Linhas Vazias: Podemos verificar se a linha está vazia ou contém apenas espaços em branco e ignorá-la.

3. Ignorar o Comando "GO": O comando "GO" é usado no SQL Server para dividir batches de comandos, mas não é um comando SQL válido por si só. Devemos ignorá-lo ou usá-lo como um ponto de divisão para executar um bloco de SQL acumulado.

Conclusão

Como instalar o Python no Windows, Linux e Mac

Como instalar o Python no Windows

Como instalar o Python no Linux

Ubuntu / Debian / Linux Mint

Fedora

Arch Linux / Manjaro

Como instalar o Python no Mac

1. Instalar o Homebrew (caso ainda não tenha)

2. Instalar o Python com o Homebrew

3. Verificar a instalação

🛠️ Criando uma API Node.js com Express + CORS e consumindo com HTML + Bootstrap

🤖 O que é uma API?

🧠 Uma explicação simples

🛠 Em termos técnicos

📱 Exemplo do dia a dia

🧰 Configurando o Ambiente

📁 Estrutura da API

Server.js

Package.json

1️⃣ Iniciando o projeto

2️⃣ Instalando Dependências

📦 O que são dependências em um projeto Node.js?

📁 Onde as dependências ficam?

🛠 Exemplo prático

3️⃣ Criando a Estrutura da API

Explicação

🔌 1. Importando bibliotecas

🚀 2. Inicializando o app

⚙️ 3. Middlewares globais

📦 4. Base de dados simulada

📩 5. Criar um item (POST)

📥 6. Ler todos os itens (GET)

✏️ 7. Atualizar um item (PUT)

🗑️ 8. Deletar um item (DELETE)

🔊 9. Iniciando o servidor

4️⃣ Testando a API

5️⃣ Criando a Página HTML

📁 Estrutura da API

6️⃣ Testando a Aplicação

Recaptilando

Conclusão

Como instalar e configurar o Bootstrap no Angular

Passo 1: Criando o projeto Angular (caso ainda não tenha)

Passo 2: Instalando o Bootstrap via NPM

Passo 3: Importando o Bootstrap no angular.json

Conclusão

Reduzindo a redundância do arquivo de rotas - Node.js, ES6 e TypeScript

Python para Desenvolvedores JavaScript: Iniciando uma Nova Jornada

Porque Python

Sobre a Python

Vantagens de utilizar a Python:

Motivos para utilizar a Python

1. Leitura em Blocos (Função `ler_arquivo_sql_em_blocos`)

2. Divisão do Script SQL em Comandos Individuais (Função `dividir_script_em_comandos`)

4. Execução do Script SQL (Função `executar_script_sql`)

Dica do Dia: a pseudoclasse `:where()`