Lista de Scripts em Shell Bash

Criando uma forma de buscar sites.

██████████████████████████████████████████████████████████████████

Criando nomes de sites aleatórios.
A função principal do script é gerar nomes ordenados lexicograficamente, seguindo a ordem alfabética,
similar à ordenação em dicionários, que considera a ordem das letras. A taxa de geração de linhas varia dependendo da capacidade do seu computador.
A saída deste script será exportada para o arquivo de texto localizado em:
$HOME/criacao_de_textos.txt
Para receber feedback durante a execução do script, vou adicionar um monitoramento que imprimirá a última linha deste arquivo de texto a cada 10 segundos direto na sua tela de terminal.
Se sua intenção é acompanhar o progresso em tempo real de execução, abra outra aba de terminal e execute o comando a seguir:
tail -f $HOME/criacao_de_textos.txt
Nesta versão do script, os provedores não serão adicionados automaticamente no final dos nomes gerados. Isso lhe dará a liberdade de adicionar os provedores desejados posteriormente. Para automatizar a adição do provedor aos nomes, utilize o seguinte comando em seu arquivo de texto:
sed -i 's/$/.com/' "$HOME/criacao_de_textos.txt"

script:

Versão minimalista do mesmo script:

SAÍDA DO SCRIPT

output:

██████████████████████████████████████████████████████████████████

Validando a disponibilidade dos sites.
Este script é útil para encontrar e registrar URLs que contenham informações relevantes com base em palavras-chave especificadas,
permitindo que você analise facilmente os sites que atendem aos seus critérios de pesquisa.
Realiza as seguintes operações:
Lê uma lista de URLs de um arquivo de texto.
Verifica a disponibilidade do site.
Realiza o download do conteúdo do site
Analisa o conteúdo baixado em busca de palavras-chave pré-definidas.
Registra as URLs que passaram no teste em um arquivo de saída.
Aqui estão alguns detalhes adicionais:
O script utiliza o comando curl -L para verificar a disponibilidade dos sites, seguindo redirecionamentos.
Se um site estiver acessível, ele baixa o texto do cabeçalho HTTP usando o curl e o salva em um arquivo temporário, que é constantemente sobrescrito.
Sobre o conteúdo baixado, o parâmetro --head solicita apenas o HEAD ao servidor, em vez de baixar o conteúdo completo da página.
O conteúdo do site é examinado em busca de qualquer uma das palavras-chave pré-definidas.
Se uma palavra-chave for encontrada no conteúdo, a URL é registrada no arquivo de saída chamado ok.txt.
Modificações recentes:
1) Adicionei ao comando curl a opção --limit-rate 50k, que limita a taxa de download das URLs para 50 kbps.
2) Também incluí o comando sed -i '1d', que assegura a remoção de todas as linhas do arquivo de entrada após terem sido analisadas.
3) Configurei o comando curl com a opção --max-time 180 (3 minutos), que define o tempo máximo permitido para a conclusão de um download.
Dicas extras:
1) Você pode ajustar a prioridade dos processos gerados pelo seu script usando o comando nice -n -19.
Esse comando requer privilégios de root, nesse caso nem mesmo o uso do sudo não seria ideal para um script em execução prolongada, uma vez que o sudo exige a renovação da senha. Se escolher usar o comando nice, precisará de privilégios de root, faça login como root ou abra uma nova aba do terminal como root usando o comando
su -c comando_aqui. O comando nice não resolve problemas como escassez da banda larga.
Em média, cada script executando o comando curl consome aproximadamente 8 megabytes de memória.
ps aux | grep curl
ps aux | grep "nome_aqui.sh"
ps aux | grep "nome_aqui.sh" | awk '{print $6/1024 " MB"}'

script:

Abrindo múltiplos scripts de uma vez:

Crie um lançador para seus scripts:

██████████████████████████████████████████████████████████████████

Finalizado, basta navegar pelos sites descobertos.

