DEV Community: Davi

Comandos Essenciais do Linux (Nv-2)

Davi — Thu, 02 Jan 2025 18:19:27 +0000

Se tornando um mago

Olá para você novamente! Hoje vamos explorar comandos mais complexos e bem construídos, com explicações completas e detalhadas sobre cada um deles. Este artigo será mais abrangente que o primeiro, refletindo o nível intermediário que vamos abordar aqui. Então, prepare-se para fortalecer ainda mais suas habilidades no terminal Linux!

1. `sudo apt install` e suas variantes

O que faz?

O comando sudo apt install é utilizado para instalar pacotes no sistema baseado em distribuições Debian, como Ubuntu. Ele funciona em conjunto com o apt, que é o gerenciador de pacotes, e requer permissões de superusuário (sudo) para modificar o sistema.

Exemplo

sudo apt install curl

No exemplo acima, o comando instala o pacote curl, uma ferramenta para transferir dados de ou para um servidor.

Explicação técnica

sudo: Permite executar o comando com permissões de superusuário, necessárias para ações que modificam o sistema. Sem isso, você receberia uma mensagem de "Permissão negada".
apt: O Advanced Package Tool é responsável por gerenciar pacotes no Linux. Ele pode buscar, instalar, atualizar e remover softwares do repositório oficial da distribuição.
install: Indica ao apt que você deseja instalar o pacote especificado.

O que acontece no sistema?

Busca no repositório: O apt verifica no repositório oficial da distribuição (ou repositórios configurados) se o pacote está disponível.
Resolução de dependências: Caso o pacote precise de outros para funcionar, o apt também os baixa e instala automaticamente.
Instalação: Os arquivos são baixados, extraídos e colocados nas localizações corretas no sistema.

Variações úteis

Instalar múltiplos pacotes de uma vez:

sudo apt install curl git vim

Simular a instalação (sem realmente executar):

sudo apt install --simulate curl

Reinstalar um pacote já instalado:

sudo apt install --reinstall curl

2. `tar` - Compactação e descompactação de arquivos

O que faz?

O comando tar é usado para criar, extrair, listar ou manipular arquivos compactados (ou pacotes de arquivos). Ele não comprime por si só, mas é frequentemente usado junto com ferramentas de compressão, como gzip ou bzip2.

Exemplo

Compactando um diretório:

tar -cvf backup.tar /meu_diretorio

Descompactando o arquivo gerado:

tar -xvf backup.tar

Explicação técnica

-c (create): Cria um novo arquivo tar.
-v (verbose): Exibe detalhes do processo no terminal, como os arquivos sendo adicionados ou extraídos.
-f (file): Especifica o nome do arquivo que será criado ou extraído.
-x (extract): Extrai o conteúdo de um arquivo tar.

Variações úteis

Compactação com compressão (gzip):

   tar -czvf backup.tar.gz /meu_diretorio

Aqui, o -z ativa a compressão com gzip, gerando um arquivo menor.

Extraindo arquivos compactados (gzip):

   tar -xzvf backup.tar.gz

Visualizando o conteúdo de um arquivo tar:

   tar -tvf backup.tar

Compactando e excluindo os arquivos originais:

   tar --remove-files -cvf backup.tar /meu_diretorio

O que acontece no sistema?

Quando você cria um arquivo com o tar, o comando empacota vários arquivos ou diretórios em um único arquivo, facilitando a movimentação ou o backup de dados. Ao adicionar compressão com ferramentas como gzip, o arquivo gerado ocupa menos espaço em disco, sendo ideal para armazenamento e transferência.

3. `chmod` - Controle de permissões de arquivos e diretórios

O que faz?

O comando chmod altera as permissões de arquivos e diretórios, permitindo configurar quem pode ler, escrever ou executar um arquivo no sistema.

Exemplo

Alterando as permissões de um arquivo para que apenas o dono possa ler e escrever:

chmod 600 arquivo.txt

Dando permissão de execução a todos os usuários:

chmod +x script.sh

Explicação técnica

O chmod usa uma combinação de números ou símbolos para definir permissões.

Modelo simbólico:
- + para adicionar permissões.
- - para remover permissões.
- = para definir permissões específicas. Exemplo:

   chmod u+x script.sh

Aqui, u significa usuário, e +x adiciona a permissão de execução.

Modelo numérico: As permissões são representadas por números:
- 4 = leitura (r)
- 2 = escrita (w)
- 1 = execução (x)

A soma desses valores define as permissões:

7 = leitura + escrita + execução (rwx)
6 = leitura + escrita (rw-)
5 = leitura + execução (r-x)
0 = nenhuma permissão (---)

O número final tem 3 dígitos, representando:

Primeiro dígito: permissões do dono do arquivo.
Segundo dígito: permissões do grupo.
Terceiro dígito: permissões para outros.

Exemplo:

   chmod 755 script.sh

Permissões:

Dono: leitura, escrita e execução (rwx).
Grupo: leitura e execução (r-x).
Outros: leitura e execução (r-x).

Variações úteis

Removendo todas as permissões para outros usuários:

   chmod o-rwx arquivo.txt

Dando permissão total apenas ao dono:

   chmod 700 diretorio

Tornando um script executável:

   chmod +x script.sh

O que acontece no sistema?

Quando o chmod é usado, ele modifica as permissões no sistema de arquivos. Essas permissões são essenciais para segurança, garantindo que apenas usuários ou grupos autorizados possam acessar ou modificar arquivos.

4. `grep` - Pesquisa avançada em arquivos e saídas de comandos

O que faz?

O comando grep pesquisa padrões de texto em arquivos ou na saída de outros comandos, exibindo linhas que correspondem a uma determinada expressão regular.

Exemplo

Pesquisando a palavra "erro" em um arquivo de log:

grep "erro" log.txt

Pesquisando de forma recursiva em um diretório:

grep -r "config" /etc

Filtrando a saída de outro comando:

ps aux | grep "apache"

Explicação técnica

Estrutura básica do comando:

   grep [opções] "padrão" [arquivo]

padrão: Texto ou expressão regular que você quer localizar.
arquivo: Arquivo ou conjunto de arquivos onde será feita a busca.

