Esta apostila contém informações detalhadas sobre os seguintes tópicos:
Selecione um tópico no menu lateral para começar.
As classes são estruturas que definem propriedades e comportamentos de um tipo específico de objeto. Um objeto é uma instância de uma classe. Classes servem como um modelo para criar objetos.
class Pessoa:
def __init__(self, nome, idade):
self.nome = nome
self.idade = idade
def apresentar(self):
return f"Olá, eu sou {self.nome} e tenho {self.idade} anos."
# Criando um objeto
pessoa1 = Pessoa("Ana", 30)
print(pessoa1.apresentar())#include <iostream>
#include <string>
class Pessoa {
private:
std::string nome;
int idade;
public:
Pessoa(std::string n, int i) : nome(n), idade(i) {}
std::string apresentar() {
return "Olá, eu sou " + nome + " e tenho " +
std::to_string(idade) + " anos.";
}
};
int main() {
Pessoa pessoa1("Ana", 30);
std::cout << pessoa1.apresentar() << std::endl;
return 0;
}Encapsulamento é o conceito de esconder os detalhes internos de uma classe e expor apenas o que é necessário para o uso da classe. Isso geralmente é feito com modificadores de acesso (público, privado, protegido).
class ContaBancaria:
def __init__(self, saldo_inicial):
self.__saldo = saldo_inicial # atributo privado
def depositar(self, valor):
if valor > 0:
self.__saldo += valor
return True
return False
def sacar(self, valor):
if 0 < valor <= self.__saldo:
self.__saldo -= valor
return True
return False
def consultar_saldo(self):
return self.__saldoclass ContaBancaria {
private:
double saldo; // atributo privado
public:
ContaBancaria(double saldoInicial) : saldo(saldoInicial) {}
bool depositar(double valor) {
if (valor > 0) {
saldo += valor;
return true;
}
return false;
}
bool sacar(double valor) {
if (valor > 0 && valor <= saldo) {
saldo -= valor;
return true;
}
return false;
}
double consultarSaldo() const {
return saldo;
}
};Herança permite que uma classe (subclasse ou classe derivada) herde atributos e métodos de outra classe (superclasse ou classe base). Isso promove a reutilização de código e estabelece relações entre classes.
class Animal:
def __init__(self, nome):
self.nome = nome
def fazer_som(self):
pass
class Cachorro(Animal):
def fazer_som(self):
return "Au au!"
class Gato(Animal):
def fazer_som(self):
return "Miau!"class Animal {
protected:
std::string nome;
public:
Animal(std::string n) : nome(n) {}
virtual std::string fazerSom() const {
return "";
}
};
class Cachorro : public Animal {
public:
Cachorro(std::string n) : Animal(n) {}
std::string fazerSom() const override {
return "Au au!";
}
};
class Gato : public Animal {
public:
Gato(std::string n) : Animal(n) {}
std::string fazerSom() const override {
return "Miau!";
}
};Polimorfismo permite que objetos de diferentes classes sejam tratados como objetos de uma classe comum. Isso é geralmente alcançado por meio de herança e interfaces/classes abstratas.
def fazer_animal_falar(animal):
return animal.fazer_som()
cachorro = Cachorro("Rex")
gato = Gato("Mimi")
print(fazer_animal_falar(cachorro)) # "Au au!"
print(fazer_animal_falar(gato)) # "Miau!"void fazerAnimalFalar(const Animal& animal) {
std::cout << animal.fazerSom() << std::endl;
}
int main() {
Cachorro rex("Rex");
Gato mimi("Mimi");
fazerAnimalFalar(rex); // "Au au!"
fazerAnimalFalar(mimi); // "Miau!"
return 0;
}Abstração é o processo de identificar as características essenciais de um objeto e ignorar os detalhes menos importantes. Classes abstratas e interfaces são exemplos de implementação de abstração.
from abc import ABC, abstractmethod
class FormaGeometrica(ABC):
@abstractmethod
def calcular_area(self):
pass
@abstractmethod
def calcular_perimetro(self):
pass
class Retangulo(FormaGeometrica):
def __init__(self, largura, altura):
self.largura = largura
self.altura = altura
def calcular_area(self):
return self.largura * self.altura
def calcular_perimetro(self):
return 2 * (self.largura + self.altura)class FormaGeometrica {
public:
virtual double calcularArea() const = 0;
virtual double calcularPerimetro() const = 0;
virtual ~FormaGeometrica() {}
};
class Retangulo : public FormaGeometrica {
private:
double largura;
double altura;
public:
Retangulo(double l, double a) : largura(l), altura(a) {}
double calcularArea() const override {
return largura * altura;
}
double calcularPerimetro() const override {
return 2 * (largura + altura);
}
};| Característica | Python | C++ |
|---|---|---|
| Tipagem | Dinâmica | Estática |
| Gerenciamento de Memória | Automático (Garbage Collector) | Manual (new/delete) ou RAII |
| Privacidade de Atributos | Convenção (_atributo, __atributo) | Explícita (private, protected, public) |
| Múltipla Herança | Suportada | Suportada (com mais complexidade) |
| Sobrecarga de Operadores | Limitada (métodos especiais como __add__) | Extensiva |
| Distribuição | Gerenciador | Comandos |
|---|---|---|
| Debian/Ubuntu | apt | apt install, apt update |
| Fedora | dnf | dnf install, dnf update |
| Arch | pacman | pacman -S, pacman -Syu |
# Adicionar usuário
sudo useradd -m username
# Definir senha
sudo passwd username
# Adicionar ao grupo
sudo usermod -aG groupname username
# Listar usuários
cat /etc/passwd
# Remover usuário
sudo userdel -r username# Iniciar serviço
sudo systemctl start service-name
# Verificar status
sudo systemctl status service-name
# Habilitar na inicialização
sudo systemctl enable service-name
# Reiniciar serviço
sudo systemctl restart service-name
# Parar serviço
sudo systemctl stop service-name# Mudar permissões (modo octal)
chmod 755 arquivo
# Mudar permissões (modo simbólico)
chmod u+x arquivo
# Mudar proprietário
chown user:group arquivo
# Permissões recursivas para diretório
chmod -R 755 diretorioO macOS não possui um gerenciador de pacotes nativo, mas o Homebrew é amplamente utilizado:
# Instalar Homebrew
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
# Instalar pacote
brew install nome-do-pacote
# Atualizar pacotes
brew update && brew upgrade
# Remover pacote
brew uninstall nome-do-pacote
# Buscar pacotes
brew search nome-do-pacoteNo macOS, o gerenciamento de usuários pode ser feito via GUI (Preferências do Sistema) ou linha de comando:
# Criar novo usuário
sudo dscl . -create /Users/nomedousuario
# Definir shell
sudo dscl . -create /Users/nomedousuario UserShell /bin/bash
# Definir diretório home
sudo dscl . -create /Users/nomedousuario NFSHomeDirectory /Users/nomedousuario
# Definir ID de usuário
sudo dscl . -create /Users/nomedousuario UniqueID 1001
# Definir nome completo
sudo dscl . -create /Users/nomedousuario RealName "Nome Completo"O macOS usa launchd para gerenciar serviços:
# Listar serviços do usuário
launchctl list
# Carregar serviço
launchctl load ~/Library/LaunchAgents/com.exemplo.servico.plist
# Descarregar serviço
launchctl unload ~/Library/LaunchAgents/com.exemplo.servico.plist
# Iniciar serviço
launchctl start com.exemplo.servico
# Parar serviço
launchctl stop com.exemplo.servicoO macOS usa a ferramenta defaults para gerenciar configurações:
# Ler configuração
defaults read com.apple.finder
# Escrever configuração
defaults write com.apple.finder AppleShowAllFiles -bool true
# Resetar configuração
defaults delete com.apple.finder AppleShowAllFiles
# Reiniciar aplicativo para aplicar as mudanças
killall FinderEmbora não seja nativo do Windows, o Chocolatey e o Windows Package Manager (winget) são comumente usados:
# Instalar Chocolatey (cmd admin)
@"%SystemRoot%\System32\WindowsPowerShell\v1.0\powershell.exe" -Command "iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))"
# Instalar pacote
choco install nome-do-pacote
# Atualizar pacotes
choco upgrade all
# Remover pacote
choco uninstall nome-do-pacote# Buscar pacote
winget search nome-do-pacote
# Instalar pacote
winget install id-do-pacote
# Atualizar pacotes
winget upgrade --allUsando PowerShell:
# Criar novo usuário local
New-LocalUser -Name "UserName" -Password (ConvertTo-SecureString "Password" -AsPlainText -Force)
# Adicionar a um grupo
Add-LocalGroupMember -Group "Administrators" -Member "UserName"
# Listar usuários
Get-LocalUser
# Remover usuário
Remove-LocalUser -Name "UserName"# Listar serviços
Get-Service
# Iniciar serviço
Start-Service -Name "ServiceName"
# Parar serviço
Stop-Service -Name "ServiceName"
# Configurar inicialização automática
Set-Service -Name "ServiceName" -StartupType Automatic
# Verificar status
Get-Service -Name "ServiceName" | Select-Object Status, Name, DisplayName# Habilitar PowerShell Remoto (no host)
Enable-PSRemoting -Force
# Conectar a sessão remota
Enter-PSSession -ComputerName PC-NAME -Credential (Get-Credential)
# Executar comando remoto
Invoke-Command -ComputerName PC-NAME -ScriptBlock { Get-Process } -Credential (Get-Credential)# Listar discos
Get-Disk
# Listar volumes
Get-Volume
# Inicializar novo disco
Initialize-Disk -Number 1 -PartitionStyle GPT
# Criar nova partição e formatar
New-Partition -DiskNumber 1 -UseMaximumSize | Format-Volume -FileSystem NTFS -NewFileSystemLabel "DataDisk"Testes unitários são uma prática de teste de software em que pequenas partes isoladas de código (unidades) são testadas individualmente para verificar se funcionam corretamente.
Os testes unitários geralmente seguem o padrão AAA (Arrange, Act, Assert):
import unittest
def soma(a, b):
return a + b
class TestSoma(unittest.TestCase):
def test_soma_positivos(self):
# Arrange
a, b = 3, 5
resultado_esperado = 8
# Act
resultado = soma(a, b)
# Assert
self.assertEqual(resultado, resultado_esperado)
def test_soma_negativo_positivo(self):
# Arrange
a, b = -2, 7
resultado_esperado = 5
# Act
resultado = soma(a, b)
# Assert
self.assertEqual(resultado, resultado_esperado)
if __name__ == '__main__':
unittest.main()#include
int soma(int a, int b) {
return a + b;
}
TEST(TestSoma, PositiveNumbers) {
// Arrange
int a = 3;
int b = 5;
int expected = 8;
// Act
int result = soma(a, b);
// Assert
EXPECT_EQ(result, expected);
}
TEST(TestSoma, MixedNumbers) {
// Arrange
int a = -2;
int b = 7;
int expected = 5;
// Act
int result = soma(a, b);
// Assert
EXPECT_EQ(result, expected);
}
int main(int argc, char **argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
} Objetos simulados usados para isolar a unidade de teste de suas dependências externas:
from unittest import TestCase
from unittest.mock import patch, MagicMock
class Usuario:
def __init__(self, db):
self.db = db
def get_nome_completo(self, user_id):
user_data = self.db.get_user(user_id)
if user_data:
return f"{user_data['nome']} {user_data['sobrenome']}"
return None
class TestUsuario(TestCase):
def test_get_nome_completo(self):
# Criar um mock para o db
mock_db = MagicMock()
# Configurar o comportamento do mock
mock_db.get_user.return_value = {
'nome': 'João',
'sobrenome': 'Silva'
}
# Injetar o mock
usuario = Usuario(mock_db)
# Testar o método
resultado = usuario.get_nome_completo(1)
# Verificar resultado
self.assertEqual(resultado, 'João Silva')
# Verificar se o mock foi chamado corretamente
mock_db.get_user.assert_called_once_with(1)#include
#include
#include
class IDatabase {
public:
virtual ~IDatabase() {}
virtual std::string GetUserName(int id) = 0;
};
class MockDatabase : public IDatabase {
public:
MOCK_METHOD(std::string, GetUserName, (int id), (override));
};
class User {
private:
IDatabase* db;
public:
User(IDatabase* database) : db(database) {}
std::string GetUserName(int id) {
return db->GetUserName(id);
}
};
TEST(UserTest, GetUserName) {
// Create mock
MockDatabase mock_db;
// Set expectations
EXPECT_CALL(mock_db, GetUserName(1))
.WillOnce(::testing::Return("João Silva"));
// Inject mock and test
User user(&mock_db);
EXPECT_EQ(user.GetUserName(1), "João Silva");
} A cobertura de testes é uma métrica que indica quanto do código fonte está sendo testado:
CMake é uma ferramenta de build system generator, multiplataforma e de código aberto, projetada para construir, testar e empacotar software. Em vez de construir diretamente o software, o CMake gera arquivos de compilação nativos (como Makefiles, projetos Visual Studio, etc.) que são então usados para compilar o código.
Um projeto típico usando CMake inclui pelo menos um arquivo CMakeLists.txt na raiz do projeto:
cmake_minimum_required(VERSION 3.10)
project(MeuProjeto VERSION 1.0)
# Definir padrão C++
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# Adicionar diretório de cabeçalhos
include_directories(include)
# Adicionar biblioteca
add_library(minha_lib src/minha_lib.cpp)
# Adicionar executável
add_executable(meu_app src/main.cpp)
target_link_libraries(meu_app minha_lib)
# Configurar testes
enable_testing()
add_subdirectory(tests)meu_projeto/
├── CMakeLists.txt # Arquivo principal do CMake
├── include/ # Arquivos de cabeçalho (.h, .hpp)
│ └── minha_lib.h
├── src/ # Arquivos de código-fonte (.cpp, .c)
│ ├── main.cpp
│ └── minha_lib.cpp
├── tests/ # Testes unitários
│ ├── CMakeLists.txt # CMake específico para testes
│ └── test_minha_lib.cpp
└── build/ # Diretório de build (gerado)cmake_minimum_required(VERSION x.y): Define a versão mínima do CMakeproject(Nome VERSION x.y): Define o nome e versão do projetoset(VAR valor): Define uma variáveloption(VAR "descrição" ON/OFF): Define uma opção booleanainclude_directories(dir): Adiciona diretórios de inclusãoadd_definitions(-DMACRO): Adiciona definições de macroadd_executable(nome fonte1 [fonte2...]): Cria um executáveladd_library(nome STATIC/SHARED fonte1 [fonte2...]): Cria uma bibliotecatarget_link_libraries(alvo dep1 [dep2...]): Vincula bibliotecastarget_include_directories(alvo dir1 [dir2...]): Inclui diretórios para um alvo específicoadd_subdirectory(dir): Adiciona um subdiretório ao buildtarget_compile_features(alvo PRIVATE/PUBLIC/INTERFACE feature): Define features de compilaçãoenable_testing(): Habilita o suporte a testesadd_test(NAME teste COMMAND comando): Adiciona um testeset_tests_properties(teste PROPERTIES propriedade valor): Define propriedades do testeExemplo de CMakeLists.txt na pasta tests/ para integrar Google Test:
# CMakeLists.txt para testes
# Baixar e configurar o GoogleTest
include(FetchContent)
FetchContent_Declare(
googletest
GIT_REPOSITORY https://github.com/google/googletest.git
GIT_TAG release-1.12.1
)
FetchContent_MakeAvailable(googletest)
# Adicionar executável de teste
add_executable(
testes
test_minha_lib.cpp
)
# Vincular bibliotecas necessárias
target_link_libraries(
testes
PRIVATE
gtest_main
minha_lib
)
# Incluir headers da biblioteca
target_include_directories(
testes
PRIVATE
${PROJECT_SOURCE_DIR}/include
)
# Registrar o teste
include(GoogleTest)
gtest_discover_tests(testes)Exemplo de arquivo de teste usando Google Test:
#include
#include "minha_lib.h"
TEST(MinhaLib, TesteFuncao1) {
// Arrange
int entrada = 5;
int esperado = 10;
// Act
int resultado = dobro(entrada);
// Assert
EXPECT_EQ(resultado, esperado);
}
TEST(MinhaLib, TesteFuncao2) {
// Arrange
std::string entrada = "abc";
std::string esperado = "ABC";
// Act
std::string resultado = paraMinusculo(entrada);
// Assert
EXPECT_EQ(resultado, esperado);
} Processo típico para construir um projeto usando CMake:
# 1. Criar e entrar no diretório de build
mkdir -p build && cd build
# 2. Configurar o projeto (gerar Makefiles)
cmake ..
# 3. Compilar o projeto
cmake --build .
# 4. Executar os testes
ctest
# 5. Instalar (opcional)
cmake --install .# Build de debug (mais informações para depuração)
cmake -DCMAKE_BUILD_TYPE=Debug ..
# Build de release (otimizada para desempenho)
cmake -DCMAKE_BUILD_TYPE=Release ..
# Especificar compilador
cmake -DCMAKE_CXX_COMPILER=g++-11 ..# 1. Habilitar testes no projeto principal
enable_testing()
# 2. Incluir o diretório de testes
add_subdirectory(tests)
# 3. No diretório de testes (tests/CMakeLists.txt):
add_executable(testes_unitarios test1.cpp test2.cpp)
target_link_libraries(testes_unitarios PRIVATE
minha_lib
gtest_main)
# 4. Adicionar testes ao CTest
add_test(NAME testes_unitarios COMMAND testes_unitarios)
# 5. Executar testes
# (no diretório build)
ctest -V# Exemplo de CMakeLists.txt para testes Python
find_package(Python COMPONENTS Interpreter REQUIRED)
# Adicionar teste com pytest
add_test(
NAME python_tests
COMMAND ${Python_EXECUTABLE} -m pytest ${CMAKE_CURRENT_SOURCE_DIR}/tests
)
# Definir variáveis de ambiente para o teste
set_tests_properties(python_tests PROPERTIES
ENVIRONMENT "PYTHONPATH=${CMAKE_SOURCE_DIR}/src"
)
# Outra opção: usar um script Python diretamente
add_test(
NAME test_script
COMMAND ${Python_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/run_tests.py
)Exemplo de configuração para GitHub Actions:
name: CMake CI
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Configurar CMake
run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=Debug
- name: Compilar
run: cmake --build ${{github.workspace}}/build
- name: Executar testes
working-directory: ${{github.workspace}}/build
run: ctest -C Debug -V
Single Responsibility Principle
Uma classe deve ter apenas uma razão para mudar, ou seja, deve ter apenas uma responsabilidade.
Open/Closed Principle
Entidades de software devem estar abertas para extensão, mas fechadas para modificação.
Liskov Substitution Principle
Subtipos devem ser substituíveis por seus tipos base sem alterar a corretude do programa.
Interface Segregation Principle
Clientes não devem ser forçados a depender de interfaces que não utilizam.
Dependency Inversion Principle
Módulos de alto nível não devem depender de módulos de baixo nível. Ambos devem depender de abstrações.
class Usuario:
def __init__(self, nome, email):
self.nome = nome
self.email = email
def salvar_no_banco(self):
# Lógica para salvar no banco de dados
print(f"Salvando usuário {self.nome} no banco")
def enviar_email_boas_vindas(self):
# Lógica para enviar email
print(f"Enviando email para {self.email}")
def validar_email(self):
# Lógica para validar o email
return '@' in self.emailclass Usuario:
def __init__(self, nome, email):
self.nome = nome
self.email = email
class UsuarioRepository:
def salvar(self, usuario):
# Lógica para salvar no banco de dados
print(f"Salvando usuário {usuario.nome} no banco")
class EmailService:
def enviar_boas_vindas(self, usuario):
# Lógica para enviar email
print(f"Enviando email para {usuario.email}")
class EmailValidator:
def validar(self, email):
# Lógica para validar o email
return '@' in emailclass Calculadora {
public:
double calcular(double a, double b, string operacao) {
if (operacao == "soma") {
return a + b;
} else if (operacao == "subtracao") {
return a - b;
} else if (operacao == "multiplicacao") {
return a * b;
} else if (operacao == "divisao") {
return a / b;
}
// Para adicionar uma nova operação, precisamos modificar esta classe
return 0;
}
};class Operacao {
public:
virtual double executar(double a, double b) = 0;
virtual ~Operacao() {}
};
class Soma : public Operacao {
public:
double executar(double a, double b) override {
return a + b;
}
};
class Subtracao : public Operacao {
public:
double executar(double a, double b) override {
return a - b;
}
};
// Novas operações podem ser adicionadas sem modificar o código existente
class Multiplicacao : public Operacao {
public:
double executar(double a, double b) override {
return a * b;
}
};
class Calculadora {
private:
Operacao* operacao;
public:
Calculadora(Operacao* op) : operacao(op) {}
double calcular(double a, double b) {
return operacao->executar(a, b);
}
};from abc import ABC, abstractmethod
# Interface Strategy
class EstrategiaOrdenacao(ABC):
@abstractmethod
def ordenar(self, dados):
pass
# Implementações concretas
class OrdenacaoBubbleSort(EstrategiaOrdenacao):
def ordenar(self, dados):
print("Ordenando com Bubble Sort")
# Implementação do bubble sort
return sorted(dados)
class OrdenacaoQuickSort(EstrategiaOrdenacao):
def ordenar(self, dados):
print("Ordenando com Quick Sort")
# Implementação do quick sort
return sorted(dados)
class OrdenacaoMergeSort(EstrategiaOrdenacao):
def ordenar(self, dados):
print("Ordenando com Merge Sort")
# Implementação do merge sort
return sorted(dados)
# Contexto
class Ordenador:
def __init__(self, estrategia: EstrategiaOrdenacao):
self._estrategia = estrategia
def definir_estrategia(self, estrategia: EstrategiaOrdenacao):
self._estrategia = estrategia
def ordenar(self, dados):
return self._estrategia.ordenar(dados)
# Uso
dados = [3, 1, 4, 1, 5, 9, 2, 6, 5]
# Inicialmente usa BubbleSort
ordenador = Ordenador(OrdenacaoBubbleSort())
ordenador.ordenar(dados)
# Muda para QuickSort
ordenador.definir_estrategia(OrdenacaoQuickSort())
ordenador.ordenar(dados)#include
#include
#include
#include
// Observer Interface
class Observer {
public:
virtual ~Observer() {}
virtual void update(const std::string& message) = 0;
};
// Subject (Observable)
class Subject {
private:
std::vector observers;
public:
void addObserver(Observer* observer) {
observers.push_back(observer);
}
void removeObserver(Observer* observer) {
observers.erase(
std::remove(observers.begin(), observers.end(), observer),
observers.end()
);
}
void notify(const std::string& message) {
for (Observer* observer : observers) {
observer->update(message);
}
}
};
// Concrete Subject
class WeatherStation : public Subject {
private:
int temperature;
public:
WeatherStation() : temperature(0) {}
void setTemperature(int temp) {
temperature = temp;
notify("Temperature changed to " + std::to_string(temperature));
}
};
// Concrete Observer
class Display : public Observer {
private:
std::string name;
public:
Display(const std::string& n) : name(n) {}
void update(const std::string& message) override {
std::cout << name << " received: " << message << std::endl;
}
};
// Client code
int main() {
WeatherStation station;
Display phoneDisplay("Phone Display");
Display tabletDisplay("Tablet Display");
station.addObserver(&phoneDisplay);
station.addObserver(&tabletDisplay);
station.setTemperature(25); // Both displays will be notified
station.removeObserver(&tabletDisplay);
station.setTemperature(30); // Only phone display will be notified
return 0;
} def p(d, t):
# Calcular pagamento
r = 0
for i in range(len(d)):
if d[i]["t"] == "r":
r += d[i]["v"]
elif d[i]["t"] == "d":
if t:
r -= d[i]["v"] * 0.9
else:
r -= d[i]["v"]
return rDESCONTO_PREMIUM = 0.9
def calcular_saldo_final(transacoes, cliente_premium):
"""
Calcula o saldo final com base nas transações e status do cliente.
Args:
transacoes: Lista de dicionários com transações
cliente_premium: Booleano indicando se o cliente é premium
Returns:
float: Saldo final após todas as transações
"""
saldo = 0
for transacao in transacoes:
if transacao["tipo"] == "receita":
saldo += transacao["valor"]
elif transacao["tipo"] == "despesa":
saldo -= aplicar_desconto_se_premium(
transacao["valor"],
cliente_premium
)
return saldo
def aplicar_desconto_se_premium(valor, cliente_premium):
"""Aplica desconto se o cliente for premium."""
if cliente_premium:
return valor * DESCONTO_PREMIUM
return valorvoid process(vector& e, int type) {
double result = 0.0;
for (int i = 0; i < e.size(); i++) {
if (type == 0) { // Calculate total salary
result += e[i]->s;
} else if (type == 1) { // Count employees
result += 1;
} else if (type == 2) { // Average age
result += e[i]->a;
}
}
if (type == 0 || type == 2) {
if (type == 2 && e.size() > 0) {
result /= e.size();
}
cout << "Result: " << result << endl;
} else {
cout << "Count: " << result << endl;
}
} enum class ReportType {
TOTAL_SALARY,
EMPLOYEE_COUNT,
AVERAGE_AGE
};
struct Employee {
std::string name;
double salary;
int age;
};
double calculateTotalSalary(const std::vector& employees) {
double total = 0.0;
for (const auto& employee : employees) {
total += employee->salary;
}
return total;
}
int countEmployees(const std::vector& employees) {
return employees.size();
}
double calculateAverageAge(const std::vector& employees) {
if (employees.empty()) {
return 0.0;
}
double totalAge = 0.0;
for (const auto& employee : employees) {
totalAge += employee->age;
}
return totalAge / employees.size();
}
void printReport(const std::vector& employees,
ReportType reportType) {
switch (reportType) {
case ReportType::TOTAL_SALARY:
std::cout << "Total Salary: "
<< calculateTotalSalary(employees) << std::endl;
break;
case ReportType::EMPLOYEE_COUNT:
std::cout << "Employee Count: "
<< countEmployees(employees) << std::endl;
break;
case ReportType::AVERAGE_AGE:
std::cout << "Average Age: "
<< calculateAverageAge(employees) << std::endl;
break;
}
} Framework ágil para gerenciar trabalho complexo em equipes.
Conjunto de práticas que combinam desenvolvimento de software (Dev) e operações de TI (Ops).
Metodologia ágil focada em práticas de programação de alta qualidade.
Lista das dez vulnerabilidades de segurança mais críticas em aplicações web:
# ❌ Vulnerável a injeção SQL
def buscar_usuario(username):
query = "SELECT * FROM usuarios WHERE nome = '" + username + "'"
cursor.execute(query)
return cursor.fetchone()
# ✅ Protegido contra injeção SQL
def buscar_usuario_seguro(username):
query = "SELECT * FROM usuarios WHERE nome = %s"
cursor.execute(query, (username,))
return cursor.fetchone()
# ❌ Criptografia fraca
def senha_segura(senha):
import hashlib
return hashlib.md5(senha.encode()).hexdigest() # MD5 é inseguro!
# ✅ Criptografia forte
def senha_segura_bcrypt(senha):
import bcrypt
# O salt é gerado e incorporado automaticamente
return bcrypt.hashpw(senha.encode(), bcrypt.gensalt())// ❌ Vulnerável a buffer overflow
void funcaoInsegura(char* input) {
char buffer[10];
strcpy(buffer, input); // Sem verificação de tamanho!
}
// ✅ Protegido contra buffer overflow
void funcaoSegura(const char* input) {
char buffer[10];
strncpy(buffer, input, sizeof(buffer) - 1);
buffer[sizeof(buffer) - 1] = '\0';
}
// ✅ Ainda melhor: usar std::string
void funcaoMaisSegura(const std::string& input) {
std::string buffer = input.substr(0, 9);
}
// ❌ Desalocação de memória insegura
void memoriaInsegura() {
int* ptr = new int[10];
// Algum código que pode lançar exceção
delete[] ptr; // Pode nunca ser executado!
}
// ✅ Gerenciamento de memória seguro (RAII)
void memoriaSegura() {
std::vector vec(10); // Liberado automaticamente
// Ou com smart pointers
std::unique_ptr ptr(new int[10]);
} Git é um sistema de controle de versão distribuído que permite rastrear mudanças no código-fonte durante o desenvolvimento. Ao contrário de sistemas centralizados, cada desenvolvedor possui uma cópia completa do repositório, incluindo todo o histórico.
| Área | Descrição |
|---|---|
| Working Directory | Onde você edita os arquivos do projeto |
| Staging Area (Index) | Área intermediária onde as mudanças são preparadas para commit |
| Repository (HEAD) | Banco de dados de objetos que armazena o histórico de versões |
| Remote Repository | Repositório hospedado remotamente (ex: GitHub) |
Working Directory → git add → Staging Area → git commit → Local Repository → git push → Remote Repository
# Configurar nome de usuário
git config --global user.name "Seu Nome"
# Configurar email
git config --global user.email "seu.email@exemplo.com"
# Configurar editor padrão
git config --global core.editor "code --wait"
# Ver configurações
git config --list# Inicializar um novo repositório
git init
# Clonar um repositório existente
git clone https://github.com/usuario/repositorio.git
# Clonar um repositório com um nome específico
git clone https://github.com/usuario/repositorio.git novo-nome
# Clonar um branch específico
git clone -b nome-do-branch https://github.com/usuario/repositorio.git# Verificar status do repositório
git status
# Adicionar arquivos ao staging
git add arquivo.txt # Arquivo específico
git add diretorio/ # Diretório inteiro
git add . # Todos os arquivos modificados
git add -p # Adicionar interativamente
# Fazer commit das mudanças
git commit -m "Mensagem do commit"
# Fazer commit pulando o staging (para arquivos rastreados)
git commit -a -m "Mensagem do commit"
# Mostrar histórico de commits
git log
git log --oneline # Formato resumido
git log --graph --oneline # Com gráfico de branches# Listar remotes
git remote -v
# Adicionar remote
git remote add origin https://github.com/usuario/repositorio.git
# Enviar commits para remote
git push origin main
# Baixar mudanças do remote (sem mesclar)
git fetch origin
# Baixar mudanças e mesclar automaticamente
git pull origin main
# Baixar mudanças com rebase em vez de merge
git pull --rebase origin main# Listar branches
git branch # Locais
git branch -r # Remotos
git branch -a # Todos
# Criar e mudar para novo branch
git checkout -b novo-branch
# Mudar de branch
git checkout outro-branch
# Mesclar branch
git merge branch-origem
# Mesclar sem commit automático
git merge --no-commit branch-origem
# Rebase (reescrever histórico)
git rebase main
# Apagar branch
git branch -d branch-nome # Local
git push origin --delete branch-nome # Remoto# Descartar mudanças não staging
git checkout -- arquivo.txt
# Descartar todas as mudanças
git reset --hard HEAD
# Remover do staging
git reset HEAD arquivo.txt
# Modificar último commit
git commit --amend -m "Nova mensagem"
# Reverter um commit (criar novo commit revertendo)
git revert commit-hash
# Resetar para commit específico (cuidado!)
git reset --soft commit-hash # Mantém arquivos staging
git reset --mixed commit-hash # Remove do staging (padrão)
git reset --hard commit-hash # Descarta completamente# Salvar mudanças temporariamente
git stash
# Salvar com mensagem
git stash save "Descrição das mudanças"
# Listar stashes
git stash list
# Aplicar stash mais recente (mantém na lista)
git stash apply
# Aplicar stash específico
git stash apply stash@{2}
# Aplicar e remover stash da lista
git stash pop
# Remover stash
git stash drop stash@{1}
# Limpar todos os stashes
git stash clear# Ver diferenças antes de adicionar ao staging
git diff
# Ver diferenças já no staging
git diff --staged
# Ver diferenças entre branches
git diff branch1..branch2
# Ver diferenças entre commits
git diff commit1..commit2
# Ver alterações de um commit
git show commit-hash
# Ver quem alterou cada linha de um arquivo
git blame arquivo.txt
# Buscar string no histórico
git grep "texto" $(git rev-list --all)Modelo de ramificação para projetos com ciclos de release definidos.
Ideal para: Projetos com releases periódicas e equipes maiores
Fluxo simplificado baseado em branches e pull requests.
Ideal para: Entrega contínua e deploys frequentes
Desenvolvimento centrado no branch principal (trunk).
Ideal para: DevOps maduro e equipes experientes
Formato: <tipo>(<escopo>): <descrição>
feat(auth): adiciona autenticação com Google OAuth
Implementa o login com Google usando a biblioteca oauth2client.
Resolve #123
fix(api): corrige timeout em chamadas assíncronas
O tempo limite de 5s era muito curto para ambientes de rede lentos.
Aumentado para 15s com retry configurável.
refactor(database): melhora desempenho das consultas
- Adiciona índices em colunas frequentemente pesquisadas
- Otimiza joins usando chaves estrangeiras
- Reduz tempo de consulta em 40%Mecanismo para notificar membros do time sobre mudanças que você propôs a um branch. Uma vez aberto, você pode discutir e revisar as mudanças com colaboradores antes de mesclar ao branch principal.
Issues são usadas para rastrear ideias, melhorias, tarefas ou bugs. Funcionam como um sistema de rastreamento integrado ao GitHub.
GitHub Actions é uma plataforma de CI/CD integrada que permite automatizar workflows baseados em eventos no GitHub.
name: Python CI
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Set up Python
uses: actions/setup-python@v4
with:
python-version: '3.10'
- name: Install dependencies
run: |
python -m pip install --upgrade pip
pip install pytest
pip install -r requirements.txt
- name: Test with pytest
run: |
pytestGitHub Pages permite hospedar sites estáticos diretamente de seu repositório GitHub. Ideal para documentação, portfólios e landing pages.
https://username.github.io/repositoryEspaço colaborativo para sua comunidade discutir, fazer perguntas e compartilhar informações, separado das issues.
Ambientes de desenvolvimento na nuvem direto do GitHub, eliminando a necessidade de configuração local.
# Gerar chave GPG
gpg --full-generate-key
# Listar chaves
gpg --list-secret-keys --keyid-format=long
# Configurar Git para usar a chave
git config --global user.signingkey ID_DA_CHAVE
# Habilitar assinatura automática
git config --global commit.gpgsign true
# Exportar chave pública para GitHub
gpg --armor --export ID_DA_CHAVE
# Fazer commit assinado
git commit -S -m "Commit assinado"Arquivo que define automaticamente quem deve revisar mudanças em diferentes partes do código.
# Proprietários padrão para tudo no repositório
* @org/time-principal
# Proprietários dos arquivos de docs
/docs/ @org/time-docs
# Proprietários do código do backend
/src/backend/ @alice @bob
# Proprietários de configuração do CI
/.github/ @devops-team
# Arquivos de configuração têm proprietário específico
*.json @config-managerSalve como .github/CODEOWNERS no repositório.
Ocorrem quando dois branches têm alterações diferentes na mesma parte do código e o Git não consegue mesclar automaticamente.
# 1. Atualizar o branch atual com o branch alvo
git pull origin main
# 2. Resolver conflitos manualmente editando arquivos
# O Git marca os conflitos assim:
# <<<<<<< HEAD (seu branch atual)
# Seu código
# =======
# Código do outro branch
# >>>>>>> outra-branch
# 3. Adicionar arquivos resolvidos
git add .
# 4. Continuar o merge
git merge --continue
# Ou
git commit -m "Resolve conflitos de merge"git mergetool para usar ferramentas como kdiff3# Descartar mudanças em um arquivo
git checkout -- arquivo.txt
# Descartar todas as mudanças
git restore .
# ou (mais antigo)
git reset --hard# Manter as mudanças no working dir
git reset --soft HEAD^
# Descartar completamente as mudanças
git reset --hard HEAD^# Criar novo commit que desfaz as mudanças
git revert commit-hash
# Reverter vários commits (do mais recente ao mais antigo)
git revert HEAD~3..HEAD# Mudar a mensagem
git commit --amend -m "Nova mensagem"
# Adicionar arquivos esquecidos
git add arquivo-esquecido
git commit --amend --no-edit# Encontrar hash do último commit do branch
git reflog
# Recriar o branch a partir do commit
git checkout -b branch-recuperado commit-hashBash (Bourne Again SHell) é um interpretador de comandos e linguagem de script, sendo o shell padrão na maioria das distribuições Linux e no macOS (até Catalina).
| Sistema Operacional | Como Acessar |
|---|---|
| Linux | Ctrl+Alt+T (em muitas distros) Ou procure por "Terminal" no menu |
| macOS | Applications > Utilities > Terminal Ou Cmd+Space e digite "Terminal" |
| Windows | Windows Subsystem for Linux (WSL) Git Bash Cygwin PowerShell (semelhante, mas não é Bash) |
O prompt padrão tem a seguinte forma:
username@hostname:current_directory$
O $ indica usuário regular, enquanto # indica usuário root.
# Mostrar diretório atual
pwd
# Listar conteúdo do diretório
ls # Listagem básica
ls -l # Formato longo (detalhes)
ls -a # Mostrar arquivos ocultos
ls -la # Combinar opções
ls -lh # Tamanhos em formato humano
# Mudar de diretório
cd /caminho/para/diretorio # Caminho absoluto
cd pasta # Caminho relativo
cd .. # Voltar um nível
cd ~ # Ir para o diretório home
cd - # Voltar ao diretório anterior
# Criar diretório
mkdir nova_pasta
mkdir -p pasta1/pasta2/pasta3 # Criar estrutura aninhada# Criar arquivo vazio
touch arquivo.txt
# Copiar arquivos
cp origem.txt destino.txt
cp -r pasta1 pasta2 # Copiar diretório recursivamente
# Mover/renomear arquivos
mv arquivo.txt novo_nome.txt
mv arquivo.txt /outro/diretorio/
# Remover arquivos
rm arquivo.txt
rm -i arquivo.txt # Interativo (pede confirmação)
rm -f arquivo.txt # Forçado (sem confirmação)
# Remover diretórios
rmdir diretorio_vazio
rm -r diretorio # Recursivo (com conteúdo)
rm -rf diretorio # Recursivo e forçado (cuidado!)
# Criar link simbólico
ln -s arquivo_original link_simbolico# Ver conteúdo completo
cat arquivo.txt
# Ver as primeiras linhas
head arquivo.txt
head -n 20 arquivo.txt # Primeiras 20 linhas
# Ver as últimas linhas
tail arquivo.txt
tail -n 20 arquivo.txt # Últimas 20 linhas
tail -f arquivo.log # Seguir arquivo em tempo real
# Visualizador paginado
less arquivo.txt
# Dentro do less:
# - q: sair
# - /texto: buscar "texto"
# - n: próxima ocorrência
# - N: ocorrência anterior
# - g: ir para o início
# - G: ir para o fim
# Mostrar tipo de arquivo
file arquivo.txt# Buscar arquivos por nome
find . -name "*.txt" # Buscar .txt no dir atual
find /home -type d -name "dados" # Buscar diretórios
find . -type f -size +10M # Arquivos > 10MB
find . -mtime -7 # Modificados nos últimos 7 dias
# Buscar texto em arquivos
grep "texto" arquivo.txt
grep -i "texto" arquivo.txt # Ignorar case
grep -r "texto" diretorio # Recursivo
grep -v "texto" arquivo.txt # Linhas que não contêm
# Filtrar texto
sort arquivo.txt # Ordenar linhas
uniq arquivo.txt # Remover duplicatas adjacentes
sort arquivo.txt | uniq # Remover todas duplicatas
wc arquivo.txt # Contar linhas, palavras, bytes
wc -l arquivo.txt # Apenas linhas# Concatenar arquivos
cat arquivo1.txt arquivo2.txt > combinado.txt
# Dividir arquivos
split -l 100 arquivo.txt prefixo_ # Dividir a cada 100 linhas
# Cortar colunas
cut -d"," -f1,3 arquivo.csv # Colunas 1 e 3 de CSV
# Substituir texto
sed 's/antigo/novo/g' arquivo.txt # Substituir todas ocorrências
sed -i 's/antigo/novo/g' arquivo.txt # Editar no lugar
# Processar texto com awk
awk '{print $1, $3}' arquivo.txt # Imprimir colunas 1 e 3
awk -F"," '{print $1}' arquivo.csv # Definir separador
awk '{sum+=$1} END {print sum}' arquivo.txt # Somar 1ª coluna# Compressão gzip
gzip arquivo.txt # Comprime para arquivo.txt.gz
gunzip arquivo.txt.gz # Descomprime
# Compressão bzip2
bzip2 arquivo.txt # Mais lento, melhor compressão
bunzip2 arquivo.txt.bz2 # Descomprime
# Criar arquivo tar
tar -cvf arquivo.tar pasta/ # Criar (sem compressão)
tar -xvf arquivo.tar # Extrair
# Criar tar comprimido (tarball)
tar -czvf arquivo.tar.gz pasta/ # Com gzip
tar -cjvf arquivo.tar.bz2 pasta/ # Com bzip2
tar -xzvf arquivo.tar.gz # Extrair gzip
tar -xjvf arquivo.tar.bz2 # Extrair bzip2
# Arquivos ZIP
zip -r arquivo.zip pasta/ # Criar
unzip arquivo.zip # Extrair# Ver permissões
ls -l arquivo.txt
# Formato de permissões: [tipo][user][group][others]
# r (leitura) = 4, w (escrita) = 2, x (execução) = 1
# Mudar permissões (modo octal)
chmod 755 arquivo.sh # rwxr-xr-x
chmod 644 arquivo.txt # rw-r--r--
chmod 700 script.sh # rwx------
# Mudar permissões (modo simbólico)
chmod u+x arquivo.sh # Adicionar execução para usuário
chmod go-w arquivo.txt # Remover escrita para grupo/outros
chmod a+r arquivo.txt # Adicionar leitura para todos
# Mudar proprietário
chown usuario:grupo arquivo.txt
chown -R usuario:grupo pasta/ # Recursivo# Listar processos
ps # Processos do usuário
ps aux # Todos os processos
top # Visualização interativa
htop # Alternativa melhorada (instalar se necessário)
# Controle de processos
comando & # Executar em background
Ctrl+Z # Suspender processo atual
bg # Continuar suspenso em background
fg # Trazer para foreground
jobs # Listar jobs em background
# Sinais para processos
kill PID # Encerrar processo (SIGTERM)
kill -9 PID # Forçar encerramento (SIGKILL)
killall nome_processo # Encerrar por nome
# Execução programada
at 14:30 # Agendar para 14:30
# Digite comandos e pressione Ctrl+D para finalizar
# Crontab (tarefas recorrentes)
crontab -l # Listar tarefas
crontab -e # Editar tarefas# Redirecionar stdout para arquivo (sobrescreve)
ls -la > listagem.txt
# Redirecionar stdout para arquivo (anexa)
echo "Nova linha" >> arquivo.txt
# Redirecionar stderr para arquivo
comando_erro 2> erros.log
# Redirecionar stdout e stderr para arquivos diferentes
comando > output.txt 2> erros.log
# Redirecionar stdout e stderr para o mesmo arquivo
comando > output.txt 2>&1
# ou mais simplesmente
comando &> output.txt
# Descartar saída (redirecionar para "lugar nenhum")
comando > /dev/null
# Ler do arquivo como entrada
sort < lista.txt
# Heredoc (documento embutido)
cat << EOF > arquivo.txt
Linha 1
Linha 2
Linha 3
EOFPipes (|) permitem que a saída de um comando seja usada como entrada para outro.
# Contar arquivos em um diretório
ls | wc -l
# Encontrar as 5 maiores arquivos
du -h /var/log/* | sort -rh | head -5
# Contar ocorrências de uma palavra em vários arquivos
grep "erro" *.log | wc -l
# Filtrar e processar dados
cat dados.csv | grep "2023" | cut -d"," -f2,3 | sort | uniq -c
# Pipeline mais complexo
find /var/log -type f -name "*.log" | xargs grep "ERROR" | cut -d":" -f1 | sort | uniq -c | sort -nr
# tee: dividir output (mostrar na tela e salvar)
comando | tee output.txt | grep "importante"#!/bin/bash
# Este é um script de exemplo
# Comentários começam com #
# Definindo variáveis
NOME="Mundo"
DATA=$(date +%Y-%m-%d)
# Imprimindo texto
echo "Olá, $NOME!"
echo "Hoje é $DATA"
# Recebendo entrada do usuário
echo "Digite seu nome:"
read USUARIO
# Usando a entrada
echo "Bem-vindo, $USUARIO!"
# Fim do script
exit 0# Tornar o script executável
chmod +x meu_script.sh
# Executar o script
./meu_script.sh
# Executar sem torná-lo executável
bash meu_script.sh#!/bin/bash
# Variáveis de ambiente
echo "HOME: $HOME"
echo "PATH: $PATH"
echo "USER: $USER"
# Definindo variáveis
NOME="Maria"
IDADE=30
# Usando variáveis
echo "$NOME tem $IDADE anos"
# Parâmetros de linha de comando
echo "Nome do script: $0"
echo "Primeiro argumento: $1"
echo "Segundo argumento: $2"
echo "Todos os argumentos: $@"
echo "Número de argumentos: $#"
# Variáveis especiais
echo "PID do script: $$"
echo "Status do último comando: $?"
# Substituição de comando
ARQUIVOS=$(ls -la)
HOJE=$(date +%d/%m/%Y)
# Operações aritméticas
SOMA=$((10 + 5))
QUADRADO=$((IDADE * IDADE))./script.sh argumento1 argumento2#!/bin/bash
# Condicional if-else
if [ "$1" = "ajuda" ]; then
echo "Modo de ajuda ativado"
elif [ "$1" = "versao" ]; then
echo "Versão 1.0"
else
echo "Comando desconhecido"
fi
# Verificando números
IDADE=18
if [ $IDADE -ge 18 ]; then
echo "Maior de idade"
else
echo "Menor de idade"
fi
# Operadores de comparação para números
# -eq (igual), -ne (diferente), -lt (menor que)
# -le (menor ou igual), -gt (maior que), -ge (maior ou igual)
# Verificando arquivos
if [ -f "/etc/passwd" ]; then
echo "O arquivo existe"
fi
# Condições de arquivo
# -f (arquivo regular), -d (diretório), -e (existe)
# -r (leitura), -w (escrita), -x (execução), -s (não vazio)
# Operadores lógicos
if [ $IDADE -ge 18 ] && [ $IDADE -le 65 ]; then
echo "Idade produtiva"
fi
# Forma alternativa para operadores lógicos
if [[ $IDADE -ge 18 && $IDADE -le 65 ]]; then
echo "Idade produtiva"
fi#!/bin/bash
# Loop for básico
for i in 1 2 3 4 5; do
echo "Número: $i"
done
# For com expansão de sequência
for i in {1..10}; do
echo "Contagem: $i"
done
# For com expansão de sequência e incremento
for i in {1..20..2}; do # Incremento de 2
echo "Ímpar: $i"
done
# For estilo C
for ((i=0; i<5; i++)); do
echo "Índice: $i"
done
# Iterar sobre arquivos
for arquivo in *.txt; do
echo "Processando $arquivo"
done
# Loop while
contador=1
while [ $contador -le 5 ]; do
echo "While: $contador"
contador=$((contador + 1))
done
# Loop until
contador=5
until [ $contador -le 0 ]; do
echo "Until: $contador"
contador=$((contador - 1))
done
# Loop infinito com break
while true; do
echo "Loop infinito"
break # Sai do loop
done
# Continue (pula para próxima iteração)
for i in {1..10}; do
if [ $i -eq 5 ]; then
continue
fi
echo "Valor: $i"
done#!/bin/bash
# Definindo uma função simples
saudacao() {
echo "Olá, mundo!"
}
# Chamando a função
saudacao
# Função com parâmetros
cumprimentar() {
echo "Olá, $1!"
}
cumprimentar "Maria" # Passa "Maria" como parâmetro
# Função com múltiplos parâmetros
soma() {
resultado=$(($1 + $2))
echo "A soma de $1 e $2 é $resultado"
}
soma 5 3
# Função com variável local
calcular_quadrado() {
local numero=$1 # Variável local
echo $((numero * numero))
}
resultado=$(calcular_quadrado 4)
echo "O quadrado é $resultado"
# Função com valor de retorno
# (bash não tem return como outras linguagens)
# Usamos o código de saída ou echo
verifica_arquivo() {
if [ -f "$1" ]; then
echo "1" # Existe
return 0 # Sucesso
else
echo "0" # Não existe
return 1 # Falha
fi
}
# Capturando saída da função
arquivo_existe=$(verifica_arquivo "/etc/passwd")
echo "Existe? $arquivo_existe"
# Verificando código de retorno
verifica_arquivo "/nao/existe"
echo "Status: $?"#!/bin/bash
# Declarando um array
frutas=("maçã" "banana" "laranja" "uva")
# Acessando elementos
echo "Primeira fruta: ${frutas[0]}"
echo "Segunda fruta: ${frutas[1]}"
# Todos os elementos
echo "Todas as frutas: ${frutas[@]}"
# Número de elementos
echo "Total de frutas: ${#frutas[@]}"
# Adicionando elemento
frutas+=("morango")
# Removendo elemento (deixa lacuna)
unset frutas[1]
# Iterando sobre o array
for fruta in "${frutas[@]}"; do
echo "Fruta: $fruta"
done
# Iterando com índice
for i in "${!frutas[@]}"; do
echo "Índice $i: ${frutas[i]}"
done
# Array associativo (tipo dicionário)
declare -A capitais
capitais[Brasil]="Brasília"
capitais[França]="Paris"
capitais[Japão]="Tóquio"
# Acessando
echo "Capital do Brasil: ${capitais[Brasil]}"
# Todas as chaves
echo "Países: ${!capitais[@]}"
# Iterando sobre array associativo
for pais in "${!capitais[@]}"; do
echo "$pais: ${capitais[$pais]}"
doneEste exemplo ilustra um script para backup de diretórios, combinando vários conceitos do Bash:
#!/bin/bash
#
# backup.sh - Script de backup de diretórios
#
# Uso: ./backup.sh diretorio [destino]
#
# Configurações padrão
BACKUP_DIR="/tmp/backups"
DATE=$(date +%Y%m%d_%H%M%S)
LOG_FILE="/tmp/backup_$DATE.log"
# Função para exibir uso
mostrar_uso() {
echo "Uso: $0 diretorio [destino]"
echo " diretorio : Diretório a ser copiado"
echo " destino : Diretório destino (opcional, padrão: $BACKUP_DIR)"
exit 1
}
# Função para registrar log
registrar_log() {
echo "[$(date +%Y-%m-%d\ %H:%M:%S)] $1" | tee -a "$LOG_FILE"
}
# Verificar argumentos
if [ $# -lt 1 ]; then
mostrar_uso
fi
SRC_DIR="$1"
if [ ! -d "$SRC_DIR" ]; then
registrar_log "ERRO: Diretório de origem não existe: $SRC_DIR"
exit 2
fi
# Verificar diretório destino
if [ $# -ge 2 ]; then
BACKUP_DIR="$2"
fi
# Criar diretório de backup se não existir
if [ ! -d "$BACKUP_DIR" ]; then
mkdir -p "$BACKUP_DIR"
if [ $? -ne 0 ]; then
registrar_log "ERRO: Não foi possível criar diretório de backup: $BACKUP_DIR"
exit 3
fi
fi
# Nome do arquivo de backup
SRC_NAME=$(basename "$SRC_DIR")
BACKUP_FILE="$BACKUP_DIR/${SRC_NAME}_$DATE.tar.gz"
# Iniciar backup
registrar_log "Iniciando backup de $SRC_DIR para $BACKUP_FILE"
# Criar arquivo tar.gz
tar -czf "$BACKUP_FILE" -C "$(dirname "$SRC_DIR")" "$SRC_NAME" 2>> "$LOG_FILE"
# Verificar resultado
if [ $? -eq 0 ]; then
TAMANHO=$(du -h "$BACKUP_FILE" | cut -f1)
registrar_log "Backup concluído com sucesso. Tamanho: $TAMANHO"
# Listar arquivos de backup mais antigos que 30 dias
ANTIGOS=$(find "$BACKUP_DIR" -name "${SRC_NAME}_*.tar.gz" -mtime +30)
# Remover backups antigos
if [ -n "$ANTIGOS" ]; then
echo "$ANTIGOS" | while read arquivo; do
registrar_log "Removendo backup antigo: $arquivo"
rm "$arquivo"
done
fi
exit 0
else
registrar_log "ERRO: Falha ao criar backup"
exit 4
fi# Backup do diretório atual para o local padrão
./backup.sh .
# Backup com destino personalizado
./backup.sh /home/usuario/documentos /mnt/backup_externo# Node Version Manager (NVM)
# Instalação
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
# Uso
nvm install 16 # Instalar Node.js v16
nvm use 16 # Usar Node.js v16
nvm alias default 16 # Definir como padrão
# Python Version Manager (pyenv)
# Instalação
curl https://pyenv.run | bash
# Uso
pyenv install 3.10.0 # Instalar Python 3.10.0
pyenv global 3.10.0 # Definir como global
pyenv local 3.8.12 # Definir para o diretório atual
# Ruby Version Manager (RVM)
# Instalação
\curl -sSL https://get.rvm.io | bash -s stable
# Uso
rvm install 3.0.0 # Instalar Ruby 3.0.0
rvm use 3.0.0 # Usar Ruby 3.0.0
rvm --default use 3.0.0 # Definir como padrão# Python virtualenv
# Instalação
pip install virtualenv
# Uso
virtualenv venv # Criar ambiente
source venv/bin/activate # Ativar (Linux/Mac)
venv\Scripts\activate # Ativar (Windows)
deactivate # Desativar
# Python venv (módulo integrado)
python -m venv myenv # Criar ambiente
source myenv/bin/activate # Ativar (Linux/Mac)
myenv\Scripts\activate.bat # Ativar (Windows)
# Conda (Anaconda/Miniconda)
conda create -n myenv python=3.8 # Criar ambiente
conda activate myenv # Ativar
conda deactivate # Desativar
conda env list # Listar ambientes
# Node.js - nvm com .nvmrc
echo "16" > .nvmrc # Criar arquivo de versão
nvm use # Usar versão do arquivo# Cron: agendador de tarefas do Linux/Unix
# Formato: minuto hora dia mês diaSemana comando
# Editar crontab
crontab -e
# Exemplos de entradas
# Executar todo dia às 3:30 AM
30 3 * * * /caminho/para/script.sh
# Executar a cada 5 minutos
*/5 * * * * /caminho/para/script.sh
# Executar às segundas, quartas e sextas às 8h
0 8 * * 1,3,5 /caminho/para/script.sh
# Executar no primeiro dia de cada mês
0 0 1 * * /caminho/para/script.sh
# Backup a cada dia às 2h da manhã
0 2 * * * tar -czf /backup/$(date +\%Y\%m\%d).tar.gz /dados
# Cronômetro para parar um processo após tempo
timeout 30s comando_demorado
timeout 5m script_longo.sh# Conectar a servidor remoto
ssh usuario@servidor
# Conectar em porta não padrão
ssh -p 2222 usuario@servidor
# Executar comando remoto
ssh usuario@servidor "ls -la"
# Transferir arquivos com SCP
scp arquivo.txt usuario@servidor:/diretorio/
scp usuario@servidor:/arquivo.txt local/
scp -r diretorio/ usuario@servidor:/destino/
# Transferir com rsync (mais eficiente)
rsync -avz diretorio/ usuario@servidor:/destino/
rsync -avz --delete diretorio/ usuario@servidor:/destino/
# Túnel SSH para porta local:remota
ssh -L 8080:localhost:80 usuario@servidor
# Túnel reverso (remota:local)
ssh -R 8080:localhost:80 usuario@servidor
# Configurar ~/.ssh/config para facilitar
cat > ~/.ssh/config << EOF
Host servidor
HostName endereço.exemplo.com
User usuario
Port 2222
IdentityFile ~/.ssh/id_rsa_servidor
EOF
# Depois, basta usar:
ssh servidor# Informações sobre interfaces
ifconfig # Clássico (deprecado)
ip addr show # Alternativa moderna
# Testando conectividade
ping exemplo.com
traceroute exemplo.com # Rota dos pacotes
mtr exemplo.com # Ping + traceroute interativo
# DNS e resolução de nomes
nslookup exemplo.com
dig exemplo.com
host exemplo.com
# Verificar portas abertas
netstat -tuln # Portas TCP/UDP abertas
ss -tuln # Alternativa moderna
lsof -i :80 # Processo usando porta 80
# Verificar conexões
netstat -an | grep ESTABLISHED
ss -o state established
# Ferramenta wget para downloads
wget https://exemplo.com/arquivo.zip
wget -c https://exemplo.com/arquivo.zip # Continuar download
wget -r -np https://exemplo.com/docs/ # Recursivo
# Ferramenta curl para requisições
curl https://api.exemplo.com/dados
curl -X POST -d "chave=valor" https://api.exemplo.com
curl -H "Content-Type: application/json" \
-d '{"chave":"valor"}' \
https://api.exemplo.com# Monitoramento de CPU e memória
top
htop # Interface melhor (instalar se necessário)
# Monitoramento de disco
df -h # Espaço em disco
du -sh * # Tamanho de arquivos/diretórios
ncdu # Navegador de uso de disco (instalar)
# Operações de I/O
iostat # Estatísticas de E/S
iotop # Top para I/O (instalar)
# Estatísticas de desempenho
vmstat
mpstat # Estatísticas de CPU
free -h # Memória disponível
# Informações de hardware
lscpu # Informações de CPU
lsblk # Dispositivos de bloco
lspci # Dispositivos PCI
lsusb # Dispositivos USB
dmidecode # Informações detalhadas
# Logs do sistema
dmesg # Mensagens do kernel
journalctl # Logs do systemd
tail -f /var/log/syslog # Monitorar logs em tempo real
# Estatísticas em tempo real
watch -n 1 "ps aux | sort -rk 3 | head -10" # Top 10 CPU
watch -n 1 "free -m" # Atualizar uso de memória| Atalho | Descrição |
|---|---|
| Ctrl+C | Interromper processo atual |
| Ctrl+Z | Suspender processo atual |
| Ctrl+D | Enviar EOF (sair do shell) |
| Ctrl+L | Limpar tela (igual a clear) |
| Ctrl+A | Ir para o início da linha |
| Ctrl+E | Ir para o fim da linha |
| Ctrl+U | Limpar do cursor até o início |
| Ctrl+K | Limpar do cursor até o fim |
| Ctrl+W | Apagar palavra anterior |
| Ctrl+R | Pesquisar histórico |
| Tab | Autocompletar |
| Seta para cima/baixo | Navegar histórico de comandos |
# Expansão de tilde
cd ~ # Diretório home do usuário atual
cd ~usuario # Diretório home de outro usuário
# Expansão de brace
echo {1..5} # 1 2 3 4 5
echo {a..e} # a b c d e
mkdir -p projeto/{src,docs,tests}
cp arquivo.txt{,.bak} # Copia para arquivo.txt.bak
# Substituição de comando
echo "Hoje é $(date +%d/%m/%Y)"
files=$(find . -name "*.txt")
# Expansão de parâmetros
echo ${var:-padrão} # Usa 'padrão' se var não estiver definida
echo ${var:=padrão} # Define var como 'padrão' se não estiver definida
echo ${#var} # Comprimento da string
echo ${var:0:5} # Primeiros 5 caracteres
echo ${var/old/new} # Substitui 'old' por 'new'
# Expansão de nomes de arquivo (globbing)
ls *.txt # Qualquer arquivo .txt
ls [a-c]*.txt # Arquivos .txt começando com a, b ou c
ls file[0-9].txt # file1.txt, file2.txt, etc
ls file?.txt # file1.txt, fileA.txt, etc (um caractere)
ls **/logs # logs em qualquer subdiretório# Aliases temporários
alias ll='ls -la'
alias cls='clear'
alias ..='cd ..'
alias ...='cd ../..'
# Adicionando ao .bashrc para persistência
echo 'alias ll="ls -la"' >> ~/.bashrc
echo 'alias gits="git status"' >> ~/.bashrc
# Função de utilidade
cd_make() {
mkdir -p "$1" && cd "$1"
}
# Adicionando ao .bashrc
echo 'cd_make() { mkdir -p "$1" && cd "$1"; }' >> ~/.bashrc
# Função para extrair arquivos
extract() {
if [ -f "$1" ]; then
case "$1" in
*.tar.bz2) tar xjf "$1" ;;
*.tar.gz) tar xzf "$1" ;;
*.bz2) bunzip2 "$1" ;;
*.rar) unrar e "$1" ;;
*.gz) gunzip "$1" ;;
*.tar) tar xf "$1" ;;
*.tbz2) tar xjf "$1" ;;
*.tgz) tar xzf "$1" ;;
*.zip) unzip "$1" ;;
*.Z) uncompress "$1" ;;
*.7z) 7z x "$1" ;;
*) echo "'$1' não pode ser extraído" ;;
esac
else
echo "'$1' não é um arquivo válido"
fi
}
# Carregando as mudanças
source ~/.bashrc# Arquivo de configuração principal
nano ~/.bashrc # Para bash
nano ~/.zshrc # Para zsh
# Definindo o editor padrão
export EDITOR=nano
export VISUAL=nano
# Configurando o histórico
export HISTSIZE=10000 # Tamanho do histórico na memória
export HISTFILESIZE=10000 # Tamanho do arquivo de histórico
export HISTCONTROL=ignoreboth # Ignorar duplicatas e comandos com espaço
# Configurando o prompt (PS1)
# \u: nome do usuário, \h: hostname, \w: diretório atual
# \t: hora, \d: data, \n: nova linha, \$: $ ou # (root)
export PS1="\u@\h:\w\\$ "
# Prompt colorido
export PS1="\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]\\$ "
# Adicionar caminho ao PATH
export PATH="$HOME/bin:$PATH"
# Aliases comuns
alias update='sudo apt update && sudo apt upgrade'
alias mkdir='mkdir -p'
alias grep='grep --color=auto'
# Criando uma pasta de scripts pessoais
mkdir -p ~/bin
echo 'export PATH="$HOME/bin:$PATH"' >> ~/.bashrc
# Ferramentas de melhoria do terminal
# (instale primeiro)
# - Oh My Zsh (para zsh)
# - Bash-it (para bash)
# - Starship (prompt cross-shell)
# - fzf (pesquisa fuzzy)
# Instalando Starship
# curl -sS https://starship.rs/install.sh | sh
echo 'eval "$(starship init bash)"' >> ~/.bashrc# Encontrar arquivos modificados nas últimas 24h
find . -type f -mtime -1
# Contar linhas de código em arquivos .py
find . -name "*.py" | xargs wc -l
# Encontrar arquivos duplicados
find . -type f -exec md5sum {} \; | sort | uniq -w32 -d
# Substituir texto em vários arquivos
find . -name "*.html" -exec sed -i 's/antigo/novo/g' {} \;
# Ordenar arquivos por tamanho
ls -lS /caminho | head -10
# Buscar IPs em logs
grep -E -o "([0-9]{1,3}[\.]){3}[0-9]{1,3}" arquivo.log | sort | uniq -c
# Encontrar processos usando muita memória
ps aux | sort -nk 4 | tail -10
# Converter espaços em tabs
sed 's/ \+/\t/g' arquivo.txt# Servidor HTTP simples no diretório atual
python3 -m http.server 8000
# Baixar site inteiro
wget -mk -w 20 http://exemplo.com/
# Ver usuários logados e o que estão fazendo
w
# Verificar conectividade com rede externa
ping -c 4 8.8.8.8
# Medir tempo de resposta de site
curl -s -w "%{time_total}\n" -o /dev/null http://exemplo.com
# Monitorar conexões HTTP
sudo tcpdump -i eth0 port 80 -n
# Ver portas abertas
sudo lsof -i -P -n | grep LISTEN
# Gerar senha segura
openssl rand -base64 12# Executar vários comandos sequencialmente
comando1 && comando2 && comando3 # Próximo só se anterior suceder
comando1 ; comando2 ; comando3 # Executa todos independente de erros
comando1 || comando2 # comando2 só executa se comando1 falhar
# Executar em background e desconectar
nohup comando > /dev/null 2>&1 &
# Redirecionamento de stdout e stderr para arquivo
comando > output.log 2>&1
# Múltiplos comandos pipe
cat arquivo.log | grep "erro" | sort | uniq -c | sort -nr
# Executar comando para cada linha de um arquivo
cat lista.txt | while read linha; do echo "Processando $linha"; comando "$linha"; done
# Executar comando em cada arquivo
find . -name "*.jpg" -exec convert {} {}.png \;
# Combinar saídas de diferentes comandos
paste <(ls -l) <(ls -l | md5sum)
# Processar arquivo CSV
cat dados.csv | cut -d, -f1,3 | sort | uniq > resultado.txt