Para testar rapidamente uma lista de sites sem a necessidade de copiar e colar cada URL manualmente no navegador.
Usaremos um comando simples no terminal para automatizar esse processo, economizando tempo e esforço.
Vou usar o google-chrome que abrirá todas as URLs em abas separadas em modo de navegação anônima.
Certifique-se de que o Google Chrome esteja instalado no seu sistema, ou use outro navegador.

como usar outros navegadores:

Este é o comando no qual você inserirá suas URLs:
urls=(URL1
URL2
URL3
URL4
URL5); comando="google-chrome-stable --incognito"; for url in "${urls[@]}"; do comando="$comando --new-tab $url"; done; $comando

opcional > mesmo comando, mas de forma manual:

finalizamos!

Funções extras:
Este é um pequeno utilitário em Bash que permite abrir o navegador com o tema da sua pesquisa previamente definido.
Inserindo um texto na linha de comando que servirá como base para uma pesquisa no Google Imagens.

+informações:

██████████████████████████████████████████████████████████████████

reservado

A finalidade deste script é ler em voz alta qualquer texto fornecido pelo usuário, etapas:

Solicita ao usuário que insira um texto, que é então salva em um arquivo temporário chamado temporario.txt no diretório /tmp.
Inserir o texto pelo cat, necessita que você pressione Ctrl+D duas vezes seguidas, para indicar que você quer finalizar a criação desses dois arquivos de texto.
Utiliza o comando tr para eliminar linhas em branco, e salva o resultado em um novo arquivo de texto temporário texto_processado.txt.
Executa o comando RHVoice-test para transformar esse texto em um arquivo de áudio no formato WAV.
Por fim, o arquivo de áudio é reproduzido usando o programa mpv, e o usuário tem a opção de repetir a reprodução.

Para que o script funcione corretamente, é necessário ter os seguintes pacotes instalados:
sudo pacman -S mpv rhvoice rhvoice-language-brazilian-portuguese rhvoice-voice-leticia-f123

Código:

#!/bin/bash

# Função para processar o texto
processar_texto() {
    # Solicita ao usuário o texto a ser transformado e salva em um arquivo temporário em /tmp
    cat > /tmp/temporario.txt

    if [ -s /tmp/temporario.txt ]; then
        # Aplica o comando tr para transformar o texto em uma única linha e salva em um novo arquivo temporário
        tr '\n' ' ' < /tmp/temporario.txt > /tmp/texto_processado.txt

        # Executa o comando RHVoice-test para gerar o áudio a partir do texto processado
        RHVoice-test -q high -r 80 -o /tmp/voice.wav < /tmp/texto_processado.txt

        # Reproduz o arquivo de áudio com mpv e dá a opção de loop
        while true; do
            mpv /tmp/voice.wav
            read -p "Deseja reproduzir o áudio novamente? (s/n): " choice
            if [ "$choice" != "s" ]; then
                break
            fi
        done

        # Isso marca o início de um loop das funções do script
        echo "Insira um novo texto."
    else
        echo "Nenhum texto foi inserido."
    fi

    # Chama a função novamente para processar um novo texto
    processar_texto
}

# Chama a função para processar o texto pela primeira vez
processar_texto


Para desabilitar e habilitar o JavaScript usando a interface gráfica do navegador Firefox:

Desabilitar JavaScript:
Na barra de endereço, digite about:config e pressione Enter.
Na barra de pesquisa na parte superior, digite javascript.enabled. Isso filtrará as opções relevantes.
Clique duas vezes na opção javascript.enabled para alterar seu valor de true para false. Isso desabilitará o JavaScript.

Para desabilitar e habilitar o JavaScript no Firefox e navegadores derivados, como o Tor, usando o terminal:
Para desabilitar o JavaScript em todo o navegador, execute o seguinte comando no terminal:

Desabilitar
find $HOME/.mozilla/firefox/ -name prefs.js -exec sed -i '$a\user_pref("javascript.enabled", false);' {} \;

Habilitar
find $HOME/.mozilla/firefox/ -name prefs.js -exec sed -i 's/"javascript.enabled", false/"javascript.enabled", true/' {} \;

Este script em Bash realiza duas contagens simultaneamente: uma contagem regressiva e uma contagem crescente.
Ele monitora quantas vezes a tecla Enter é pressionada.
A contagem regressiva começa em 198, e a contagem crescente em 1, efetue ajustes conforme necessário.
Ele funciona como um registro simples de atividades, registrando quantas vezes a tecla Enter é acionada.
Pode ser útil como uma checklist para acompanhar o progresso em tarefas paralelas, mantendo um registro do estágio.

Você pode aprimorar o script incluindo o comando time read para cronometrar o intervalo de tempo decorrido entre uma tarefa e outra,
adicionando uma funcionalidade de medição do tempo decorrido.

Código:

#!/bin/bash

count_regressiva=198
count_crescente=1

while [ $count_regressiva -ge 1 ]; do
    clear
    echo "Contagem regressiva: $count_regressiva"
    echo "Contagem crescente: $count_crescente"
    read -p "Pressione Enter para continuar..." -s -n 1 key
    if [[ $key == "" ]]; then
        ((count_regressiva--))
        ((count_crescente++))
    fi
done

echo "Contagem regressiva concluída!"

Usando o comando time read:

Para executar scripts em Python, você precisa editar seu código em qualquer editor de texto, salve com a extensão .py exemplo: meu_script.py
Em seguida, abra um terminal, execute-o digitando python meu_script.py
Lembre-se de ter o Python instalado.
sudo pacman -S python

você pode querer instalar alguns pacotes adicionais relacionados à linguagem Python ou a ambientes de desenvolvimento Python, dependendo das suas necessidades.
Aqui estão alguns pacotes comuns que você pode considerar instalar em seu Python:

O pip é o gerenciador de pacotes Python que facilita a instalação de bibliotecas e pacotes Python. Você pode instalá-lo com:
sudo pacman -S python-pip

O Virtualenv é útil para criar ambientes Python isolados para diferentes projetos. Isso ajuda a evitar conflitos de dependências entre projetos:
sudo pacman -S python-virtualenv

IDLE é um ambiente de desenvolvimento integrado Python simples que você pode usar para escrever e testar código Python:
sudo pacman -S idle

Se você estiver interessado em ciência de dados ou aprendizado de máquina, o Jupyter Notebook é uma ferramenta poderosa para criar e compartilhar documentos interativos com código Python:
sudo pacman -S jupyter-notebook

O PyInstaller é usado para criar executáveis independentes a partir de scripts Python. Isso significa que você pode transformar um script Python em um arquivo executável que pode ser executado em sistemas operacionais que não possuem o Python instalado. Isso é útil quando você deseja distribuir seu aplicativo Python para usuários que não são desenvolvedores Python e não desejam ou não sabem como instalar o Python e as dependências do seu aplicativo.
rua install pyinstaller-git

passo a passo
Depois de editar seu código em qualquer editor de texto, salve com a extensão .py exemplo: meu_script.py
Em seguida, abra um terminal, execute a construção do executável pyinstaller --onefile meu_script.py
O PyInstaller irá criar uma pasta chamada dist na sua home com esse executável e todos os arquivos necessários para executa-lo.
Ele é muito semelhante ao pacote python-setuptools que também cria pacotes Python em diferentes formatos, como sdist (source distribution), bdist (binary distribution), ou wheels.