Principais opções:
- -i: Ignora maiúsculas e minúsculas.
```
 grep -i "config" arquivo.txt
```

-n: Mostra o número da linha onde o padrão foi encontrado.
```
 grep -n "erro" log.txt
```
-r: Busca recursiva em diretórios.
-v: Mostra linhas que não correspondem ao padrão.
```
 grep -v "sucesso" log.txt
```
--color: Destaca o texto encontrado no terminal.

Expressões regulares avançadas:
- .: Corresponde a qualquer caractere.
```
 grep "t.st" arquivo.txt
```
Encontra palavras como "test", "tost" ou "tast".
- ^: Indica o início de uma linha.
```
 grep "^Erro" log.txt
```
Encontra linhas que começam com "Erro".
- $: Indica o final de uma linha.
```
 grep "fim$" arquivo.txt
```
Encontra linhas que terminam com "fim".
- *: Zero ou mais ocorrências do caractere anterior.
```
 grep "go*gle" texto.txt
```
Encontra palavras como "ggle", "gogle", "google", etc.
Combinando com outros comandos:

O grep é ainda mais poderoso quando usado em pipelines:
- Encontrando processos específicos:
```
 ps aux | grep "nginx"
```

Buscando logs em tempo real:
```
 tail -f log.txt | grep "erro"
```

Variações úteis

Contar ocorrências de um padrão:

   grep -c "padrão" arquivo.txt

Mostrar apenas os nomes dos arquivos que contêm o padrão:

   grep -l "main" *.c

Mostrar o contexto ao redor do padrão:
- -A: Mostra as linhas após o padrão.
- -B: Mostra as linhas antes do padrão.
- -C: Mostra as linhas antes e depois.
```
 grep -C 2 "erro" log.txt
```

O que acontece no sistema?

O grep utiliza uma abordagem eficiente para percorrer arquivos linha por linha, analisando o texto com base no padrão definido. Ele é amplamente utilizado em scripts para automação e análise de dados.

6. `rsync` - Sincronização de Arquivos e Diretórios

O que faz?

O comando rsync é utilizado para sincronizar arquivos e diretórios de forma eficiente, localmente ou remotamente. Ele copia apenas as diferenças entre a origem e o destino, economizando tempo e largura de banda.

Exemplo

Sincronizando um diretório local:

   rsync -av /origem/ /destino/

Transferindo arquivos para um servidor remoto:

   rsync -av /meus_arquivos/ usuario@servidor:/caminho_destino/

Excluindo arquivos do destino que não existem na origem:

   rsync -av --delete /origem/ /destino/

Sincronizando arquivos entre dois servidores remotos:

   rsync -av usuario1@servidor1:/origem/ usuario2@servidor2:/destino/

Explicação técnica

Estrutura básica do comando:

   rsync [opções] origem destino

Opções principais:
- -a (archive): Preserva atributos do arquivo (permissões, timestamps, links simbólicos).
- -v (verbose): Exibe detalhes do processo de cópia.
- --delete: Remove arquivos no destino que não estão presentes na origem.
- --progress: Exibe o progresso da transferência de cada arquivo.
- -z: Comprime os arquivos durante a transferência.
Diretórios de origem e destino:
- Para copiar apenas o conteúdo de um diretório (não o próprio diretório), adicione / no final:
```
 rsync -av /origem/ /destino/
```

Para copiar o diretório inteiro, não use a barra:
```
 rsync -av /origem /destino/
```

Sincronização remota: O rsync pode usar SSH para transferências seguras:

   rsync -av -e ssh /origem usuario@servidor:/destino/

Filtros e exclusões: Você pode incluir ou excluir arquivos específicos com:

   rsync -av --exclude='*.tmp' /origem/ /destino/

Isso exclui todos os arquivos com extensão .tmp.

Variações úteis

Sincronizar somente arquivos alterados:

   rsync -av --update /origem/ /destino/

Criar backups incrementais:

   rsync -av --backup --backup-dir=/backup_incremental /origem/ /destino/

Sincronizar com verificação de integridade:

   rsync -av --checksum /origem/ /destino/

O que acontece no sistema?

O rsync utiliza um algoritmo de delta para comparar os dados da origem e do destino, transferindo apenas as partes que foram alteradas. Ele também cria um índice para evitar a cópia redundante de arquivos, tornando o processo rápido e eficiente, mesmo para grandes volumes de dados.

Parabéns, jovem mago! 🧙‍♂️ Com esses comandos intermediários, você está cada vez mais próximo de dominar o terminal e liberar todo o seu potencial no Linux. Siga minhas aventuras e dicas mágicas no meu Twitter:https://x.com/davvzin

Comandos Essenciais do Linux (Nv-1)

Davi — Mon, 30 Dec 2024 22:15:42 +0000

Torne-se um Mago do Terminal

O terminal Linux pode parecer intimidador para iniciantes, mas com o domínio de alguns comandos essenciais, você pode se tornar um verdadeiro "mago". Este artigo vai guiá-lo pelos fundamentos e comandos básicos que todo usuário de Linux precisa conhecer.

O Que É o Terminal?

O terminal é a interface de linha de comando usada para interagir com o sistema operacional. No Linux, ele geralmente utiliza o Bash (Bourne Again Shell) como shell padrão, mas existem outros tipos, como Zsh, Fish e Ksh. Aqui, usaremos exemplos do Bash, mas os conceitos são aplicáveis a outros shells.

Dica: se você usa o Zsh, pode personalizá-lo com plugins e temas (como o Oh My Zsh) para tornar seu uso mais prático e visualmente atraente. (meu caso)

1. Navegação no Sistema de Arquivos

Para se movimentar pelo sistema de arquivos, você usa comandos como ls e cd.

Comandos:

ls: Lista o conteúdo do diretório atual.

ls

ls -l: Mostra o conteúdo com mais detalhes (permissões, tamanho, etc.).

  ls -l

ls -a: Mostra arquivos ocultos.

  ls -a

cd: Altera o diretório atual.

  cd /caminho/do/diretorio