Instalar pacotes Phyton
Se você deseja instalar um pacote de forma isolada, você pode usar o pipx, que é uma ferramenta que instala pacotes Python em ambientes virtuais gerenciados automaticamente, ou seja, cada programa é isolado em seu próprio ambiente virtual.
Certifique-se de ter o python-pipx instalado:
sudo pacman -S python-pipx
Vamos adicionar a pasta bin criada pelo pipx ao sistema:
export PATH=$PATH:/home/adr1/.local/bin
veja que agora está visível o nome do diretório contendo os binários, pois adicionamos ao PATH:
echo $PATH
Você pode querer adicionar permanentemente o diretório /home/adr1/.local/bin ao seu PATH, usando o arquivo ~/.bashrc
nano ~/.bashrc
Vá para o final do arquivo e adicione a seguinte linha:
export PATH=$PATH:/home/adr1/.local/bin
Salve as alterações e feche o editor de texto.
Atualize o seu shell para que as alterações entrem em vigor sem reiniciar o terminal.
source ~/.bashrc
Agora tudo pronto para instalar um pacote Phyton
pipx install NOME_AQUI
se precisar reinstalar:
pipx upgrade NOME_AQUI
Desinstalar:
pipx uninstall NOME_AQUI
Para executar seus programas instalados, basta seguir o guia de uso da ferramenta que foi instalada, sem necessidade de nenhum complemento extra.

Veja suas instalações feitas com pipx:
pipx list

Para Estabelecer uma Comunicação entre Aplicações Python: Use os Links Simbólicos
Em ambientes Python onde diversas aplicações são instaladas por diferentes métodos, como o Pacman ou pipx.
Se houver a necessidade de estabelecer uma comunicação entre elas, você precisará criar um link manualmente.
Tomemos como exemplo a situação em que uma aplicação Python, instalada através do Pacman, precisa interagir com outras aplicações instaladas por meio do pipx.
Você precisa identificar todos os diretórios de instalação das aplicações(módulos) Python que precisam interagir, vamos criar um link simbólico de exemplo:
sudo ln -s alvo link
sudo ln -s /usr/lib/python3.11/site-packages/pysrt /usr/lib/python3.11/site-packages/srt
O comando cria um link simbólico chamado srt no diretório /usr/lib/python3.11/site-packages/.
Esse link simbólico aponta para o diretório real onde o pacote pysrt está instalado, que é /usr/lib/python3.11/site-packages/pysrt.
Certamente você tem algum pacote Python instalado via Pacman, veja eles com esse comando:
pacman -Qq | grep python
Para descobrir o caminho de algum pacote Python, você pode usar esse comando aqui:
python -c "import pysrt; print(pysrt.__file__)"
O comando chama o interpretador Python que é utilizado para imprimir o caminho do arquivo __init__.py do módulo pysrt.
Com isso você obtêm o caminho completo dessa aplicação Python:
/usr/lib/python3.11/site-packages/pysrt/__init__.py

BIBLIOTECAS
Vou falar de uma biblioteca chamada: Beautiful Soup, usada para análise e extração de dados em documentos HTML e XML.
Ele é usado para web scraping e parsing de páginas da web.
Ele cria uma árvore de análise a partir do documento, que você pode percorrer usando métodos e seletores simples.
sudo pacman -S python-beautifulsoup4
Um exemplo de uso, o Beautiful Soup vai analisar o HTML da página encontrar todos os elementos (links). Portanto, vai extrair todas as URLs existentes no site.

Código:

import requests
from bs4 import BeautifulSoup

# Faz uma requisição HTTP para uma página da web
url = 'https://flyer.forumeiro.com/t351-instalacao-arch-linux-bios-legacy-triple-boot-xfce-home-games'
response = requests.get(url)

# Cria um objeto BeautifulSoup para analisar o conteúdo HTML da página
soup = BeautifulSoup(response.text, 'html.parser')

# Exemplo: Encontrar e imprimir todos os links da página
links = soup.find_all('a')
for link in links:
    print(link.get('href'))

Se um site oferecer uma API pública para acessar seus dados, é preferível usá-la em vez de fazer scraping.
As APIs são projetadas para fornecer um total acesso aos dados de um site de maneira eficiente.
Ter um bom conhecimento de HTML e CSS facilitará muito a identificação e extração de elementos de uma página.