cd ..: Retorna ao diretório anterior.

  cd ..

2. Manipulação de Arquivos e Diretórios

Aprenda a criar, mover, copiar e deletar arquivos e diretórios com comandos simples.

Comandos:

touch: Cria um arquivo vazio.

  touch arquivo.txt

mkdir: Cria um novo diretório.

  mkdir novo_diretorio

cp: Copia arquivos ou diretórios.

  cp arquivo.txt copia_arquivo.txt

mv: Move ou renomeia arquivos.

  mv arquivo.txt novo_nome.txt

rm: Remove arquivos.

  rm arquivo.txt

rm -r: Remove diretórios recursivamente.

  rm -r diretorio

3. Visualização de Arquivos

Visualizar o conteúdo de arquivos é fundamental para depuração e leitura de logs.

Comandos:

cat: Mostra o conteúdo de um arquivo.

  cat arquivo.txt

less: Permite navegar pelo conteúdo de um arquivo de forma interativa.

  less arquivo.txt

head: Exibe as primeiras linhas de um arquivo.

  head arquivo.txt

tail: Exibe as últimas linhas de um arquivo.

  tail arquivo.txt

4. Buscas e Filtros

Localizar arquivos ou filtrar informações dentro deles pode ser incrivelmente útil.

Comandos:

find: Busca por arquivos no sistema.

  find / -name arquivo.txt

grep: Pesquisa por um texto dentro de arquivos.

  grep "palavra" arquivo.txt

5. Gerenciamento de Processos

Monitore e controle os processos em execução no seu sistema.

Comandos:

ps: Mostra processos em execução.

  ps aux

top: Exibe processos em tempo real.

top

kill: Encerra um processo.

  kill PID

6. Comandos Gerais

Alguns comandos adicionais que tornam sua vida no terminal mais fácil.

Comandos:

clear: Limpa a tela do terminal.

  clear

history: Mostra o histórico de comandos executados.

  history

man: Exibe o manual de um comando.

  man ls

Um abraço e até o Nv-2

Quer aprender PHP?

Davi — Sat, 13 Apr 2024 16:34:09 +0000

Vamos ver alguns conceitos então my brother

Variáveis e Tipos de Dados:

$nome = "João";
$idade = 25;
$altura = 1.75;
$temperatura = true;

Operadores:

$a = 10;
$b = 5;
$c = $a + $b; // $c será 15
$d = $a > $b; // $d será true
$nome_completo = "João" . " " . "Silva"; // Concatenação de strings

Estruturas de Controle:

$idade = 18;

if ($idade >= 18) {
    echo "Pode entrar";
} else {
    echo "Não pode entrar";
}

for ($i = 0; $i < 5; $i++) {
    echo $i;
}

$array = [1, 2, 3];
foreach ($array as $valor) {
    echo $valor;
}

Funções:

function soma($a, $b) {
    return $a + $b;
}

$resultado = soma(3, 4); // $resultado será 7

Arrays:

$array = array(1, 2, 3);
echo $array[0]; // Saída: 1

$count = count($array); // $count será 3

array_push($array, 4); // Adiciona o valor 4 ao final do array

Manipulação de Strings:

$nome = "João";
echo strlen($nome); // Saída: 4

$mensagem = "Olá mundo!";
echo substr($mensagem, 0, 3); // Saída: Olá

Trabalhando com Formulários HTML:

// Supondo que o formulário tenha um campo de entrada com o nome 'nome'
$nome = $_POST['nome'];
echo $nome;

Inclusão de Arquivos:

include 'funcoes.php';

Tratamento de Erros:

try {
    // código que pode gerar um erro
} catch (Exception $e) {
    echo "Ocorreu um erro: " . $e->getMessage();
}

Comentários:

// Este é um comentário de linha única

/*
Este é um comentário
de múltiplas linhas
*/

"só isso Davi??" Claro q não meu parceiro.

Vamos ver um pouco sobre a sintx echo

Exemplo 1: Imprimindo uma string diretamente:

   $mensagem = "Olá mundo!";
   echo $mensagem;

Neste exemplo, a variável $mensagem contém a string "Olá mundo!". O echo simplesmente imprime essa string na saída. No contexto de uma página da web, essa saída será o conteúdo exibido no navegador.

Exemplo 2: Concatenando uma mensagem com uma variável:

   $nome = "João";
   echo "Olá, " . $nome . "! Bem-vindo!";

Neste caso, o echo imprime uma mensagem que é uma concatenação de três partes:

A string "Olá, ".
O conteúdo da variável $nome.
A string "! Bem-vindo!".

Quando executado, o resultado será algo como "Olá, João! Bem-vindo!". Aqui, o echo permite a combinação de strings e variáveis em uma única saída.

"A davi mais cade os arrays?" - Toma ai

Para imprimir um array em PHP, você pode usar a função print_r() ou var_dump(). Aqui está como você pode fazer isso:

$array = array("maçã", "banana", "laranja");
echo "O conteúdo do array é: ";
print_r($array);

Este código irá imprimir algo assim:

O conteúdo do array é: Array ( [0] => maçã [1] => banana [2] => laranja )

ou, usando var_dump():

$array = array("maçã", "banana", "laranja");
echo "O conteúdo do array é: ";
var_dump($array);

Este código irá imprimir algo assim:

O conteúdo do array é: array(3) { [0]=> string(5) "maçã" [1]=> string(6) "banana" [2]=> string(7) "laranja" }

Ambos print_r() e var_dump() são úteis para imprimir o conteúdo de um array em PHP, mas var_dump() fornece mais informações sobre os tipos de dados e os comprimentos das strings. Escolha o método que melhor atenda às suas necessidades de depuração ou exibição de dados.

"Agora já posso arranjar um trampo mano dayvis?" pode sim mano CONFIA

Vamos ver banco de dados pra finalizar

<?php
// Dados de conexão ao banco de dados
$host = 'localhost'; // Endereço do servidor MySQL
$usuario = 'usuario'; // Nome de usuário do MySQL
$senha = 'senha'; // Senha do MySQL
$banco_de_dados = 'nome_do_banco'; // Nome do banco de dados MySQL

// Conexão com o banco de dados
$conexao = new mysqli($host, $usuario, $senha, $banco_de_dados);

// Verifica se houve algum erro na conexão
if ($conexao->connect_error) {
    die("Erro na conexão: " . $conexao->connect_error);
}

// Consulta SQL
$sql = "SELECT * FROM tabela";

// Executa a consulta
$resultado = $conexao->query($sql);

// Verifica se a consulta retornou resultados
if ($resultado->num_rows > 0) {
    // Exibe os resultados
    while($linha = $resultado->fetch_assoc()) {
        echo "ID: " . $linha["id"] . " - Nome: " . $linha["nome"] . "<br>";
    }
} else {
    echo "Não foram encontrados resultados.";
}

// Fecha a conexão
$conexao->close();
?>

Neste exemplo:

mysqli é uma classe PHP usada para interagir com o MySQL.
new mysqli() cria uma nova instância de conexão com o MySQL.
connect_error verifica se houve algum erro na conexão.
query() executa a consulta SQL no banco de dados.
fetch_assoc() obtém cada linha de resultado como um array associativo.
num_rows verifica o número de linhas retornadas pela consulta.

Certifique-se de substituir 'localhost', 'usuario', 'senha' e 'nome_do_banco' pelos valores corretos correspondentes ao seu ambiente de desenvolvimento. Além disso, substitua 'tabela', 'id' e 'nome' pelos nomes reais da tabela e dos campos em sua base de dados.

Claro, vamos dar um toque mais descontraído e divertido a esses exemplos!

UPDATE (atualização de dados) - atualizar.php:

<?php
$host = 'uma_caverna_misteriosa';
$usuario = 'o_guardião';
$senha = 'segredo_antigo';
$banco_de_dados = 'livro_dos_tesouros';
$conexao = new mysqli($host, $usuario, $senha, $banco_de_dados);

if ($conexao->connect_error) {
    die("Ops, parece que tropeçamos em uma rocha! Erro: " . $conexao->connect_error);
}

$novo_nome = "O Novo Herói";
$id = 1;

$sql = "UPDATE tabela SET nome='$novo_nome' WHERE id=$id";

if ($conexao->query($sql) === TRUE) {
    echo "O herói foi renomeado com sucesso!";
} else {
    echo "Uh-oh! O feitiço de atualização falhou: " . $conexao->error;
}

$conexao->close();
?>

SELECT (consulta de dados) - consultar.php:

<?php
$host = 'uma_caverna_misteriosa';
$usuario = 'o_guardião';
$senha = 'segredo_antigo';
$banco_de_dados = 'livro_dos_tesouros';
$conexao = new mysqli($host, $usuario, $senha, $banco_de_dados);

if ($conexao->connect_error) {
    die("Ops, parece que tropeçamos em uma rocha! Erro: " . $conexao->connect_error);
}

$sql = "SELECT * FROM tabela";

$resultado = $conexao->query($sql);

if ($resultado->num_rows > 0) {
    while($linha = $resultado->fetch_assoc()) {
        echo "Ah, olha só! Encontramos um tesouro: " . $linha["nome"] . "!<br>";
    }
} else {
    echo "Nenhum tesouro encontrado. Vamos continuar a busca!";
}

$conexao->close();
?>

DELETE (exclusão de dados) - excluir.php:

<?php
$host = 'uma_caverna_misteriosa';
$usuario = 'o_guardião';
$senha = 'segredo_antigo';
$banco_de_dados = 'livro_dos_tesouros';
$conexao = new mysqli($host, $usuario, $senha, $banco_de_dados);

if ($conexao->connect_error) {
    die("Ops, parece que tropeçamos em uma rocha! Erro: " . $conexao->connect_error);
}

$id = 1;

$sql = "DELETE FROM tabela WHERE id=$id";

if ($conexao->query($sql) === TRUE) {
    echo "O tesouro foi encontrado e destruído!";
} else {
    echo "Uh-oh! O feitiço de exclusão falhou: " . $conexao->error;
}

$conexao->close();
?>

INSERT (inserção de dados) - inserir.php:

<?php
$host = 'uma_caverna_misteriosa';
$usuario = 'o_guardião';
$senha = 'segredo_antigo';
$banco_de_dados = 'livro_dos_tesouros';
$conexao = new mysqli($host, $usuario, $senha, $banco_de_dados);

if ($conexao->connect_error) {
    die("Ops, parece que tropeçamos em uma rocha! Erro: " . $conexao->connect_error);
}

$novo_tesouro = "Um Amuleto Antigo";

$sql = "INSERT INTO tabela (nome) VALUES ('$novo_tesouro')";

if ($conexao->query($sql) === TRUE) {
    echo "Um novo tesouro foi descoberto e adicionado!";
} else {
    echo "Uh-oh! O feitiço de inserção falhou: " . $conexao->error;
}

$conexao->close();
?>

FROM: A cláusula FROM é usada para especificar de qual tabela ou conjunto de tabelas os dados serão selecionados. Em uma consulta SELECT, você precisa indicar de onde os dados devem ser recuperados. Por exemplo:

   SELECT * FROM tabela;

Neste caso, "tabela" é o nome da tabela da qual você deseja recuperar os dados. Você pode selecionar dados de várias tabelas simultaneamente, separando-as por vírgula na cláusula FROM.

WHERE: A cláusula WHERE é usada para filtrar os resultados da consulta com base em uma condição específica. Ele permite que você especifique critérios de seleção mais detalhados. Por exemplo:

   SELECT * FROM tabela WHERE idade > 18;

Neste exemplo, a consulta selecionará todas as linhas da tabela onde o valor da coluna "idade" for maior que 18.

INTO: A cláusula INTO é usada principalmente em comandos INSERT para especificar em qual tabela os novos dados serão inseridos. Por exemplo:

   INSERT INTO tabela (coluna1, coluna2) VALUES (valor1, valor2);

Neste exemplo, "tabela" é o nome da tabela onde você deseja inserir os novos dados, e "coluna1" e "coluna2" são os nomes das colunas às quais os valores serão inseridos.