Python no Backend, você quer trabalhar no exterior? Aqui está um roadmap de estudo em ordem de importância para você:
   Inglês (Essencial)
   Estruturas de Dados e Algoritmos
   Programação Concorrente e Paralela
   Flask ou Django (Frameworks Python)
   Celery ou Apache Kafka para Processamento de Filas
   Git, Docker, Kubernetes
   AWS, Azure, ou GCP (Plataformas em Nuvem)
   Design Patterns (ou GoF- Gang of Four ) são Padrões de Projeto
   Architectural Patterns (Padrões Arquiteturais)
   Cloud Patterns (Padrões de Nuvem) e Microservices Patterns (Padrões de Microsserviços), para escaláveis, resilientes e distribuídos na nuvem.

Este script em Python utiliza a biblioteca gtts (Google Text-to-Speech)
é um biblioteca Python que interage com a API Text-to-Speech do Google,
permitindo a conversão de texto em fala e salvar o resultado em um arquivo de áudio MP3.

Primeiramente vamos instalar a biblioteca usando o pipx.
pipx install gtts

Com a biblioteca gtts instalada no ambiente virtual criado pelo pipx.  Ela oferece suporte a vários idiomas e oferece flexibilidade na personalização da saída de áudio.
mais informações

Altere o caminho para sua home, onde contém sua biblioteca gtts:

Código:

import sys
sys.path.append('/home/flyer/.local/pipx/venvs/gtts/lib/python3.11/site-packages')

from gtts import gTTS

texto = "No coração desse reino, erguia-se um castelo de pedras cinzentas, suas torres apontando para o céu como guardiões do passado. Dentro de seus muros, existia uma biblioteca secreta, onde volumes antigos sussurravam contos esquecidos e segredos perdidos."
lingua= "pt"

tts = gTTS(texto, lang=lingua)
tts.save("audiopy.mp3")

Execute seu script
python '/home/flyer/scripts/audioempy.py'

O arquivo de áudio será criado em sua home.
██████████████████████████████████████████████████████████████████████████████████████████████████████████████████
Incrementando seu script.
Este script desempenha a mesma função do script anterior, porém agora é um script Bash que invoca o interpretador Python junto com sua biblioteca gtts. Novas funcionalidades foram incorporadas para proporcionar uma experiência mais interativa:
Solicitação de Texto ao Usuário:
   Agora, o script interage diretamente com o usuário, solicitando o texto desejado e armazenando-o em um arquivo temporário em /tmp/temporario.txt.
Tratamento do Texto:
   O texto fornecido pelo usuário passa por um tratamento para remover quebras de linha, resultando em um arquivo /tmp/texto_processado.txt contendo uma única linha.
Configuração do Ambiente Python:
   São realizadas configurações básicas no ambiente Python para garantir o correto funcionamento da biblioteca gtts.
Criação do Áudio e Reprodução Automática:
   O script gera um arquivo de áudio, audiopy.mp3, na sua pasta pessoal e inicia automaticamente a reprodução utilizando o player mpv.

Código:

#!/bin/bash

# Caminho da biblioteca gtts
GTTS_PATH="$HOME/.local/pipx/venvs/gtts/lib/python3.11/site-packages"

# Função para processar o texto
processar_texto() {
    echo "Digite o texto a ser transformado em fala (Ctrl+D para finalizar):"
    
    # Solicita ao usuário o texto e salva em um arquivo temporário
    cat > /tmp/temporario.txt

    if [ -s /tmp/temporario.txt ]; then
        # Aplica o comando tr para transformar o texto em uma única linha
        tr '\n' ' ' < /tmp/temporario.txt > /tmp/texto_processado.txt

        # Adiciona o caminho da biblioteca gtts ao PYTHONPATH
        export PYTHONPATH="$GTTS_PATH:$PYTHONPATH"

        while true; do
            # Executa o script Python para processar o texto do arquivo temporário
            python - <<END
from gtts import gTTS

# Lê o texto processado do arquivo temporário
with open("/tmp/texto_processado.txt", "r") as f:
    texto = f.read()

# Configuração do idioma
lingua = "pt"

# Cria o objeto gTTS com o texto processado
tts = gTTS(texto, lang=lingua)
tts.save("audiopy.mp3")
END

            # Reproduz o arquivo de áudio com mpv e dá a opção de loop
            mpv audiopy.mp3
            read -p "Deseja criar um novo arquivo audiopy.mp3? (s/n): " choice
            [ "$choice" != "s" ] && break

            # Solicita ao usuário um novo texto e repete o processo
            echo "Digite o novo texto (Ctrl+D para finalizar):"
            cat > /tmp/temporario.txt
            tr '\n' ' ' < /tmp/temporario.txt > /tmp/texto_processado.txt
        done
    else
        echo "Nenhum texto foi inserido."
    fi
}

# Chama a função para processar o texto
processar_texto


Dicas de funções genéricas e reutilizáveis que podem ser utilizadas em seus scripts.
Exemplos:

Essa função pode ser usada em qualquer script para verificar se o usuário digitou exit e, se sim, sair do script.
Verifica se o usuário deseja sair do script.

Código:

function verificar_saida() {
    if [ "$1" == "exit" ]; then
        echo "Saindo do script."
        exit 0
    fi
}

Nesta função, você fornece a entrada, o critério (expressão regular) e a mensagem de erro personalizada. Se a entrada não atender ao critério, a mensagem de erro será exibida.
Função para Validar Entrada:

Código:

function validar_entrada() {
    local entrada="$1"
    local criterio="$2"

    if [[ ! $entrada =~ $criterio ]]; then
        echo "Entrada inválida. $3"
        return 1
    fi
}

Esta função atua como um separador visual entre duas saídas, marcando distintamente o término de uma e o início da outra.
Quando colocado no final do seu script ele sinalizará com 1000 caracteres @ que esse é o ponto final da saída.

Código:

printf '%.0s@' {1..1000}; echo

Se você possui um script com várias funções e deseja ignorar determinadas linhas sem excluí-las,
simplesmente insira esta condição no cabeçalho do seu script. Para ignorar as linhas desejadas, basta adicionar a palavra --skip ao final delas.
exemplo: Exec=xfce4-terminal --tab --title=Grim -e '/bin/bash /home/adr2/grep_script_grim.sh' --skip
As linhas subsequentes, se houverem, não são afetadas por essa condição e serão executadas normalmente, semelhando ao uso do #
se você colocar um # no início da linha, a linha será considerada um comentário e não será executada, esse é o comportamento padrão dentro do shell.

Código:

# Verifica se o comando do script deve ser ignorado
if [ "$1" = "--skip" ]; then
    echo "O script foi ignorado."
    exit 0
fi

Esse é um script em bash é feito para monitora o uso de memória RAM e envia um alerta se a quantidade de memória em uso ultrapassar 7GB.
o script continuará rodando em um loop infinito, verificando o uso de memória RAM a cada 10 segundos.
Estamos usando o comando notify-send que faz parte do pacote libnotify do Arch Linux, que é responsável por enviar notificações para o ambiente de desktop.
Xfce é um ambiente de desktop que possui seu próprio gerenciador de notificações chamado xfce4-notifyd, que é independente do notify-send.
Portanto para poder usar esse script instale o libnotify.

Código:

#!/bin/bash

while true; do
    # Obtém a quantidade de memória RAM usada em gigabytes
    mem_used=$(free -g | awk '/Mem/ {print $3}')

    # Verifica se a quantidade de memória usada é igual a 7GB
    if [[ "$mem_used" -eq 7 ]]; then
        # Envia um alerta usando o notify-send
        /usr/bin/notify-send "Alerta de Memória RAM" "O uso de memória RAM atingiu 7GB"
    fi

    # Espere 10 segundos antes de verificar novamente
    sleep 10