"E agora men?"

Agora é só praticar

Quer aprender PHP?

Davi — Sat, 13 Apr 2024 16:34:09 +0000

Vamos ver alguns conceitos então my brother

Variáveis e Tipos de Dados:

$nome = "João";
$idade = 25;
$altura = 1.75;
$temperatura = true;

Operadores:

$a = 10;
$b = 5;
$c = $a + $b; // $c será 15
$d = $a > $b; // $d será true
$nome_completo = "João" . " " . "Silva"; // Concatenação de strings

Estruturas de Controle:

$idade = 18;

if ($idade >= 18) {
    echo "Pode entrar";
} else {
    echo "Não pode entrar";
}

for ($i = 0; $i < 5; $i++) {
    echo $i;
}

$array = [1, 2, 3];
foreach ($array as $valor) {
    echo $valor;
}

Funções:

function soma($a, $b) {
    return $a + $b;
}

$resultado = soma(3, 4); // $resultado será 7

Arrays:

$array = array(1, 2, 3);
echo $array[0]; // Saída: 1

$count = count($array); // $count será 3

array_push($array, 4); // Adiciona o valor 4 ao final do array

Manipulação de Strings:

$nome = "João";
echo strlen($nome); // Saída: 4

$mensagem = "Olá mundo!";
echo substr($mensagem, 0, 3); // Saída: Olá

Trabalhando com Formulários HTML:

// Supondo que o formulário tenha um campo de entrada com o nome 'nome'
$nome = $_POST['nome'];
echo $nome;

Inclusão de Arquivos:

include 'funcoes.php';

Tratamento de Erros:

try {
    // código que pode gerar um erro
} catch (Exception $e) {
    echo "Ocorreu um erro: " . $e->getMessage();
}

Comentários:

// Este é um comentário de linha única

/*
Este é um comentário
de múltiplas linhas
*/

"só isso Davi??" Claro q não meu parceiro.

Vamos ver um pouco sobre a sintx echo

Exemplo 1: Imprimindo uma string diretamente:

   $mensagem = "Olá mundo!";
   echo $mensagem;

Exemplo 2: Concatenando uma mensagem com uma variável:

   $nome = "João";
   echo "Olá, " . $nome . "! Bem-vindo!";

Neste caso, o echo imprime uma mensagem que é uma concatenação de três partes:

A string "Olá, ".
O conteúdo da variável $nome.
A string "! Bem-vindo!".

Quando executado, o resultado será algo como "Olá, João! Bem-vindo!". Aqui, o echo permite a combinação de strings e variáveis em uma única saída.

"A davi mais cade os arrays?" - Toma ai

Para imprimir um array em PHP, você pode usar a função print_r() ou var_dump(). Aqui está como você pode fazer isso:

$array = array("maçã", "banana", "laranja");
echo "O conteúdo do array é: ";
print_r($array);

Este código irá imprimir algo assim:

O conteúdo do array é: Array ( [0] => maçã [1] => banana [2] => laranja )

ou, usando var_dump():

$array = array("maçã", "banana", "laranja");
echo "O conteúdo do array é: ";
var_dump($array);

Este código irá imprimir algo assim:

O conteúdo do array é: array(3) { [0]=> string(5) "maçã" [1]=> string(6) "banana" [2]=> string(7) "laranja" }

"Agora já posso arranjar um trampo mano dayvis?" pode sim mano CONFIA

Vamos ver banco de dados pra finalizar

<?php
// Dados de conexão ao banco de dados
$host = 'localhost'; // Endereço do servidor MySQL
$usuario = 'usuario'; // Nome de usuário do MySQL
$senha = 'senha'; // Senha do MySQL
$banco_de_dados = 'nome_do_banco'; // Nome do banco de dados MySQL

// Conexão com o banco de dados
$conexao = new mysqli($host, $usuario, $senha, $banco_de_dados);

// Verifica se houve algum erro na conexão
if ($conexao->connect_error) {
    die("Erro na conexão: " . $conexao->connect_error);
}

// Consulta SQL
$sql = "SELECT * FROM tabela";

// Executa a consulta
$resultado = $conexao->query($sql);

// Verifica se a consulta retornou resultados
if ($resultado->num_rows > 0) {
    // Exibe os resultados
    while($linha = $resultado->fetch_assoc()) {
        echo "ID: " . $linha["id"] . " - Nome: " . $linha["nome"] . "<br>";
    }
} else {
    echo "Não foram encontrados resultados.";
}

// Fecha a conexão
$conexao->close();
?>

Neste exemplo:

mysqli é uma classe PHP usada para interagir com o MySQL.
new mysqli() cria uma nova instância de conexão com o MySQL.
connect_error verifica se houve algum erro na conexão.
query() executa a consulta SQL no banco de dados.
fetch_assoc() obtém cada linha de resultado como um array associativo.
num_rows verifica o número de linhas retornadas pela consulta.

Claro, vamos dar um toque mais descontraído e divertido a esses exemplos!

UPDATE (atualização de dados) - atualizar.php:

<?php
$host = 'uma_caverna_misteriosa';
$usuario = 'o_guardião';
$senha = 'segredo_antigo';
$banco_de_dados = 'livro_dos_tesouros';
$conexao = new mysqli($host, $usuario, $senha, $banco_de_dados);

if ($conexao->connect_error) {
    die("Ops, parece que tropeçamos em uma rocha! Erro: " . $conexao->connect_error);
}

$novo_nome = "O Novo Herói";
$id = 1;

$sql = "UPDATE tabela SET nome='$novo_nome' WHERE id=$id";

if ($conexao->query($sql) === TRUE) {
    echo "O herói foi renomeado com sucesso!";
} else {
    echo "Uh-oh! O feitiço de atualização falhou: " . $conexao->error;
}

$conexao->close();
?>

SELECT (consulta de dados) - consultar.php:

<?php
$host = 'uma_caverna_misteriosa';
$usuario = 'o_guardião';
$senha = 'segredo_antigo';
$banco_de_dados = 'livro_dos_tesouros';
$conexao = new mysqli($host, $usuario, $senha, $banco_de_dados);

if ($conexao->connect_error) {
    die("Ops, parece que tropeçamos em uma rocha! Erro: " . $conexao->connect_error);
}

$sql = "SELECT * FROM tabela";

$resultado = $conexao->query($sql);

if ($resultado->num_rows > 0) {
    while($linha = $resultado->fetch_assoc()) {
        echo "Ah, olha só! Encontramos um tesouro: " . $linha["nome"] . "!<br>";
    }
} else {
    echo "Nenhum tesouro encontrado. Vamos continuar a busca!";
}

$conexao->close();
?>

DELETE (exclusão de dados) - excluir.php:

<?php
$host = 'uma_caverna_misteriosa';
$usuario = 'o_guardião';
$senha = 'segredo_antigo';
$banco_de_dados = 'livro_dos_tesouros';
$conexao = new mysqli($host, $usuario, $senha, $banco_de_dados);

if ($conexao->connect_error) {
    die("Ops, parece que tropeçamos em uma rocha! Erro: " . $conexao->connect_error);
}

$id = 1;

$sql = "DELETE FROM tabela WHERE id=$id";

if ($conexao->query($sql) === TRUE) {
    echo "O tesouro foi encontrado e destruído!";
} else {
    echo "Uh-oh! O feitiço de exclusão falhou: " . $conexao->error;
}

$conexao->close();
?>

INSERT (inserção de dados) - inserir.php:

<?php
$host = 'uma_caverna_misteriosa';
$usuario = 'o_guardião';
$senha = 'segredo_antigo';
$banco_de_dados = 'livro_dos_tesouros';
$conexao = new mysqli($host, $usuario, $senha, $banco_de_dados);

if ($conexao->connect_error) {
    die("Ops, parece que tropeçamos em uma rocha! Erro: " . $conexao->connect_error);
}

$novo_tesouro = "Um Amuleto Antigo";

$sql = "INSERT INTO tabela (nome) VALUES ('$novo_tesouro')";

if ($conexao->query($sql) === TRUE) {
    echo "Um novo tesouro foi descoberto e adicionado!";
} else {
    echo "Uh-oh! O feitiço de inserção falhou: " . $conexao->error;
}

$conexao->close();
?>

FROM: A cláusula FROM é usada para especificar de qual tabela ou conjunto de tabelas os dados serão selecionados. Em uma consulta SELECT, você precisa indicar de onde os dados devem ser recuperados. Por exemplo:

   SELECT * FROM tabela;

Neste caso, "tabela" é o nome da tabela da qual você deseja recuperar os dados. Você pode selecionar dados de várias tabelas simultaneamente, separando-as por vírgula na cláusula FROM.

WHERE: A cláusula WHERE é usada para filtrar os resultados da consulta com base em uma condição específica. Ele permite que você especifique critérios de seleção mais detalhados. Por exemplo:

   SELECT * FROM tabela WHERE idade > 18;

Neste exemplo, a consulta selecionará todas as linhas da tabela onde o valor da coluna "idade" for maior que 18.

INTO: A cláusula INTO é usada principalmente em comandos INSERT para especificar em qual tabela os novos dados serão inseridos. Por exemplo:

   INSERT INTO tabela (coluna1, coluna2) VALUES (valor1, valor2);

Neste exemplo, "tabela" é o nome da tabela onde você deseja inserir os novos dados, e "coluna1" e "coluna2" são os nomes das colunas às quais os valores serão inseridos.

"E agora men?"

Agora é só praticar

Introdução a APIS s

Davi — Wed, 09 Aug 2023 02:04:21 +0000

Guia Completo sobre APIs

As APIs (Interfaces de Programação de Aplicativos) são uma parte fundamental da construção de software moderno. Elas permitem que diferentes sistemas e serviços se comuniquem e interajam entre si. Neste guia, exploraremos o que é uma API, como ela funciona e forneceremos exemplos de códigos para ilustrar conceitos-chave.

O que é uma API?

Uma API é um conjunto de regras e protocolos que permitem que diferentes componentes de software se comuniquem uns com os outros. Ela define como solicitar determinadas ações ou acessar dados de um serviço ou aplicativo, sem precisar entender a complexidade interna desse serviço.

Tipos de APIs

Existem diversos tipos de APIs, incluindo:

APIs da Web: Essas APIs são acessadas via HTTP e geralmente retornam dados em formatos como JSON ou XML. Exemplo de requisição usando Python:

import requests

response = requests.get('https://api.exemplo.com/dados')
data = response.json()
print(data)

APIs de Bibliotecas: Muitas bibliotecas de programação oferecem APIs para que os desenvolvedores possam interagir com suas funcionalidades. Exemplo usando a biblioteca math do Python:

import math

valor = math.sqrt(25)
print(valor)

APIs de Sistemas Operacionais: Sistemas operacionais também oferecem APIs para que aplicativos possam interagir com recursos do sistema. Exemplo usando a API os do Python para listar arquivos em um diretório:

import os

arquivos = os.listdir('/caminho/do/diretorio')
print(arquivos)

Autenticação e Autorização

Muitas APIs requerem autenticação para garantir que apenas usuários autorizados acessem os dados. Isso geralmente envolve o uso de tokens ou chaves de API.

import requests

url = 'https://api.exemplo.com/dados'
headers = {'Authorization': 'Bearer seu-token-aqui'}
response = requests.get(url, headers=headers)

Boas Práticas

Ao usar e criar APIs, algumas boas práticas incluem:

Fornecer documentação clara para desenvolvedores.
Usar nomes de endpoints descritivos.
Versionar sua API para evitar quebra de compatibilidade.
Considerar a segurança e a proteção dos dados.

Conclusão

As APIs são essenciais para a construção de aplicativos modernos e para permitir a integração entre diferentes serviços. Compreender seus conceitos e práticas é fundamental para qualquer desenvolvedor.

Para mais informações, confira a documentação da API Exemplo.

Espero que este guia tenha fornecido uma introdução sólida às APIs e inspire você a explorar mais a fundo essa poderosa tecnologia.

Forum Import rev MySQL

Davi — Sun, 30 Jul 2023 23:16:38 +0000