done

Este outro script monitora continuamente o consumo de memória RAM.
Ele mantém um registro da quantidade atual de memória RAM utilizada e compara-a com a quantidade anteriormente registrada.
Se houver uma alteração no consumo de memória, o script emite uma notificação ao usuário,
indicando se o consumo aumentou ou diminuiu e para qual valor em gigabytes.
A verificação do consumo de memória acontece a cada minuto.
Para poder usar esse script instale o libnotify.

Código:

#!/bin/bash

# Obtém a quantidade inicial de memória RAM usada em gigabytes
mem_used=$(free -g | awk '/Mem/ {print $3}')
previous_mem=$mem_used

while true; do
    # Obtém a quantidade de memória RAM usada em gigabytes
    mem_used=$(free -g | awk '/Mem/ {print $3}')

    # Verifica se houve uma alteração na quantidade de memória usada
    if [[ "$mem_used" -ne "$previous_mem" ]]; then
        # Verifica se a memória aumentou ou diminuiu
        if [[ "$mem_used" -gt "$previous_mem" ]]; then
            # Envia um alerta usando o notify-send indicando que a memória subiu
            /usr/bin/notify-send "Consumo de Memória RAM" "Subiu para $mem_used GB"
        else
            # Envia um alerta usando o notify-send indicando que a memória reduziu
            /usr/bin/notify-send "Consumo de Memória RAM" "Reduziu para $mem_used GB"
        fi
        previous_mem=$mem_used
    fi

    # Espere 1 segundos antes de verificar novamente
    sleep 1
done


Este script também monitora continuadamente a utilização de memória RAM do sistema.
Ele verifica periodicamente a quantidade de memória RAM usada e, se a quantidade de memória RAM usada atingir exatamente 7GB,
o script identifica e encerra o processo que está consumindo mais memória, garantindo que a utilização de memória não exceda esse limite especificado.
O script continua a monitorar a memória RAM em intervalos de 10 segundos, repetindo o processo de verificação e encerramento do processo conforme necessário.

Código:

#!/bin/bash

while true; do
    # Obtém a quantidade de memória RAM usada em gigabytes
    mem_used=$(free -g | awk '/Mem/ {print $3}')

    # Verifica se a quantidade de memória usada é igual a 7GB
    if [[ "$mem_used" -eq 7 ]]; then
        # Encontra o PID do processo que mais consome memória
        pid_to_kill=$(top -o %MEM -n 1 -b | grep -E '^ *[0-9]+' | awk '{print $1}' | head -n 1)
        
        # Encerra o processo que mais consome memória
        kill "$pid_to_kill"
    fi

    # Espere 10 segundos antes de verificar novamente
    sleep 10
done


Para executar qualquer script assim que o computador iniciar.
Abra o terminal e execute o comando para editar o cron, (o agendador de tarefas do linux)
export VISUAL=nano; crontab -e

Adicione a seguinte linha no arquivo do cron:
@reboot '/home/flyer/scripts/memoria.sh' >/dev/null 2>&1
Usando /dev/null 2>&1 o script será executado silenciosamente sem imprimir qualquer saída no terminal ou em arquivos de log.
Na página 5 desse fórum tem uma explicação detalhada de como usar o cronie no Arch Linux.

Se você procura uma maneira de apagar arquivos de forma definitiva, tornando a recuperação de dados impossível, o comando shred é a solução.
Ele é utilizado para eliminar permanentemente arquivos ou dispositivos de armazenamento, como discos rígidos ou partições, tornando os dados irreconhecíveis e inacessíveis.

Este script executa esse comando
find /home/usuário/diretório -type f -exec shred -v -n 5 -z -u {} \;
usa find para localizar arquivos no diretório descrito.
Em seguida, ele executa shred em cada arquivo encontrado, sobrescrevendo-o cinco vezes com dados aleatórios.