Passo 1: Configuração do Projeto
Crie um novo projeto Spring Boot e adicione as seguintes dependências no arquivo pom.xml (se estiver usando o Maven):

<dependencies>
    <!-- Spring Boot Starter Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- Spring Boot Starter Data JPA -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <!-- Spring Boot Starter Security -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>

    <!-- MySQL Connector -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
</dependencies>

Passo 2: Configuração do Banco de Dados
Configure as propriedades de conexão com o banco de dados MySQL no arquivo application.properties:

spring.datasource.url=jdbc:mysql://localhost:3306/db_name
spring.datasource.username=db_username
spring.datasource.password=db_password

Substitua db_name, db_username e db_password pelos valores apropriados do seu ambiente.

Passo 3: Criar a Entidade do Usuário
Crie uma entidade JPA que representará o usuário no banco de dados:

@Entity
public class Usuario {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String login;
    private String senha;
    private String token;

    // Construtores, getters e setters
}

Passo 4: Criar o Repositório do Usuário
Crie um repositório JPA para realizar operações no banco de dados relacionadas ao usuário:

@Repository
public interface UsuarioRepository extends JpaRepository<Usuario, Long> {
    Usuario findByLogin(String login);
}

Passo 5: Criar o Serviço de Autenticação
Crie um serviço que será responsável por lidar com a autenticação e geração de tokens:

@Service
public class AuthenticationService {
    @Autowired
    private UsuarioRepository usuarioRepository;

    public String generateToken(String login) {
        // Implemente aqui a lógica para gerar o token (pode ser aleatório ou baseado no login, por exemplo)
        return UUID.randomUUID().toString();
    }

    public boolean authenticate(String login, String senha) {
        Usuario usuario = usuarioRepository.findByLogin(login);
        if (usuario != null && usuario.getSenha().equals(senha)) {
            String token = generateToken(login);
            usuario.setToken(token);
            usuarioRepository.save(usuario);
            return true;
        }
        return false;
    }

    public boolean checkToken(String token) {
        Usuario usuario = usuarioRepository.findByToken(token);
        return usuario != null;
    }
}

Passo 6: Configurar o Spring Security
Crie uma classe de configuração do Spring Security para definir as regras de autenticação e autorização:

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private AuthenticationService authenticationService;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeRequests()
                .antMatchers("/login").permitAll()
                .anyRequest().authenticated()
            .and()
            .formLogin().loginPage("/login");
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.authenticationProvider(new CustomAuthenticationProvider(authenticationService));
    }
}

Passo 7: Implementar o CustomAuthenticationProvider
Crie um provedor de autenticação personalizado para verificar as credenciais do usuário e definir a autenticação:

public class CustomAuthenticationProvider implements AuthenticationProvider {
    private final AuthenticationService authenticationService;

    public CustomAuthenticationProvider(AuthenticationService authenticationService) {
        this.authenticationService = authenticationService;
    }

    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        String login = authentication.getName();
        String senha = authentication.getCredentials().toString();

        if (authenticationService.authenticate(login, senha)) {
            return new UsernamePasswordAuthenticationToken(login, senha, new ArrayList<>());
        }
        throw new BadCredentialsException("Credenciais inválidas.");
    }

    @Override
    public boolean supports(Class<?> authentication) {
        return UsernamePasswordAuthenticationToken.class.isAssignableFrom(authentication);
    }
}

Passo 8: Implementar as Páginas de Login e Acesso Restrito
Crie páginas para a autenticação do usuário e páginas de acesso restrito. Por exemplo, crie um controlador para exibir a página de login e a página após o login com token:

@Controller
public class AuthController {
    @GetMapping("/login")
    public String loginPage() {
        return "login";
    }

    @GetMapping("/home")
    public String homePage() {
        return "home";
    }
}

Lembre-se de criar as respectivas páginas HTML para "login" e "home".

Passo 9: Implementar as Rotas Protegidas
Para proteger as páginas de acesso restrito, você pode configurar o Spring Security para exigir autenticação para determinadas rotas. Você pode fazer isso no método configure(HttpSecurity http) da classe SecurityConfig. Por exemplo:

@Override
protected void configure(HttpSecurity http) throws Exception {
    http.csrf().disable()
        .authorizeRequests()
            .antMatchers("/login").permitAll()
            .antMatchers("/home").authenticated()
            .anyRequest().authenticated()
        .and()
        .formLogin().loginPage("/login");
}

Dessa forma, somente os usuários autenticados (com token válido) poderão acessar a rota /home e outras rotas não configuradas explicitamente.

Passo 10: Implementar o Controller para o Login
Crie um controlador para processar a requisição de login e realizar a autenticação:

@Controller
public class AuthController {
    @Autowired
    private AuthenticationService authenticationService;

    @PostMapping("/login")
    public String login(@RequestParam String login, @RequestParam String senha) {
        if (authenticationService.authenticate(login, senha)) {
            return "redirect:/home";
        } else {
            return "login";
        }
    }
}

Oque estudar {rust}

Davi — Thu, 27 Jul 2023 13:42:31 +0000

Para aprender Rust, você pode seguir uma abordagem passo a passo para adquirir os conhecimentos necessários. Aqui estão as principais áreas que você pode estudar para se tornar proficiente em Rust:

Sintaxe e estrutura da linguagem: Comece com o básico, aprendendo a sintaxe e a estrutura da linguagem Rust. Entenda como declarar variáveis, usar tipos de dados, estruturas de controle (como loops e condicionais) e funções.
Propriedades da linguagem: Aprenda os principais conceitos que tornam Rust único, como propriedade de propriedade, empréstimos, mutabilidade e o sistema de tipos de Rust. Esses conceitos são fundamentais para escrever código seguro e livre de erros.
Gerenciamento de memória: Estude como o Rust gerencia a memória de forma segura, evitando problemas comuns, como vazamentos de memória e referências inválidas. Entenda os conceitos de empréstimos e regras de propriedade.
Tipos de dados avançados: Aprofunde-se nos tipos de dados mais avançados, como enums, structs, tuplas e arrays. Aprenda a usar esses tipos para criar estruturas de dados complexas e eficientes.
Programação concorrente e assíncrona: Rust possui um poderoso suporte para programação concorrente e assíncrona. Estude os conceitos de threads, paralelismo e programação assíncrona usando as primitivas fornecidas pelo Rust.
Gerenciamento de pacotes e projeto com Cargo: Familiarize-se com o gerenciador de pacotes do Rust, chamado Cargo. Aprenda a criar, gerenciar e compartilhar projetos em Rust usando o Cargo.
Bibliotecas e frameworks: Explore as bibliotecas e frameworks disponíveis para Rust que podem facilitar o desenvolvimento de diferentes tipos de aplicativos, como web, jogos, sistemas, entre outros.
Exemplos práticos: Escreva projetos pequenos e exemplos práticos para aplicar os conceitos aprendidos. Isso ajudará a solidificar seu conhecimento e a ganhar experiência na escrita de código em Rust.
Leitura e documentação oficial: Consulte a documentação oficial do Rust (https://doc.rust-lang.org/) e outros recursos recomendados pela comunidade. Isso lhe dará informações detalhadas e precisas sobre a linguagem.
Participação na comunidade: Participe de fóruns, grupos e comunidades de desenvolvedores em Rust. Compartilhe seu aprendizado, faça perguntas e aprenda com outras pessoas. A comunidade Rust é amigável e colaborativa.

Lembre-se de que o aprendizado de uma nova linguagem de programação requer prática e dedicação. À medida que você adquire mais experiência em Rust, continue explorando projetos e desafios mais complexos para aprimorar suas habilidades. Aproveite a jornada de aprendizado e divirta-se programando em Rust!

Ponteiros 🤮

Davi — Mon, 24 Jul 2023 17:41:59 +0000

Em C, os ponteiros são uma das características mais poderosas e complexas da linguagem. Eles permitem manipular diretamente a memória, apontando para endereços de outras variáveis e objetos. Os ponteiros são amplamente usados em C para lidar com estruturas de dados, alocar memória dinamicamente e otimizar a performance em certas situações. Aqui está uma explicação básica sobre ponteiros:

Declaração de ponteiros:

   tipo *nome_ponteiro;

Exemplo:

   int *ponteiro_int; // Declara um ponteiro para um inteiro
   char *ponteiro_char; // Declara um ponteiro para um caractere
   float *ponteiro_float; // Declara um ponteiro para um número de ponto flutuante

Atribuição de endereço a um ponteiro:

   ponteiro = &variavel;

Exemplo:

   int numero = 42;
   int *ponteiro_numero;
   ponteiro_numero = &numero; // O ponteiro agora aponta para o endereço de memória da variável 'numero'

Acesso ao valor apontado pelo ponteiro:

   *ponteiro;

Exemplo:

   int numero = 42;
   int *ponteiro_numero;
   ponteiro_numero = &numero;
   printf("%d\n", *ponteiro_numero); // Imprime o valor armazenado na variável 'numero' (42)

Ponteiros e alocação de memória dinâmica: Em C, é possível alocar memória dinamicamente usando funções como malloc e calloc. A alocação de memória dinâmica permite criar arrays de tamanho variável e estruturas de dados complexas. No entanto, é responsabilidade do programador liberar a memória alocada usando a função free para evitar vazamentos de memória.

Exemplo:

   int *ponteiro_array;
   int tamanho = 5;
   ponteiro_array = (int *)malloc(tamanho * sizeof(int)); // Aloca memória para um array de inteiros com tamanho 5

   // Use o array dinamicamente alocado

   free(ponteiro_array); // Libera a memória alocada quando não for mais necessária

Ponteiros podem ser bastante poderosos e úteis, mas também podem levar a erros complexos se usados incorretamente. É importante entender bem como os ponteiros funcionam e sempre ter cuidado ao manipular memória diretamente. Além disso, o uso de ponteiros é mais comum em C do que em outras linguagens de programação, pois outras linguagens de mais alto nível tendem a abstrair o gerenciamento de memória para facilitar o desenvolvimento e evitar erros de programação relacionados à memória.

DEV Community: Davi

Comandos Essenciais do Linux (Nv-2)

Se tornando um mago

1. sudo apt install e suas variantes

O que faz?

Exemplo

Explicação técnica

O que acontece no sistema?

Variações úteis

2. tar - Compactação e descompactação de arquivos

O que faz?

Exemplo

Explicação técnica

Variações úteis

O que acontece no sistema?

3. chmod - Controle de permissões de arquivos e diretórios

O que faz?

Exemplo

Explicação técnica

Variações úteis

O que acontece no sistema?

4. grep - Pesquisa avançada em arquivos e saídas de comandos

O que faz?

Exemplo

Explicação técnica

Variações úteis

O que acontece no sistema?

6. rsync - Sincronização de Arquivos e Diretórios

O que faz?

Exemplo

Explicação técnica

Variações úteis

O que acontece no sistema?

Comandos Essenciais do Linux (Nv-1)

Torne-se um Mago do Terminal

O Que É o Terminal?

1. Navegação no Sistema de Arquivos

Comandos:

2. Manipulação de Arquivos e Diretórios

Comandos:

3. Visualização de Arquivos

Comandos:

4. Buscas e Filtros

Comandos:

5. Gerenciamento de Processos

Comandos:

6. Comandos Gerais

Comandos:

Quer aprender PHP?

Vamos ver banco de dados pra finalizar

Agora é só praticar

Quer aprender PHP?

Vamos ver banco de dados pra finalizar

Agora é só praticar

Introdução a APIS s

Guia Completo sobre APIs

O que é uma API?

Tipos de APIs

Autenticação e Autorização

Boas Práticas

Conclusão

Forum Import rev MySQL

Oque estudar {rust}

Ponteiros 🤮

1. `sudo apt install` e suas variantes

2. `tar` - Compactação e descompactação de arquivos

3. `chmod` - Controle de permissões de arquivos e diretórios

4. `grep` - Pesquisa avançada em arquivos e saídas de comandos

6. `rsync` - Sincronização de Arquivos e Diretórios