Esse script facilita a eliminação de arquivos, permite ao usuário fornecer caminhos de arquivos ou diretórios para exclusão.
Após receber o caminho, ele executa o comando shred, que sobrescreve os arquivos encontrados com dados aleatórios, tornando a recuperação dos dados praticamente impossível.
O script remove as aspas dos caminhos, verifica se os caminhos fornecidos são válidos e exibe mensagens de erro quando necessário.
Ele continuará a solicitar novos caminhos até ser interrompido pelo usuário.

Código:

#!/bin/bash

while true; do
    # Solicitar ao usuário o arquivo ou diretório a ser fornecido
    echo "Arraste o arquivo ou diretório para cá e pressione Enter:"
    read -r caminho

    # Remover as aspas do caminho, se presentes
    caminho=$(echo "$caminho" | tr -d "'\"")

    # Verificar se o caminho existe
    if [ ! -e "$caminho" ]; then
        echo "Caminho não encontrado!"
        continue
    fi

    # Executar o comando com o caminho fornecido pelo usuário
    find "$caminho" -depth -type f -exec shred -v -n 5 -z -u {} \;
done


Para limpar um disco completo!
Esse comando irá sobrescrever todo o conteúdo do disco sda, incluindo a tabela de partições.
sobrescreve cinco vezes todos os dados no primeiro disco rígido do sistema /dev/sda
shred -v -n 5 -z -u /dev/sda

Sempre que você pressionar a tecla Enter, o script irá enviar o texto especificado "DIGITE UM TEXTO AQUI" para a área de transferência.

Código:

#!/bin/bash

# Função para enviar o texto para a área de transferência
send_to_clipboard() {
    echo "DIGITE UM TEXTO AQUI" | xclip -selection clipboard
}

# Loop infinito
while true; do
    # Espera pela entrada do usuário (pressionar Enter)
    read -p "Pressione Enter para copiar o texto para a área de transferência: "
    
    # Chama a função para enviar o texto para a área de transferência
    send_to_clipboard
done

Este script em bash automatiza a adição de texto antes e depois do conteúdo de cada linha em um arquivo de texto, exibindo o resultado no terminal.
Por exemplo, considere um arquivo de texto com o seguinte conteúdo:
Produto1
Produto2
Produto3
Após ser processado pelo script, será adicionado o prefixo Item antes de cada produto e o sufixo Vendido
Também será adicionado aspas duplas no inicio de cada linha, e outra aspas dupla depois do texto Item para fechar.
resultando em:
"Produto1 Item" Vendido
"Produto2 Item" Vendido
"Produto3 Item" Vendido
Este script solicita ao usuário o caminho do arquivo.
Caso o usuário forneça o caminho do arquivo entre aspas:
'/home/flyer/Meu_Script'
O script removerá essas aspas para garantir que o caminho seja interpretado corretamente pelo shell.
Se o arquivo existir, o script processa cada linha para resolver problemas de formatação, como a remoção de espaços excessivos do início de cada linha.

Código:

#!/bin/bash

# Solicita ao usuário o caminho do arquivo
read -p "insira o caminho do arquivo: " caminho

# Remove as aspas do caminho do arquivo, se houver
caminho=$(sed -e 's/^'\''//;s/'\''$//' <<< "$caminho")

# Verifica se o arquivo existe
if [ -f "$caminho" ]; then
    # Loop para ler cada linha do arquivo
    while IFS= read -r linha; do
        # Remove espaços excessivos (tabs) no início de cada linha
        linha=$(echo "$linha" | sed 's/^[ \t]*//')
        # Adiciona o texto desejado à linha e imprime
        echo "\"$linha Item\" Vendido"
    done < "$caminho"
else
    echo "O arquivo '$caminho' não foi encontrado."
fi