INSTALAÇÃO ARCH LINUX - BIOS-Legacy, Triple-Boot, XFCE, /home, games

VOLTAR AO ÍNDICE
 PRÓXIMA PÁGINA

VOLTAR AO TOPO
VOLTAR AO ÍNDICE

VOLTAR AO ÍNDICE
 PRÓXIMA PÁGINA
PERMISSÃO DE ACESSO wiki
Calculadora CHMOD
Existem três tipos de usuários:
DONO = É o usuário que criou ou copiou o arquivo.
GRUPO = É um conjunto de usuários que têm a permissão do dono.
OUTROS = são os usuários que não fazem parte do grupo do dono.
ROOT = Deidade, com poderes para tocar no hardware.
As permissões são aplicadas para cada tipo de usuário.

Tem três formas de visualizar as permissões:

1) Modo de permissão simbólico = drwx
d=directory (d no início sinaliza um diretório)
r=read (leitura)
w=write (escrever)  
x=run (execute) 

2) Modo de permissão octal:〔0〕〔1〕〔2〕〔3〕〔4〕〔5〕〔6〕〔7〕
Cada grupo de três bits em um número binário corresponde a um dígito octal.
   Binário 000 corresponde a Octal 0
   Binário 001 corresponde a Octal 1
   Binário 010 corresponde a Octal 2
   Binário 011 corresponde a Octal 3
   Binário 100 corresponde a Octal 4
   Binário 101 corresponde a Octal 5
   Binário 110 corresponde a Octal 6
   Binário 111 corresponde a Octal 7

3) Modo de permissão binário: 1 ou 0, indicando se a permissão está ligada ou desligada,
Os números binários são agrupados em grupos de três dígitos a partir da direita.

dono grupo outros
rwx__rwx__rwx_OCTAL
000   000   000〔000〕d---------             ➪(não lê, não escreve, não executa)
001   001   001〔111〕d--x--x--x            ➪(executa)
010   010   010〔222〕d-w--w--w-           ➪(escreve)
011   011   011〔333〕d-wx-wx-wx          ➪(escreve, executa) 
100   100   100〔444〕dr--r--r--               ➪(lê)
101   101   101〔555〕dr-xr-xr-x              ➪(lê, executa) 
110   110   110〔666〕drw-rw-rw-            ➪(lê, escreve)
111   111   111〔777〕drwxrwxrwx           ➪(lê, escreve, executa)
-=archive (traço no início sinaliza que é um arquivo)
d=directory (d no início sinaliza um diretório)
l=link (L no início indica que é um link simbólico)
-=Nenhuma permissão de acesso



Vamos testar isso na prática:
Criaremos um script Bash no diretório atual
touch script2000.sh
agora temos um arquivo chamado script2000.sh
Você pode deixar o arquivo vazio, já que estamos apenas testando as permissões,
mas que tal tornarmos as coisas mais divertidas e editarmos o arquivo?
nano script2000.sh
Experimente copiar e colar esse código para seu script2000.sh
Assim, você poderá criar um divertido jogo de adivinhação.
Esse jogo gera um número aleatório entre 0 e 99 e pede ao jogador para adivinhar o número correto.
Ele fornece feedback se o palpite é muito alto ou muito baixo e conta o número de tentativas até que o jogador adivinhe corretamente.

Código:

#!/bin/bash

secret=$((RANDOM % 100))
attempts=0

echo "Bem-vindo ao jogo de adivinhação!"

while true; do
    read -p "Digite um número: " guess
    ((attempts++))

    if [[ $guess -eq $secret ]]; then
        echo "Parabéns! Você acertou em $attempts tentativas."
        break
    elif [[ $guess -lt $secret ]]; then
        echo "Tente um número maior."
    else
        echo "Tente um número menor."
    fi
done

Vamos tornar o script executável
chmod +x script2000.sh
olhe as permissões atuais do arquivo:
ls -l script2000.sh

-rwxr-xr-x ou 755
7 DONO - (lê, escreve, executa)
5 GRUPO - (lê, executa)
5 OUTROS - (lê, executa)
Vamos mudar as permissão desse arquivo:
chmod 631 script2000.sh
olhe as permissões atuais do arquivo:
ls -l script2000.sh

-rw--wx--x  ou 631
6 DONO - (lê, escreve)
3 GRUPO - (escreve, executa)
1 OUTROS - (executa)
vamos testar, abrindo o arquivo
./script2000.sh
Obs: Cada usuário possui um grupo com o mesmo nome, e por padrão, o arquivo é sempre atribuído à propriedade de seu criador.
No entanto, neste caso, removemos o privilégio de execução do proprietário do arquivo script2000.sh, mas ainda temos permissão para ler e escrever nele.



As regras que o dono estabelece para seus arquivos são soberanas, para com outros usuários, ou ele mesmo.
Usuários locais, virtuais, remotos ou de containers(docker.), todos com seus devidos poderes.
É possível determinar regras para o shadow restringir de onde um usuário poderá fazer login.
Essa elevação de privilégios confere aos usuários autorizados a capacidade de executar comandos.
Isso torna o sistema bastante punitivo contra vírus, quando aliada à criptografia de arquivos, essa medida acrescenta uma camada adicional de proteção ao seu sistema.

O Ciclo de Um Vírus no Linux:
Tudo começa quando o arquivo contendo um vírus projetado especificamente para infectar sistema Linux é baixado. Para dar uma mãozinha ao vírus, decidimos executá-lo com privilégios de root. Sua primeira ação é descompactar automaticamente em um diretório, mas logo descobrimos um contratempo: a falta de permissões de gravação nesse diretório impediu o malware de prosseguir. O vírus estava programado para descompactar, mas infelizmente o destino escolhido não permitia gravação, pois era um diretório com permissão chmod 000.

Decidimos dar uma segunda chance ao vírus. Recompilamos o código e o executamos na pasta do usuário, dessa vez garantindo todas as permissões necessárias. Porém, o vírus enfrentou outro obstáculo: ele dependia de uma biblioteca específica que não estava disponível no sistema. Para ajudá-lo novamente, compilamos e criamos um pacote .deb a partir do código-fonte, incluindo todas as dependências necessárias para o vírus funcionar.

Finalmente, o vírus conseguiu ser executado, mas, inesperadamente, gerou logs de erro, resultando em uma falha que causou um despejo de núcleo e travou. Após uma hora de análise minuciosa dos logs, descobrimos que o vírus presumiu incorretamente que estava em um sistema de arquivos ext4, o que gerou problemas, uma vez que, na verdade, estávamos utilizando o sistema de arquivos Btrfs, que o fez operar em modo leitura.

A diversidade do ecossistema Linux exige um esforço sobrenatural de um malware para se espalhar com sucesso.
Infectar todos os sistemas Linux é uma tarefa impossível, e até mesmo atingir toda a base de usuários de uma distribuição seria um desafio hercúleo.
Agora, pense em tentar infectar aquele indivíduo que está usando uma distribuição baseada no Arch, com um kernel do FreeBSD,
em um sistema de arquivos que é um fork, em uma interface gráfica esotérica com algumas variáveis de ambiente modificadas, exemplo:
HOME=/pôneis/seu_nome_de_usuário, um gerenciador de pacotes personalizado e um conjunto de permissões cuidadosamente ajustado.
Isso é apenas o começo das complexidades que um vírus enfrentaria.

Gostaria de lhe apresentar as ferramentas que temporariamente conferem esses poderes a um usuário comum:
sudo
Ao digitar sudo antes de um comando permite que um usuário comum ganhe a capacidade de executar tarefas administrativas
sem a necessidade de efetuar o login na conta de superusuário (root) do sistema, conforme definido pela política de segurança.
Se você tentar executar um comando administrativo usando uma conta de usuário comum, receberá a seguinte mensagem de erro:
erro: você não pode realizar esta operação a menos que seja root.

exemplo:
Vamos fazer um teste; crie um arquivo de texto chamado meuarquivo.txt contendo Fórum Flyer dentro de um diretório do sistema /etc
Espere, você não tem permissão para fazer isso! então, o comando sudo é para essas ocasiões, vamos usa-lo:
sudo echo "Fórum Flyer" > /etc/meuarquivo.txt
(será solicitado uma senha)
O sudo sairá se a senha do usuário não for inserida dentro de um limite de tempo, além de inspirar.
Mas oferecee suporte ao cache de credenciais, permitindo que o usuário execute o sudo novamente dentro de um período.
Ao usar o comando sudo -v, um usuário pode atualizar o tempo das credenciais de cache.
sudo -K remover todas as credenciais cacheadas do usuário.
sudo -N comando Para executar um comando que não atualiza as credenciais cacheadas do usuário.

O comando sudo não está incluído no conjunto de programas essenciais do Arch Linux.
Para permitir que todos os usuários possam utilizá-lo, é necessário que o superusuário (root) o instale.
pacman -S sudo

Lista os privilégios do usuário atual
sudo -l

Para executar um comando como se você fizesse parte de um grupo específico:
sudo -g grupo comando

Você pode iniciar um novo shell como superusuário (root), concedendo a si mesmo todos os privilégios administrativos. Basta utilizar o comando:
sudo -i
A opção -i inicia um novo shell de login com um ambiente semelhante ao de um usuário comum, mas como root.
Configura a variável HOME para o diretório pessoal do superusuário (root).
Além disso, redefine todas as variáveis de ambiente para refletir o ambiente do root.
Mantém um registro de auditoria de quem usou o sudo para iniciar o shell de root.
É a maneira recomendada de obter acesso ao ambiente de root puro.

Outro comando útil é o seguinte:
sudo -Es
Ele mantém a variável de ambiente HOME como o diretório pessoal do usuário original que está executando o comando sudo.
Permitindo que o usuário continue a ter acesso ao seu próprio diretório pessoal proporcionado pela opção -E enquanto executa comandos com privilégios de superusuário.
Essa escolha de design do sudo equilibra a segurança com a conveniência, proporcionando um ambiente seguro e preservando o acesso aos recursos pessoais do usuário.

Também vou mencionar o comando:
sudo su
Este comando também inicia um shell de root.
Algumas variáveis de ambiente do usuário original ainda permanecem ativas no ambiente de root.
Mantém um registro de auditoria das ações realizadas como root.
Uma característica peculiar do comando é a herança de alguns aspectos da sessão anterior, como não substituir o diretório pessoal ~ pelo diretório pessoal do superusuário.
sudo é mais apropriado para executar tarefas administrativas temporárias enquanto você permanece autenticado como um usuário comum,
se o sudo for usado com o su quer dizer que o período será prolongado, proporcionando acesso contínuo a todos os recursos e configurações associados ao superusuário.

Independentemente da representação, é importante ressaltar que todos esses comandos, seja sudo su, sudo -i ou sudo -Es, fornecem um ambiente administrativo.
Ambos são úteis, mas a escolha entre eles depende das necessidades específicas e das políticas de segurança do sistema em uso.


Ao executar este script como um usuário comum, você receberá a mensagem "Você está em uma sessão de usuário comum."
Quando você o executa como o superusuário (root), que possui acesso às suas próprias variáveis de ambiente, a mensagem será "Você está em um ambiente root puro."
Aqui está o código:

Código:

if [ -n "$SUDO_USER" ]; then
  echo "Está em um ambiente root puro."
else
  echo "Está em uma sessão de usuário comum."
fi

Digamos que você está logado como root e deseja executar um comando sem permissões administrativas.
Use essa estrutura para executar o comando apenas com as permissões de um usuário especifico:
sudo -u username_aqui comando_aqui
sudo -u root ls -l
sudo -u flyer ls -l

Para verificar se o usuário logado possui acesso às variáveis de ambiente, você pode utilizar os seguintes comandos de teste:
echo "HOME: $HOME" = Esta variável armazena o caminho para o diretório pessoal do usuário atual.
echo "USER: $USER" = Contém o nome do usuário atualmente logado no sistema.
echo "SHELL: $SHELL" = Esta variável armazena o caminho para o shell padrão do usuário atual.
echo "PATH: $PATH" = Onde o sistema procura por programas para serem executados.
echo "LANG: $LANG" = Define o idioma padrão que o sistema operacional.
echo "SUDO_USER: $SUDO_USER" = Armazena o nome de usuário que iniciou a sessão do sudo.

outras variáveis:

Vou demonstrar o uso do parâmetro --preserve-env para mantém as variáveis de ambiente durante a execução de um script ou comando.
Isso pode ser útil em situações onde o script depende dessas variáveis de ambiente específicas para funcionar  (como PATH e LANG neste caso)
sudo --preserve-env=PATH,LANG script.sh

Para habilitar o uso do sudo em seu usuário comum, é necessário que o administrador do sistema inclua seu nome de usuário em um arquivo chamado /etc/sudoers
e lhe atribua uma senha especial para essa finalidade específica. Essa nova senha concederá permissões para aplicar configurações no sistema.
Você ficará com duas senhas: A senha para usar o sudo e sua senha principal para fazer o login na sua conta de usuário.
Ferramentas concorrentes do sudo:(Doas download), (pkexec download), runas-git, suex, gosu.

su
Ao contrário do sudo, o su é um comando essencial que já está incluído no pacote util-linux, o qual faz parte do pacote base do sistema.
su é uma abreviação para "substitute user", ou seja, ele permite a troca de usuário, incluindo a capacidade de efetuar login no superusuário (root).
O comportamento do comando su pode ser personalizado e configurado pelo administrador do sistema.

Para utilizar o comando su, basta digitar su seguido pelo nome do usuário desejado, como no exemplo:
su root 
su flyer
Ao usar o su e especificar um usuário, será solicitada a senha desse usuário. Se a senha estiver correta, você assumirá a identidade desse usuário durante a sessão.
Esse comando efetivamente inicia um shell com os privilégios de root dentro da sua sessão atual, mantendo as variáveis de ambiente do usuário comum.
Isso é útil quando você precisa realizar tarefas específicas como superusuário temporariamente, mantendo a maior parte do seu ambiente original.
É importante notar que o comando su não configura todas as variáveis de ambiente necessárias para uma sessão root pura.

O sudo e o su estão intrinsecamente ligados à organização dos usuários, especialmente àqueles que necessitam de permissões de acesso diferenciadas.
Vale relembrar os três tipos de usuários principais:
   Dono: Este é o usuário que criou o arquivo originalmente ou realizou a cópia. Como dono, ele possui autoridade total sobre o arquivo, incluindo a habilidade de definir permissões.
   Grupo: Este é um conjunto de usuários que compartilham determinadas permissões, com base na autorização concedida pelo dono. O grupo pode acessar o arquivo de acordo com as permissões estabelecidas.
   Outros: Esses são os usuários que não pertencem ao grupo do dono, as permissões definidas para "outros" se torna um tipo de exclusão para esses usuários.

Você tem a capacidade de conceder permissões de acesso a um arquivo, seja para um usuário específico ou para um grupo composto por diversos usuários.
Isso permite uma gestão fina das autorizações, garantindo que apenas os usuários autorizados tenham acesso aos arquivos.

Para visualizar os grupos existentes em seu sistema:
cat /etc/group

Aqui estão alguns exemplos de grupos do sistema: http, dbus, scanner, network, log ...
Ao adicionar um usuário a qualquer a um desses grupos, ele ganha a capacidade de acessar as funcionalidades associadas a esse hardware específico.

como criar um grupo
groupadd nome_do_grupo

Adicionar um usuário a um grupo
gpasswd -a nome_do_usuário nome_do_grupo

Para além da elevação de privilégios possibilitada pelo uso do sudo, você também pode empregar os comandos chmod, chown e chgrp
para ajustar as permissões de acesso, alterar o proprietário e modificar o grupo associado a um arquivo.
Ao entender como os grupos operam no ecossistema do Linux e como eles se interrelacionam com a elevação de privilégios de usuários,
você adquire o conhecimento de gerenciar seu sistema com extrema segurança para seu dados.

Durante minha demonstração de uma instalação detalhada do Arch Linux, você já pôde vivenciar esses conceitos na prática.
Aqui está um trecho dos comandos que foram utilizados, sobre grupos, sudo, criação de usuário e permissões:
groupadd sudo Cria um novo grupo, chamado sudo.
nano /etc/sudoers Edita o arquivo de configuração do sudo.
sudo ALL=(ALL) ALL remova o símbolo de # dessa linha
useradd -m -G sudo,uucp,vboxusers,log,sys,systemd-journal -s /bin/bash flyer1 Cria seu primeiro usuário, atribuindo ele a vários grupos e ao shell bash.
passwd flyer1 Define uma senha para esse usuário.
chmod 755 -R /media/usb Altera as permissões de um arquivo.
chown -R flyer1 /media/usb Modifica o proprietário de um arquivo.
chgrp -Rc flyer1 /media/usb Altera o grupo associado a um arquivo.


O Linux organiza os arquivos de forma inteligente e os envia para seus devidos locais.
O Filesystem Hierarchy Standard
Ou (FHS) é um projeto da Linux Foundation para padronizar a estrutura de diretórios e o conteúdo dos diretórios nos sistemas Linux.

alguns exemplos.

/ Este é o diretório raiz, o primeiro da hierarquia, essa barra indica o inicio de todos os outros caminhos, todos os outros diretórios ficam dentro dele.
Um sistema de arquivos é comparado a uma árvore; nesse caso, este seria o tronco ao qual todos os galhos se conectam.

/bin é um link simbólico(atalho) para /usr/bin. contendo executáveis de uso comum, Quanto mais programas instalados maior será o tamanho desse diretório.
/sbin é um link simbólico(atalho) para /usr/bin. contendo executáveis que controlam o sistema. Quanto mais programas, maior será o tamanho desse diretório.

Descrição de Link simbólico:

/usr Com executáveis binários, documentações, bibliotecas, plugins, daemons, etc. 184818 itens. Tamanho 6,4 GiB.

/var diretório de arquivos em cache variáveis e de crescimento exponencial. 5278 itens. Tamanho da pasta 2,0 GiB.

/run arquivos temporários do sistema que são necessários pelos PIDs em execução, sockets, containers, tem um subdiretório chamado /run/user/ com seu ID de usuário como nome do diretório. id -u usuário_aqui contêm informações temporárias relacionadas às sessões e atividades dos usuários, como data e hora da execução do comando sudo.

/dev abreviação de (devices), aqui contém arquivos que representam todos os dispositivos, como por exemplo: os virtuais com suas sessões de pseudoterminais e os de rede para comunicação de VPN, etc. São gerados dinamicamente pelo sistema durante o processo de inicialização e podem variar de acordo com o sistema. Conheça o diretório /dev/null Quando você redireciona a saída de um comando para /dev/null você envia essa saída para o nada, uma espécie de buraco negro no sistema Unix-like, frequentemente usado em scripts e automatização de tarefas para suprimir saídas indesejadas.
/dev/shm, também conhecido como tmpfs, é um sistema de arquivos especial que reside os dados da memória RAM, útil para operações que requerem acesso rápido aos dados, como caches temporários. Quando o sistema é reiniciado, o conteúdo de /dev/shm/ é perdido e precisa ser recriado.
/dev/zero, Este dispositivo é uma fonte de dados zerados. Todos os dados gravados neste dispositivo são descartados. Uma leitura deste dispositivo retornará tantos bytes contendo o valor zero quantos foram solicitados.
/dev/tty, é uma representação simbólica do terminal de controle de um processo. Quando o dispositivo /dev/tty é aberto, todas as operações de leitura e escrita realizadas por esse programa serão direcionadas para o terminal de controle ativo, como se o programa estivesse interagindo em tempo real.

/home arquivos pessoais, como documentos, fotografias, save de games/softwares. Você passará muito tempo controlando o crescimento dessa pasta.

/.cache é um diretório oculto ligado a home do usuário, que armazenamento de dados temporários dos aplicativos. Reduzindo a necessidade de recriar os dados.
/.cache/mesa_shader_cache refere-se ao diretório cache para shaders gerados pelo driver Mesa, que oferecer suporte a aceleração gráfica, como transformações geométricas, cálculos de luz e sombras, texturização, outros. Quando esses shaders são compilados e executados pela primeira vez, o driver gráfico os armazena em cache para acelerar o seu carregamento no futuro, evitando a necessidade de recompilar os shaders sempre que um programa é iniciado, economizando tempo e recursos do sistema.

Outras Pastas: /mnt /srv /root /boot /opt /lib /lib64 /proc /sys /etc /tmp (se somar todas essas outras da 1,4GiB)
no final dessa publicação comentei em forma de lista um guia, para te ajudar a entender as pastas do Linux.

PASTAS IMPORTANTES DO ARCH LINUX

Código:

Seu kernel fica nessa pasta
/lib/modules

esses arquivos descrevem como um initramfs deve ser construído
/usr/share/libalpm/scripts

para definir preset de inicialização
nano /etc/mkinitcpio.conf
nano /etc/mkinitcpio.d/linux.preset

arquivos de daemon usado pelo systemctl
/etc/systemd/system

Chaves "PGP PUBLIC KEY"
/usr/share/pacman/keyrings

Histórico de todos os comandos que você fez usando o pacman. journal
/var/log

documentações de inúmeros programas instalados
/usr/share/doc

Repositórios são banco de dados usados pelo pacman.
/var/lib/pacman
se você deseja alterar o caminho dos repositórios deve comenta-los aqui:
nano /etc/pacman.conf

Pacotes baixados e armazenados para serem reinstalados localmente, sem internet.
/var/cache/pacman/pkg
lembrando que essa pasta pode ser limpa para abrir espaço em seu HD: sudo pacman -Sc
para reinstalar um pacote dessa pasta ou fazer downgrade use:
sudo pacman -U '/var/cache/pacman/pkg/arch-wiki-docs-20221115-1-any.pkg.tar.zst'
+informações me https://wiki.archlinux.org/title/Downgrading_packages_(Portugu%C3%AAs)

Aqui fica a memória dos aplicativos instalados.
(programas desinstalados ainda guardam os perfis dos usuários.)
ex: Se eu deletar a pasta do meu Streaming de música "Deezer" vou precisar fazer login novamente, resetando o cache que guardava meu perfil.
Fazendo backup dessa pasta, você não precisará fazer login em seus programas, mesmo depois de uma formatação.
/home/flyerpc/.config

informações de versões, dependências ...
as informações dessa pasta é puxada com esse comando: pacman -Ql
/var/lib/pacman/local

Local que armazena miniaturas de imagens
/home/flyerpc/.cache/thumbnails

temas para seu computador em [url=https://wiki.archlinux.org/title/GTK_(Portugu%C3%AAs)]GTK[/url]
/usr/share/themes

Papeis de paredes do Xfce(11,2 MiB )
/usr/share/backgrounds/xfce

configuração do menu iniciar
/usr/share/desktop-directories

Barra de aplicações
/home/flyerpc/.local/share/applications/

Aplicações básicas do usuário, se arrasta-los para a dock cria um atalho
/usr/share/applications

log de notificações do Xfce
/home/flyerpc/.cache/xfce4/notifyd

Letras / fontes
/usr/share/fonts

Ícones
/usr/share/icons

Recursos compartilhados entre vários pacotes, como documentação,
man pages, informações de fuso horário, fontes e outros recursos.
/usr/share

[AUR] scripts do RUA/AUR baixados e aguardando para serem compilados (pode deletar)
Etapa 1, diretório em que os pacotes AUR são clonados.
/home/flyerpc/.config/rua/pkg

[AUR] RUA = arquivos compilados (pode deletar)
Etapa 2, os pacotes revisados são copiados aqui e, em seguida, construídos
/home/flyerpc/.cache/rua/build

[AUR] RUA = pronto para instalar (pacman -U)  (pode deletar)
/home/flyerpc/.local/share/rua/checked_tars/

Ótimo local para se criar uma Lixeira
/home/flyerpc/.local/share/Trash/files
ou
trash:///

Bootloader do sistema
/boot/grub
/usr/lib/grub
/usr/share/grub
para configurar o grub, edite esse arquivo.
nano /etc/default/grub

----------------------------------------------------------------------
       PASTAS DE JOGOS/SOFTWARES
----------------------------------------------------------------------
                       

Código:

TOX Mensageiro P2P (pacman -S toxic) localidade do profile local.
/home/flyerpc/.config/tox/toxic_profile.tox

Gerenciador de senhas (pacman -S keepass)
/usr/share/keepass/Languages

pitivi editor de vídeo
/home/flyerpc/.local/share/pitivi

persepolis (download do youtube)
/home/flyerpc/.persepolis
download de vídeos inacabados, ficam na pasta /proc

----------------------------------------------------------------------
                           Jogos
----------------------------------------------------------------------

Para ler relatórios de erro em jogos feitos em unity. (escolha a pasta do jogo) Player.log
/home/flyerpc/.config/unity3d

winetricks
/home/flyerpc/.local/share/wineprefixes

onde todos os programas instalados com winetricks ficam
/home/flyerpc/.cache/winetricks

onde fica os atalhos de jogos instalado com wine
/home/flyerpc/.local/share/desktop-directories

arquivos do próprio wine como: gecko mono
/usr/share/wine

----------------------------------------------------------------------
                           GOG
----------------------------------------------------------------------

Heroic games (quando se instala a GoG pela Heroic)
GOG - pasta temporária antes de transferir os arquivos para o local final
/home/flyerpc/.cache/heroicGOGdl

Stardew Valley - GoG
/home/flyerpc/.config/StardewValley/Saves
Stardew Valley - fotos
/home/flyerpc/.local/share/StardewValley/Screenshots

Fell Seal: Arbiter's Mark - GoG
/home/flyerpc/Fell Seal/saves/
Adicionar fotos no jogo
/home/flyerpc/Fell Seal/customdata/portraits

Nebuchadnezzar - GoG (mods) (screenshots)
/home/flyerpc/.local/share/NeposGames/Nebuchadnezzar/save

Divinity Original Sin - GoG
/home/flyerpc/Larian Studios/Divinity Original Sin Enhanced Edition/PlayerProfiles

Pillars of Eternity - GoG
/home/flyerpc/.local/share/PillarsOfEternity/SavedGames

Neverwinter Nights - GoG
/home/flyerpc/.local/share/Neverwinter Nights/saves

democracy 3 - GoG (screenshots) (mods)
/home/flyerpc/.local/share/democracy3/savegames

Baldur's Gate - GoG
save + portraits
/home/flyerpc/.local/share/Baldur's Gate - Enhanced Edition

Baldur's Gate II - GoG
/home/flyerpc/.local/share/Baldur's Gate II - Enhanced Edition

witcher 2 - GoG
/home/flyerpc/.local/share/cdprojektred/witcher2/GameDocuments/Witcher 2/gamesaves

Tyranny - GoG
/home/flyerpc/.local/share/Tyranny/SavedGames

Train Fever - GoG
/home/flyerpc/.local/share/Train Fever/save

Beholder - GoG
/home/flyerpc/Warm Lamp Games/Beholder/Saves

pulstar - GoG
/home/flyerpc/.local/share/SNK/pulstar

The King of Fighters 2002 - GoG
/home/flyerpc/.local/share/SNK/kof2k2nd

Ascendant - GoG (screenshots vem parar nessa pasta)
/home/flyerpc/.config/unity3d/Hapa Games/Ascendant

Sid Meier's Civilization IV: The Complete - GoG (wine)
/home/flyerpc/Documentos/My Games/Civ4/Saves/single
outros locais
/media/flyerpc/DRMFREE/wine/CivilizationIV/wine/drive_c/users/flyerpc/AppData/Local/My Games/Civ4
/media/flyerpc/DRMFREE/wine/CivilizationIV/wine/drive_c/users/flyerpc/Saved Games
local de mods
/home/flyerpc/Documentos/My Games/Civ4/MODS
/home/flyerpc/Documentos/My Games/Civ4/ScreenShots

DinsCurse - DepthsOfPeril - DinsLegacy - Zombasite - GoG
/home/flyerpc/.local
Pastas correspondentes ao nome do jogos,
o arquivos user.cfg quando editado é possível mudar os parâmetros do jogo.

Zomboid - GoG
isso não deveria estar aqui
/proc/1954/task/1954/cwd/Zomboid

Gurumin: A Monstrous Adventure - GoG (wine)
/media/flyerpc/DRMFREE/wine/gurumim/exe/drive_c/users/flyerpc/Application Data/FALCOM/GURUMIN

Fallout3 - GoG (wine)
/home/flyerpc/Documentos/My Games/Fallout3/Saves

The Elder Scrolls IV Oblivion - GoG (wine)
/home/flyerpc/Documentos/My Games/Oblivion

----------------------------------------------------------------------
                           STEAM
----------------------------------------------------------------------
LOCALIZAÇÃO DOS JOGOS INSTALADOS pela steam

pasta padrão
/media/flyerpc/Steam/steamapps/common

local de instalação dos proton
/home/flyerpc/.local/share/Steam/steamapps/common

Local de vários saves em nuvem
/home/flyerpc/.local/share/Steam/userdata/1150652640

Grim Dawn
/home/flyerpc/.local/share/Steam/userdata/1150652640/219990/remote/save/main
Grim Dawn options keybindings
/media/flyerpc/SteamLibrary/steamapps/compatdata/219990/pfx/drive_c/users/steamuser/Documents/My Games/Grim Dawn/

long dark
/home/flyerpc/.local/share/Steam/userdata/1150652640/760/remote/305620

Europa 4 universalis
/home/flyerpc/.local/share/Steam/userdata/1150652640/760/remote/236850

Dawn of War (ScreenShots)
/home/flyerpc/.local/share/Steam/steamapps/common

Titan Quest
/home/flyerpc/.local/share/Steam/steamapps/compatdata/475150/pfx/drive_c/users/steamuser/My Documents/My Games/Titan Quest - Immortal Throne/SaveData

HotlineMiami2 (mods)
/home/flyerpc/.local/share/HotlineMiami2

Terraria
/home/flyerpc/.local/share/Terraria

Oxygen Not Included
save offline
/home/flyerpc/.config/unity3d/Klei/Oxygen Not Included/save_files
save na nuvem
/home/flyerpc/.config/unity3d/Klei/Oxygen Not Included/cloud_save_files

----------------------------------------------------------------------
                           EPIC
----------------------------------------------------------------------
pasta padrão que fica muitos save game e também programas.
/home/flyerpc/.local/share

Civilization 6
/home/flyerpc/.local/share/aspyr-media/Sid Meier's Civilization VI/Saves/Single/
mod
/media/flyerpc/SteamLibrary/steamapps/common/Sid Meier's Civilization VI/steamassets/base/assets

Don't Starve
/home/flyerpc/.steam/steam/userdata/1150652640/219740/

Cities Skylines
/home/flyerpc/.local/share/Colossal Order/Cities_Skylines/Saves/

Tropico 6
/home/flyerpc/.local/share/Tropico6/Saved/SaveGames/

Worms Reloaded
/home/flyerpc/.local/share/Team17  (FALTA CONFIRMAR)
ou
/home/flyerpc/.local/share/Steam/userdata/1150652640/22600/remote/home/flyerpc/.local/share/Team17

SimCity 2013 executável
/home/flyerpc/Games/simcity-2013/drive_c/Program Files (x86)/Origin/Origin.exe
SimCity 2013 local dos games da origin
/home/flyerpc/Games/simcity-2013/drive_c/users/flyerpc/Meus Documentos/SimCity/Games/
Observação: dentro dessa pasta contém uma subpasta para cada save!
SimCity 2013 como são as pastas com saves
9a3b67ca9f02c197

SimCity 2013 pirata
/home/flyerpc/Games/simcity-2013/drive_c/Program Files (x86)/install/SimCity/SimCity.exe
SimCity 2013 Save pirata
9a3b6720a2b84853

Diablo 1 devilutionx
informações de inicialização do game
/home/flyerpc/.local/share/diasurgical/devilution
instalação
/home/flyerpc/.cache/rua/build/devilutionx
local que cola os arquivos .MPQ retirados do .EXE
/usr/share/diasurgical/devilutionx
traduções
/home/flyerpc/.cache/rua/build/devilutionx/src/devilutionX-1.3.0/Translations

The Bard's Tale
/home/flyerpc/.local/share/BardTale/data/SavedGames
----------------------------------------------------------------------
                                   LUTRIS
----------------------------------------------------------------------
Local que ficam instalado os jogos das lojas, se feito pelo Lutris

Lutris capas para jogos
/home/flyerpc/.local/share/lutris/banners

Lutris prefix
/home/flyerpc/.local/share/lutris/runners

EPIC
/media/flyerpc/Lutris/Epic Games/drive_c/Program Files/Epic Games

BATTLE.NET
/media/flyerpc/Lutris/Battle.net/drive_c/Program Files (x86)

ORIGIN
/media/flyerpc/Lutris/Origin/Simcity/drive_c/Program Files (x86)/Origin Games/

Ubisoft
/media/flyerpc/Lutris/Ubisoft/drive_c/Program Files (x86)/Ubisoft/Ubisoft Game Launcher/games

GOG Galaxy
/media/flyerpc/Lutris/GOG/GOG Galaxy/APP LUTIS/drive_c/Program Files (x86)/GOG Galaxy/Games

faça uma pasta para cada jogo.
----------------------------------------------------------------------
                  Jogos nativos de linux
----------------------------------------------------------------------

0ad
/home/flyerpc/.local/share/0ad/saves

flare (mods)
/home/flyerpc/.local/share/flare
----------------------------------------------------------------------
           Jogos do emulador (Fightcade)
----------------------------------------------------------------------

Fightcade (local da maioria das roms)
/home/flyerpc/.fightcade2/emulator/fbneo/ROMs

roms do video-game snes9x "super nintendo"
/home/flyerpc/.fightcade2/emulator/snes9x/ROMs

roms do video-game FBNeo "MegaDrive"
/home/flyerpc/.fightcade2/emulator/fbneo/ROMs/megadrive

não usar está pasta para guardar roms
/home/flyerpc/.fightcade2/ROMs

Como pesquisar a localização de um programa:
$ which -a firefox
$ pacman -Ql firefox
"which" ou "pacman -Ql" dará informações da localização para binários executáveis.

Enquanto o comando "ls -lh" te mostrará informações da pasta.
$ ls -lh /usr/bin/firefox


VOLTAR AO TOPO
VOLTAR AO ÍNDICE

VOLTAR AO ÍNDICE
 PRÓXIMA PÁGINA

VOLTAR AO TOPO
VOLTAR AO ÍNDICE

VOLTAR AO ÍNDICE
 PRÓXIMA PÁGINA

VOLTAR AO TOPO
VOLTAR AO ÍNDICE

VOLTAR AO ÍNDICE
 PRÓXIMA PÁGINA

Não é necessário reter todos esses comandos em sua memória, pois eles estão prontamente acessíveis em livros e em guias como esse. O efetivo mérito de uma instrução de cunho técnico não reside na memorização de informações, mas sim na capacidade de treinar a mente para aplicar uma análise lógica na utilização dessas informações, com o objetivo de resolver o desafio em questão.

Fonte da imagem > https://wiki.archlinux.org/title/core_utilities

O site https://explainshell.com é uma ferramenta online que permite entender facilmente o funcionamento de comandos da linha de comando do Linux e do Unix.
Ele ajuda os usuários a desmembrar comandos complexos, fornecendo explicações detalhadas para cada argumento e opção usados no comando.

Vou te familiarizar com os comandos básicos de um sistema POSIX (Portable Operating System Interface)
Há um conjunto de utilitários essenciais no sistema GNU/Linux, os quais são ferramentas fundamentais e básicas para o correto funcionamento do sistema.
Essas ferramentas são tradicionais do Unix, sendo que muitas delas foram padronizadas pelo POSIX e permanecem em constante desenvolvimento, sendo amplamente utilizadas até os dias de hoje.
A POSIX define um conjunto unificado de padrões para manter a compatibilidade entre todos os sistemas operacionais do tipo Unix-like,
sendo o Linux um exemplo, essa padronização possibilita o compartilhamento de ferramentas entre essa família,
isso permite que você troque de distribuição Linux sem que se perceba grandes discrepâncias.
Em outras palavras, a aderência aos padrões POSIX suaviza a transição entre diferentes ambientes Linux, criando uma experiência mais contínua os usuários.
As diferenças entre diferentes distribuições Linux costumam se concentrar em nuances sutis relacionadas à filosofia e ao foco de cada uma, abordando aspectos como privacidade, simplicidade, uso em servidores, usuário-friendly, offline, científico, elegante, otimizado, entre outros.
Esses ajustes finos estão incorporados nos seguintes aspectos: "Gerenciadores de Pacotes", "Estrutura de Diretórios", "Dependências", "Formatos de Pacotes", "Métodos de Inicialização", "Políticas de Atualização" e "Seleção de Software Padrão".

Aqui temos quatro exemplo de utilitários que fazem parte do sistema operacional Linux:
ls (listar arquivos), cp (copiar arquivos), mv (mover arquivos), rm (remover arquivos) entre muitos outros utilitários de linha de comando.
Esses comandos vêm acompanhados de instruções que fornecem informações adicionais sobre como o comando deve se comportar, é uma combinação de letras e números.
Possibilitando redirecionar uma entrada para produzir saídas. (conhecido como E/S ou I/O em inglês).
Além disso, é possível estabelecer uma interconexão entre comandos utilizando pipes, simbolizado por esse caractere vertical |
Os pipes têm a capacidade de direcionar a saída de um comando para servir como entrada para outro comando subsequente, estabelecendo uma conexão contínua.
Uma ampla variedade de tarefas relacionadas à manipulação de arquivos e texto usam essa abordagem, atendendo tanto aos usuários comuns quanto a cientistas de dados.  
Após uma breve introdução aos complementos dos comandos, finalmente, apresentarei os comandos (programas binários) concebidos para funcionar via linha de comando.
Esses programas estão integrados ao ambiente GNU/Linux e seus códigos-fonte são acessíveis.
Por serem gratuitos, você também os encontra em versões com interfaces gráficas compondo outras ferramentas.
Embora o Linux ofereça interfaces gráficas de usuário (GUI), o uso de comandos na linha de comando (CLI) pode ser mais eficiente para várias tarefas, mesmo para iniciantes.
Com base nas premissas apresentadas, irei expandir essa introdução:

Observações:
¹ Saída é o termo usado para se referir às informações ou resultados que aparecem na tela após a execução de um comando.
Esses resultados podem variar de um simples texto exibido na tela a uma lista de arquivos ou diretórios, informações de status, mensagens de erro ou até mesmo resultados processados ou filtrados. Você também tem a opção de redirecionar essa saída para um arquivo, permitindo que ela seja armazenada em um documento.
Quando alguém solicitar que você imprima a saída de um comando, essa pessoa espera ver esses resultados na tela do terminal.
A habilidade de capturar e manipular a saída dos comandos é essencial para trabalhar de forma eficaz no ambiente Linux.

² Os comandos podem variar dependendo do shell utilizado: Bash Zsh Fish

³ Todos os comandos possuem argumentos, opções e parâmetros, e são sensíveis a maiúsculas e minúsculas.

Cada comando possui seus próprios argumentos de linha de comando. Por exemplo:
-a, --all
-l, --list
-o, --out
-q, --quiet
-i, --interactive (Solicita confirmação do usuário s/n)
-r, -R, --recursive: opera recursivamente (desce na árvore de diretórios).
-v, --verbose: exibe informações adicionais na saída padrão ou de erro.

No entanto, em alguns comandos específicos, é possível notar novos significados para esses argumentos:
Um exemplo disso é a opção -f, a qual possui dois significados distintos quando utilizada em programas diferentes.
Em tar e gawk: -f, --file: especifica o nome do arquivo.
Em cp, mv, rm: -f, --force: força a execução da ação.

Teclas de atalho que o Linux reconhece:
Ctrl + C = Interrompe um programa, finaliza o processo atual.
Ctrl + Z = Pausa um programa, coloca o processo em segundo plano; fg (foreground) volta com o processo.

Ctrl + Z informações:

Ctrl + A = Move o cursor de digitação para o início da linha.
Ctrl + E = Move o cursor para o final da linha.
Ctrl + K = Apaga tudo da posição atual do cursor até o final da linha.
Ctrl + U = Apaga tudo da posição atual do cursor até o início da linha.
Ctrl + Y = Restaura o texto apagado pelas teclas Ctrl + K ou Ctrl + U.
Ctrl + W = Apaga a palavra à esquerda do cursor.
Ctrl + Shift + C = Para copiar o texto selecionado.
Ctrl + Shift + V = Para colar o texto.
Ctrl + L = Limpa o terminal "clear".
Ctrl + R = Realiza uma pesquisa nos comandos anteriores, insira uma palavras-chave depois; pressione repetidamente Ctrl + R para alternar entre os comandos encontrados.
Ctrl + T = Inverte de posição os dois caracteres à esquerda do cursor.
Ctrl + Seta para a Direita = ou para esquerda,move o cursor para a próxima palavra; o fim de uma palavra é determinado por !@#$%¨&*()_+{}?:><[]=-,.'".
Shift + Seta para cima = ou para baixo, rola o texto; funciona no terminal do XFCE.
Shift + Tab = Em alguns programas de terminal (TUI) com guias ou abas, permite que você mude o foco para a guia anterior.
Ctrl + D = Fecha o terminal, ou encerrará qualquer comando em execução, se houver.

Não existe um comando específico para desfazer uma ação no terminal, como recuperar um texto que tenha sido apagado.
Essa função comum em editores de texto não se aplicam no terminal, mas o shell interativo oferece um histórico de comandos; Ctrl + R.

Uma tarefa comum ao utilizar o terminal é obter o caminho completo de um arquivo com o qual você deseja trabalhar. Existem várias maneiras de obter esse caminho, incluindo:
Vamos obter o caminho do arquivo random_alert.py, supondo que seu arquivo esteja no diretório de trabalho:
[adr1@netlinux Documentos]$ realpath random_alert.py

resultado do comando:
'/home/adr1/Documentos/random_alert.py'

mais pela frente você aprenderá a usar o comando cd para mudar de diretório.

Outra maneira de obter o caminho completo do arquivo é arrastando-o para a janela do terminal:


O diretório home é o diretório pessoal dos usuários de sistemas Linux. Cada usuário criado nesse Linux tem seu próprio diretório home com suas configurações pessoais.
Você pode referenciar o diretório home de várias maneiras.
Nesse exemplo vou criar 4 pastas no diretório home, usando diferentes formas:


O resultado foi 4 pastas criadas dentro do diretório home:
/home/usuario/media
/home/usuario/media2
/home/usuario/media3
/home/usuario/media4


Se o diretório home for o seu diretório de trabalho atual, faça referência direta aos arquivos existentes pelo nome, sem a necessidade de especificar um caminho completo.
O ponto . também é usado como um indicador para o diretório atual.
media

O caractere til ~ é uma forma comum de referenciar o diretório home.
~/media

Para navegar para o diretório pessoal do usuário:
cd ~

A variável de ambiente $HOME contém o caminho para o diretório home do usuário atual.
$HOME/media

Quando você está em um diretório diferente e precisa especificar um caminho para outro diretório, é importante usar o caminho completo.
Especificar o caminho completo ajuda a evitar erros acidentais, especialmente ao usar comandos destrutivos como rm (para excluir arquivos) ou mv (para mover arquivos).
Observe que há pastas com nomes semelhantes em hierarquias de localização distintas:
/media
/home/usuario/media
/home/usuario/Desktop/media
Em alguns Linux, o diretório /media é usado para montar dispositivos removíveis, como unidades USB, discos rígidos externos, CD-ROMs, DVDs etc.

Atente-se a esses dois comandos e observe o diretório que estão sendo referenciados:
rm ./media
rm /.media
Ambos são comandos usados para deletar arquivos.
O comando rm ./media tem o caminho começando com . e faz referência a nossa home, onde encontramos uma pasta chamada media.
Já neste comando rm /.media o caminho começa com / indicando à raiz do sistema, onde existe uma pasta chamada .media.
O impacto desses dois comandos é consideravelmente diferente. Ao executar o comando que referencia o diretório raiz do sistema, rm /.media,
você precisa obrigatoriamente usar sudo, pois apenas o administrador do computador tem acesso a esses arquivos.
Em contrapartida, não há impactos em deletar uma pasta chamada ./media em sua home, pois se trata de um diretório pessoal,
e qualquer dano causado afetaria apenas os arquivos e pastas relacionados à sua conta de usuário, sem impactar o sistema como um todo.

No terminal, se você estiver em dúvida sobre se está logado como administrador ou usuário comum, basta dar uma olhada no seu prompt de comando, que se parece com isto:
[flyer@netlinux ~]$
ou
[root@netlinux /]#
Esse prompt oferece várias informações importantes. O flyer é o nome do seu usuário,
e netlinux é o nome do host, que corresponde ao conteúdo do arquivo /etc/hostname e é usado para identificar o sistema na rede ou localmente.
Imediatamente após o netlinux, você vê o símbolo ~, que representa o diretório atual, nesse exemplo está no diretório pessoal do usuário.
No segundo prompt, o caractere / indica que você está no diretório raiz do sistema. O diretório raiz é o ponto de partida do sistema de arquivos, e a partir dele, a estrutura de diretórios se ramifica. Quando você vê o / no prompt, isso sinaliza que você está operando no nível mais alto do sistema de arquivos.
Outro aspecto importante desses prompts são os símbolos $ e #, que denotam o tipo de usuário atual e o nível de privilégios que ele possui.
O símbolo $ (cifrão) é usado para usuários comuns, indicando que eles não têm privilégios administrativos.
O símbolo # (sustenido ou cerquilha) é reservado para o superusuário, comumente conhecido como root.
O superusuário tem privilégios administrativos completos, o que inclui realizar tarefas críticas como instalar e remover software do sistema.

O que define essa configuração de prompt (shell prompt) é essa variável PS1 é usada para personalizar essa aparência.
você pode consulta-la, usando o comando:
echo $PS1

[flyer@netlinux ~]$ echo $PS1
[\u@\h \W]\$

\u é substituído pelo nome de usuário atual (neste caso, flyer).
\h é substituído pelo nome do host (neste caso, netlinux).
\W é substituído pelo diretório de trabalho atual (por exemplo, ~ para o diretório home).
\$ representa o tipo de usuário logado, $ para comum, # para root.

Para acessar a conta de usuário root enquanto você está logado como um usuário comum, você pode usar o comando:
su
será solicitado a inserir a senha do usuário root.
****
Após digitar a senha correta, você estará logado como root com privilégios administrativos completos.
Para sair do root, digite:
exit
Em muitas distribuições Linux, a conta root fica desativada, e em vez disso, você deve usar o comando sudo para conceder temporariamente privilégios administrativos.

Operador Lógico
VAMOS CONHECER ALGUNS OPERADORES DE REDIRECIONAMENTO, VOCÊ VERÁ ELES ACOMPANHANDO OS COMANDOS:
> É um sinal de redirecionamento que direciona a saída padrão de um comando para um arquivo, substituindo o conteúdo existente, se houver.
>> Também é um sinal de redirecionamento, mas ao contrário de ">", adiciona a saída padrão de um comando ao final de um arquivo existente, sem substituí-lo.
< Sinal de redirecionamento que utiliza um arquivo como entrada padrão de um comando. O conteúdo do arquivo é usado como entrada para o comando.
<< Sinal de redirecionamento. É útil para inserir texto diretamente no terminal como entrada de um comando.
2> Redirecionar a saída de erro, ele substituirá o conteúdo existente no arquivo de destino.
2>> Adicionará a saída de erro do comando, ao final de um arquivo existente. ls /diretório_inexistente 2>> erro.txt
& Executa o comando em segundo plano, quando colocado no final de um comando você cria uma tarefa em segundo plano.
&& Ele permite que o segundo comando seja executado na mesma linha em conjunto com outros, somente se o primeiro comando for bem-sucedido.
| Símbolo conhecido como "pipe" que permite redirecionar a saída do comando anterior para o próximo comando.

Para quem quer se aprofundar nesses condutores(redirecionadores), pesquise externamente:
stdin (Standard Input): É a entrada padrão de um programa no Linux. Representa o fluxo de entrada de dados, como o teclado ou qualquer outro dispositivo que forneça dados para o programa. É identificado pelo número 0.
stdout (Standard Output): É a saída padrão de um programa no Linux em condições normais. Representa o fluxo de saída de dados, que é exibido no terminal, impressora, arquivo ou outro dispositivo. É identificado pelo número 1.
stderr (Standard Error): É a saída de erro de um programa no Linux, utilizada para exibir mensagens de erro ou informações sobre falhas durante a execução. Também pode ser redirecionada para o terminal, arquivo ou outro dispositivo. É identificado pelo número 2.
tty Abreviação de "Teletype", é um dispositivo de terminal no Linux. Representa um terminal real ao qual um usuário está conectado, seja por meio do console físico ou de terminais virtuais.
pts (Pseudo-Terminal): Representa um terminal emulado por um programa, como o SSH. É usado quando um programa é executado através de uma conexão remota e está associado a um terminal falso.



Conheça alguns termos comumente usados no contexto do shell do Linux.

O que são os Comandos do Linux?
São as instruções que você dá ao shell para executar uma determinada ação.
Realizando todo tipo tarefas diferentes, como abrir um arquivo, criar uma pasta, ou executar um programa.


O que é Shell Scripting?
é como contar uma história para o computador, mas usando uma linguagem de programação.
Em vez de dar apenas um comando de cada vez, você coloca vários comandos juntos escritos em um arquivo de texto, como se fosse uma lista de tarefas.
Você salva esse arquivo na extensão .sh, assim meu_script.sh.
Quando você executa esse arquivo, o computador lê cada comando na ordem em que estão listados e os executa um por um. É uma maneira de dizer ao computador exatamente o que você quer que ele faça.
Com shell scripting, você pode automatizar tarefas repetitivas ou complexas e usando todas as funcionalidade do seu sistema operacional Linux, como variáveis, loops, condicionais...


O que são as Variáveis?
Variáveis são como etiquetas que você cola em coisas para se lembrar delas mais tarde.
No shell, você pode usar variáveis para guardar informações importantes, como palavras, números ou até mesmo nomes de arquivos.
Por exemplo, se você quer se lembrar da frase "abcd_efgh", você pode criar uma variável chamada "var" e colar essa frase nela.
Por exemplo, vamos criar essa variável:
var="echo abcd_efgh"
Para visualizar a variável criada:
$var
Então, sempre que você quiser ver o que está escrito na variável, você pode simplesmente pedir para o computador mostrar para você usando o comando $var.
É como ter post-its virtuais para lembrar as coisas importantes!



O que é uma String?
As strings são usadas para armazenar texto ou dados, podendo ser letras, números, símbolos e espaços vazios, que formam um texto. Por exemplo, "Olá mundo!" é uma string.
Strings são simplesmente dados textuais sem nenhum padrão especial associado a eles. Elas são tratadas de forma literal pelo shell.
Elas podem ser utilizadas em uma variedade de situações, como manipulação de arquivos de texto, processamento de dados e muito mais.
Suponha que você queira armazenar o seu nome em uma string e depois exibi-lo na tela:
Criaremos uma variável chamada "nome" e atribui a ela a string "João".
nome="João"
Agora exibimos ela:
echo "Olá, $nome!"


O que é uma Expressão Regular?
As expressões regulares (também chamadas de regex) são padrões de texto utilizados para encontrar sequências específicas de caracteres em uma string.
Você pode pensar nelas como padrões de busca que você cria para encontrar palavras ou frases específicas em uma grande quantidade de texto.
Por exemplo, se você quer encontrar todas as palavras que começam com "b" e terminam com "la", você pode usar uma expressão regular como:
b.la, onde o . representa qualquer letra única.
Isso fará com que o computador procure por padrões que se encaixem nesse molde e retorne os resultados correspondentes.


O que é Funções?
Permitem que você agrupe um conjunto de comandos para serem executados juntos. Elas são úteis para reutilização de código e organização.
São como receitas que você cria para fazer algo específico. Você pode juntar um monte de passos em uma função e, sempre que precisar fazer essa tarefa, basta chamar a função.
É como ter um conjunto de instruções prontas para uso.


O que é Array?
São estruturas de dados que permitem armazenar múltiplos valores em uma única variável. No shell, os arrays são úteis para manipulação de conjuntos de dados.


O que é Heredoc?
É uma forma de redirecionamento que permite que você forneça entradas de texto para comandos em scripts do shell.

O que é Expansão de Parâmetro?
Serve para extrair uma parte do conteúdo de algo, esse algo podendo ser um strings ou uma variáveis, fazendo a manipulação de seu conteúdo.
Isso permite realizar uma variedade maior de operações de processamento de texto.
Por exemplo, vamos criar um variável:
var="abcd_efgh"
Vamos visualizar parte do conteúdo dessa variável recém criada:
echo ${var#abcd_}
Ficando assim:
efgh

O que é Substituição de Comando?
Permite que você execute um comando dentro de outro comando e use o resultado desse primeiro comando como parte do segundo comando.
substituição de comando com crase (`command`)
substituição de comando com parênteses $(command)
exemplo:
[flyer@linux ~]$ echo A data de hoje é: $(date)
A data de hoje é: dom 07 abr 2024 11:59:02 -03


O que são as condicionais?
São usados para criar script em shell pois controlam o fluxo dos comandos para permitir executar determinadas partes do código com base em uma condição específica.
Avalia algo como verdadeiro ou falso. É uma combinação de testes ou operadores de comparação para se chegar num resultado.
Esses operadores são utilizados nas condicionais para tomar decisões com base em informações sobre arquivos ou variáveis.
No shell do Linux, as condicionais mais comuns são implementadas usando a instrução if.
then: Indica o código que será executado se a condição for verdadeira.
else: Indica o código que será executado se a condição for falsa.
fi: Indica o fim da condicional.
Por exemplo:
Você pode criar um script que verifica se o arquivo.txt existe ou não no diretório atual.
Se o arquivo existir, a mensagem "O arquivo existe." será impressa;
caso contrário, a mensagem "O arquivo não existe." será impressa.

operadores de comparação:

O que são Redirecionamento?
É o processo de direcionar a entrada, saída ou erro de um comando para ou de um arquivo de texto, ou para um outro comando.


O que é Pipes?
É uma forma de conectar a saída de um comando à entrada de outro, permitindo que você encadeie vários comandos juntos.


O que é Globbing?
É um recurso do shell que permite fazer correspondência de padrões em nomes de arquivos.


O que é Operadores de Comparação?
São utilizados para comparar valores em scripts do shell, tais como == para igualdade, != para desigualdade, < para menor que, > para maior que, entre outros.


O que é Loops?
São estruturas de controle de fluxo que permitem que um conjunto de comandos seja repetido várias vezes. Exemplos incluem for, while e until.


O que é Condicional?
São estruturas de controle de fluxo que executam um conjunto de comandos com base em uma condição. Exemplos incluem if, elif e else.


O que é Arquivos de Configuração?
São arquivos usados para configurar o comportamento de aplicativos, serviços e do próprio sistema operacional. Exemplos incluem ~/.bashrc, /etc/profile, /etc/bash.bashrc.


O que é Variáveis de Ambiente?
São variáveis especiais que contêm informações sobre o ambiente de execução do shell. Exemplos incluem PATH, HOME, USER.


O que é Expansão de Caminho?
É um recurso do shell que permite que você expanda padrões de caminho de arquivos. Exemplo: ~/Documents/*.txt.


O que é Subshell?
É um shell temporário criado dentro de um shell principal. Os comandos executados dentro de um subshell são independentes do shell pai e não afetam seu ambiente.


O que são Sinais (Signals)?
É uma forma de notificação que é enviadas para processos pelo kernel para indicar eventos como interrupções, erros ou solicitações do usuário.
Exemplos de sinais incluem SIGINT (gerado quando o usuário pressiona Ctrl+C) e SIGTERM (usado para solicitar a terminação de um processo).


O que são Serviços e Daemons?
São programas que rodam em segundo plano, como o systemd, NetworkManager, OpenSSH, D-Bus, Avahi, Cron ...

Para realizar tarefas básicas de processamento de texto dentro do terminal, vamos compreender alguns padrões do shell.

Delimitadores de comandos
Os delimitadores dizem onde começa e termina uma expressão regular(regex) que por sua vez são textos usados para identificar sequências de caracteres em uma string.
; Ponto e vírgula, usado como um separador de comandos. Permite que vários comandos sejam executados sequencialmente em uma única linha.
' ' Aspas simples, qualquer variável ou comando dentro de aspas simples não será interpretado, e será tratado como texto comum.
" " Aspas duplas,  para definir uma cadeia de caracteres (string), onde os caracteres especiais como ! $ tem seu valor literal preservado.
Permitindo que você faça isso: cd "$HOME/pasta família"
É importante observar que o uso de aspas simples ' ' ou duplas " " em torno do caminho de um diretório impede o uso de caracteres curingas.
Isso ocorre porque o shell trata o conteúdo dentro das aspas como uma string literal, fazendo o caracteres curingas perderem seus poderes.
Vai ter casos que será necessário usar um caractere de escape invés de um delimitador.
Nesse exemplo quero usar o * que é um caractere curinga, mas o nome do meu diretório tem espaço em branco:
cd /home/flyer/Vídeos/Nova\ past* a forma errada de fazer isso: cd "/home/adr1/Vídeos/Nova past*"
Caracteres curinga(Wildcards)
* Asterisco, corresponde a zero ou mais caracteres em um nome de arquivo. ls *.txt - lista todos os arquivos com extensão .txt
? Ponto de interrogação,  corresponde a um único caractere em um nome de arquivo. ls arquivo?.txt - lista todos os arquivos que tenham a palavra "arquivo" seguida de um caractere.
[] Colchetes, para especificar um conjunto de caracteres possíveis. ls arquivo[12].txt - lista os arquivos arquivo1.txt e arquivo2.txt
{} Chaves, para especificar um conjunto de palavras possíveis. ls {*.txt,*.pdf} - lista todos os arquivos com extensão .txt e .pdf
!! Repete o último comando.
Caracteres de escape, são usados para indicar que o próximo caractere tem um significado especial.
\n Representa uma quebra de linha.
\t Representa um tabulador.
\\ Representa uma barra invertida literal.
\" Representa uma aspa dupla literal.
\$ Representa um cifrão literal.
\ Indicar que o espaço que a segue faz parte do nome do diretório ou arquivo, em vez de representar um separador de argumento.

Outros caracteres especiais
~ Til ou Tilde abrevia o caminho que representa o diretório do usuário atual, ls ~/Documentos outra forma de representação ls $HOME/Documentos

Usando variáveis no shell scripting
As variáveis são armazenadas na memória do processo shell em execução. Cada variável tem um nome único e um valor associado a ela.
No que diz respeito ao limite de quantas variáveis o shell pode armazenar, isso geralmente depende da quantidade de memória disponível.
Escreva quantas quiser, quando você substitui uma variável por outra de mesmo nome, a anterior deixa de existir.
Como declaração uma Variável: Primeiro, você declara uma variável atribuindo um valor a ela, como fazer isso?
Em shells Unix e Linux, o sinal de igual = é comum de ser usado para atribuir esse valor.
titulo_da_variavel="teor_da_variavel"
É importante dizer que o título da variável só pode conter letras (a-z, A-Z) e sublinhados _ os caracteres subsequentes podem incluir números (0-9).
Após ter suas variáveis declaradas, acesse os valores armazenados em seus próximos comandos.
Para acessar o valor armazenado na variável, você usa o caractere $ seguido pelo nome da variável.
vou usar o comando echo, seguido pelo título da variável $nome para assim acessar seu conteúdo.

01 Você pode economizar digitação armazenando o caminho do arquivo em uma variável e, em seguida, usando essa variável nos próximos comandos com o operador &&
file_path="$HOME/entrada.txt" grep -c "meu texto" "$file_path" && grep -n "meu texto" "$file_path"
02 Calculando a soma de dois números 897+675:
num1=897 num2=675; soma=$((num1 + num2)); echo "A soma de $num1 e $num2 é igual a $soma"
(minimalista) I=897 II=675; soma=$((I + II)); echo "$soma"
03 Repete o nome dos arquivo ou diretório da sua home com uma mensagem embutida.
diretorio="$HOME/"; for arquivo in "$diretorio"/*; do echo "Processando o arquivo: $arquivo"; done
04 Lendo entrada do usuário e usando como parte de um comando.
echo "Digite seu nome:"; read nome; echo "Olá, $nome! Bem-vindo ao nosso sistema."

Dicas de sites para aprimorar sua compreensão dos comandos Linux: link¹

VOLTAR AO TOPO
VOLTAR AO ÍNDICE

VOLTAR AO ÍNDICE
 PRÓXIMA PÁGINA

Programar no Linux
Lista de linguagens de programação
Você pode usar o Arch Linux para desenvolver em praticamente todas as linguagens de programação disponíveis.
O terminal do Linux tem todas as ferramenta necessárias para os programadores.
Nesse terminal você cria automações de tarefas, tem acesso rápido a ferramentas para gerenciar servidores remotos.
Falando propriamente do Arch Linux, por ele ser rolling release, você terá acesso rápido às versões mais recentes de software e bibliotecas,
frameworks e outras ferramentas de desenvolvimento, com acesso fácil aos softwares e todo gerenciamento de dependências para seu projeto.
O que é benéfico para desenvolvedores que querem trabalhar com as tecnologias mais recentes.
Como o Linux é de código aberto, os programadores têm acesso ao código-fonte do kernel e de muitas outras partes do sistema operacional.
Isso permite uma compreensão mais profunda do funcionamento interno do sistema e a capacidade de modificar o código para atender às necessidades.
A maioria das linguagens de programação e suas ferramentas estão disponíveis nos repositórios oficiais do Arch Linux.
Podem ser instaladas através do gerenciador de pacotes, Pacman ou AUR (Arch User Repository).
Você pode trabalhar com diversas linguagens, como Python, Ruby, Perl, PHP, Java, JavaScript (Node.js), C/C++, Go, Rust, entre outras.
Além disso, o Arch Linux oferece suporte a uma grande variedade de ambientes de desenvolvimento, IDEs (Integrated Development Environments) e ferramentas de compilação.
Se você já está utilizando o Arch Linux, você pode empregar este comando para buscar por ferramentas de IDE nos repositórios oficiais.
pacman -Ss | grep -i -E 'text|programming|development'
Se você souber o nome da ferramenta que está procurando, torna-se ainda mais fácil:
pacman -Ss nome_aqui

Além das bibliotecas fornecidas pela própria linguagem de programação, é possível aproveitar os programas e bibliotecas instalados no próprio Linux.
Por exemplo, para desenvolver um aplicativo web que requer uma camada adicional de segurança para protegê-lo contra bots.
você pode integrar em seu projeto o programa haskell-recaptcha que está instalado no seu Arch Linux.
O reCAPTCHA é um serviço oferecido pelo Google, e você pode facilmente comunica-lo com seu projeto, independentemente da linguagem de programação escolhida.
Isso pode ser realizado de várias maneiras, incluindo execução externa, criação de wrappers, chamadas diretas ou utilizando a FFI (Foreign Function Interface).

Você pode usar sua linguagem de programação dentro do terminal do Linux.
Algumas linguagens:

Bash: A linguagem de script padrão no terminal Unix-like, usada para automatizar tarefas e interagir com o sistema operacional.

Perl: Outra linguagem de script usada para manipulação de texto e automação de tarefas.
Exemplo de comando: perl script.pl para executar um script Perl chamado script.pl.

Python: Uma linguagem de programação de alto nível usada para uma ampla variedade de tarefas.
Exemplo de comando: python script.py para executar um script Python chamado script.py.

Node.js (JavaScript): Uma plataforma para executar JavaScript do lado do servidor.
Exemplo de comando: node script.js para executar um script JavaScript chamado script.js.

C/C++: Linguagens de programação de propósito geral amplamente usadas.
Exemplo de comando: gcc programa.c -o programa && ./programa para compilar e executar um programa C chamado programa.c.

Ruby: Uma linguagem de programação dinâmica conhecida por sua simplicidade e elegância.
Exemplo de comando: ruby script.rb para executar um script Ruby chamado script.rb.

PHP: Uma linguagem de programação usada principalmente para desenvolvimento web.
Exemplo de comando: php script.php para executar um script PHP chamado script.php.

Java: Uma linguagem de programação popular usada para desenvolver uma ampla variedade de aplicativos.
Exemplo de comando: java Programa para executar um programa Java chamado Programa.

SQL: Linguagem de consulta estruturada usada para interagir com bancos de dados.
Exemplo de comando: mysql -u usuário -p senha -e "SELECT * FROM tabela" para executar uma consulta SQL em um banco de dados MySQL.

HTML/CSS: você pode usar editores de texto como Vim ou Nano para editar. Essas linguagens de marcação e estilo são usadas para criar páginas da web.
Embora não sejam executáveis diretamente no terminal, você pode editá-las usando esses editores de texto. Além disso, você pode usá-las em conjunto com ferramentas como curl para exibir páginas da web no terminal.
Se você pretende trabalhar com HTML, CSS, JavaScript e outras relacionadas ao design web, saiba que existem vários editores disponíveis no Linux.
Um exemplo é o Bluefish, um software de código aberto e gratuito em português.
Você pode usar o Bluefish para editar arquivos de backend, como PHP, Python, Ruby, entre outros, contudo o foco do Bluefish está no desenvolvimento de frontend.
Ele oferece recursos como realce de sintaxe e autocompletar, e pode lidar com vários projetos simultaneamente. Além disso, o Bluefish possui alguns plugins opcionais, como o Gucharmap, Intltool, necessário para compilar softwares. Manual | Wiki

você pode programar no Linux para criar aplicativos destinados a plataformas como Windows e mobile.

Desenvolvimento de Aplicativos para Windows:
Você pode usar ferramentas de cross-compilação para compilar aplicativos do Windows diretamente no Linux.
Por exemplo, você pode usar o MinGW (Minimalist GNU for Windows) para compilar programas C/C++ para Windows em um ambiente Linux.
Muitas plataformas de desenvolvimento, como .NET Core e Electron, oferecem suporte para desenvolvimento multiplataforma, permitindo que você escreva código em Linux e compile para Windows.

Desenvolvimento de Aplicativos para Mobile:
O desenvolvimento de aplicativos Android pode ser feito no Linux usando o Android Studio, que é uma IDE oficial fornecida pelo Google.
Uma forma open source de programar para Android sem depender das ferramentas oficiais do Google
é usando o projeto F-Droid em conjunto com ferramentas de desenvolvimento de código aberto.
Você pode usar o F-Droid para distribuir seus aplicativos Android de código aberto e também para descobrir e baixar outros aplicativos de código aberto para Android.
Gradle é uma ferramenta de compilação para construir aplicativos Android. Ele é de código aberto e você pode configurá-lo para compilar e empacotar seus aplicativos Android.
Embora não seja estritamente de código aberto, Genymotion é uma ferramenta popular de emulação Android que oferece uma versão gratuita para uso pessoal.
Você pode usá-lo para testar e depurar seus aplicativos Android no Linux.
Frameworks como Flutter (para desenvolvimento de aplicativos nativos) e React Native (para desenvolvimento de aplicativos multiplataforma) oferecem suporte ao desenvolvimento no Linux.
Para o desenvolvimento iOS, você pode configurar um ambiente de compilação remota em um Mac e usar ferramentas como SSH para se conectar e compilar seu código a partir do Linux.

Tipos de Linguagens
Compilador/Interpretador
Algumas linguagens de programação requerem um compilador para construir um aplicativo executável do código-fonte, enquanto outras usam um interpretador.
As linguagens interpretadas, o código-fonte é lido linha por linha e executado imediatamente pelo interpretador.
Para utilizar a interpretação, você escreve seu código na sintaxe da linguagem desejada utilizando um editor de texto, e então solicita ao interpretador que execute seu código como um script.
Por exemplo, se estiver trabalhando com Python, uma linguagem interpretada, você pode executar um script chamado meu_script.py utilizando o interpretador Python com o seguinte comando:
python meu_script.py
Aqui, python é o nome do interpretador Python.
Outras linguagens interpretadas, como Perl, Ruby e JavaScript, também possuem seus próprios interpretadores que podem ser chamados de maneira semelhante.
Para adquirir o básico necessário para utilizar uma linguagem de programação, é suficiente instalar o compilador ou o interpretador
Abaixo vou listar alguns dos interpretadores mais renomados disponíveis nos repositórios do Arch Linux para instalação:
Interpretação de código Python. sudo pacman -S python para pesquisar complementos pacman -Ss python
Interpretação de código Ruby. sudo pacman -S ruby para pesquisar complementos pacman -Ss ruby
Interpretação de código PHP. sudo pacman -S php para pesquisar complementos pacman -Ss php
Interpretação de código Perl. sudo pacman -S perl para pesquisar complementos pacman -Ss perl
Interpretação de código Lua. sudo pacman -S lua para pesquisar complementos pacman -Ss lua
Interpretação de código R. sudo pacman -S r para pesquisar complementos pacman -Ss r
Interpretação de código JavaScript usando o ambiente Node.js. sudo pacman -S nodejs para pesquisar complementos pacman -Ss nodejs
Esses complementos pode ser bibliotecas ou frameworks, pois dependendo da linguagem, você pode querer estender as funcionalidades da linguagem.
Essas bibliotecas geralmente são instaladas usando o gerenciador de pacotes da linguagem ou do Linux, ou através de sistemas de gerenciamento de pacotes de terceiros, como o python-pipx para Python ou o npm para Node.js.
Bibliotecas e Frameworks
As bibliotecas são conjuntos de funcionalidades que podem ser chamadas individualmente em um projeto, oferecendo controle direto sobre sua utilização.
Por outro lado, um framework pode "dominar" seu código, no sentido de que ele estabelece a estrutura e as convenções que você deve seguir ao desenvolver seu aplicativo.
Você está subordinado às decisões arquiteturais e aos padrões definidos pelo framework, o que pode influenciar significativamente a maneira como você escreve seu código.
Mas o framework simplifica o desenvolvimento.

Compilar linguagens no Linux
Compilar é o processo de transformar código-fonte em um programa executável.
Isso envolve o uso de um compilador, como o GCC (GNU Compiler Collection), que é uma ferramenta que compila uma variedade de linguagens de programação,
incluindo C, C++, Objective-C, Fortran, Ada, Go, D etc.
Python, por outro lado, é uma linguagem interpretada, o que significa que o código Python é executado diretamente pelo interpretador Python, sem a necessidade de compilação prévia para código de máquina. O GCC é usado para compilar somente aquelas linguagens que precisam de compilação.
Para compilar um programa usando o GCC no Linux, é fácil:
   Escreva seu código-fonte em um arquivo com a extensão apropriada para a linguagem que você está usando (por exemplo, .c para C, .cpp para C++).
   Abra um terminal e navegue até o diretório onde seu arquivo de código-fonte está localizado.
   Execute o comando de compilação, fornecendo o nome do arquivo de origem e o nome do arquivo de saída.
Por exemplo, para compilar um programa em C chamado meu_programa.c e gerar um arquivo executável chamado meu_programa, você pode usar o seguinte comando:
gcc meu_programa.c -o meu_programa

Algumas linguagens de programação compiladas dispensam o uso do GCC.
1. Linguagens puramente compiladas, como Rust (com o compilador rustc) e Haskell (utilizando o GHC), possuem suas próprias ferramentas de compilação.

2. Por outro lado, Java opera em uma Máquina Virtual Java (JVM) e é compilado através do seu próprio compilador, o javac.

3. Julia possui um compilador próprio integrado, conhecido como JIT (Just-In-Time). Isso significa que o código Julia é compilado dinamicamente, sob demanda, em tempo de execução.

4. Enquanto o Delphi é uma IDE e uma linguagem de programação de alto nível baseada em Object Pascal, muito usado no Windows.
O Free Pascal é uma linguagem multiplataforma bem mais ampla, sendo uma alternativa ao Delphi para usuários Linux.
A linguagem Free Pascal (FPC) oferece compatibilidade com código escrito em Turbo Pascal 7.0 e Delphi. O Lazarus é sua IDE, semelhante ao Delphi, projetada para Free Pascal. Assim como no Delphi essa linguagem é orientada a objetos, como classes, herança e polimorfismo. Quem já trabalhou com o Delphi, vai continuar tendo o designer de formulários visuais e depurador integrado.

Não importa onde você compile seu código, seja em uma IDE ou usando ferramentas de linha de comando, como o GCC direto do terminal.
Uma vez que seu código é compilado, você pode usar o terminal para executar seu programa e também interagir diretamente com ele, fornecendo entrada e analisando a saída.
Pelo terminal você pode depurar e analisar o seu desempenho, usa-lo dentro de algum scripts etc.

Existem outras ferramentas que podem ser úteis para simplificar o processo de compilação e gerenciamento de projetos maiores, como:

Make: é software livre para automatizar o processo de construção de programas a partir de seus arquivos fonte, reduzindo a necessidade de recompilar todo o programa a cada modificação. Ele utiliza um arquivo chamado makefile para determinar como gerar arquivos executáveis, o Make é específico para a plataforma em que é executado.

CMake: Tanto o CMake quanto o Make são ferramentas de construção de software, mas eles têm abordagens diferentes para compilação.
O CMake oferece uma simplificação na geração de sistemas de compilação para diferentes plataformas, tornando mais fácil para os desenvolvedores.
Ele usa arquivos CMakeLists.txt, que descrevem a estrutura do projeto, invés dos makefile do Make.

abrir foto:

Autotools: Um conjunto de ferramentas (como autoconf, automake e libtool) usadas para criar scripts de configuração e makefiles para projetos de software.

mk-configure: Ele oferece uma alternativa leve e eficiente às tradicionais ferramentas GNU Autotools, como autoconf, automake e libtool.
Uma das características principais do mk-configure é a sua abordagem declarativa para escrever Makefiles.
Em vez de especificar detalhadamente como construir o software, os desenvolvedores simplesmente listam os arquivos fonte, arquivos a serem construídos e, opcionalmente, opções de compilação. Isso torna o processo de construção mais simples e menos propenso a erros.

VOLTAR AO TOPO
VOLTAR AO ÍNDICE

VOLTAR AO ÍNDICE
 PRÓXIMA PÁGINA
man

Código:

man comando

+informações:

pwd

Código:

pwd

+informações:

cd

Código:

cd caminho

+informações:

ls

Código:

ls opções caminho

+informações:

df

Código:

df opções caminho

+informações:

du sort head

Código:

du opções caminho

+informações:

cp

Código:

cp opções origem1 origem2 destino

+informações:

mv

Código:

mv OPÇÕES ORIGEM DESTINO

+informações:

VOLTAR AO TOPO
VOLTAR AO ÍNDICE

VOLTAR AO ÍNDICE
 PRÓXIMA PÁGINA

VOLTAR AO TOPO
VOLTAR AO ÍNDICE

VOLTAR AO ÍNDICE
 PRÓXIMA PÁGINA
rm

Código:

rm opções arquivos ou diretórios

+informações:

file

Código:

file ARQUIVO

+informações:

iconv

Código:

iconv -f ENCODING_ORIGEM -t ENCODING_DESTINO [OPÇÕES] ARQUIVO_ORIGEM > ARQUIVO_DESTINO

+informações:

mkdir

Código:

mkdir caminho

+informações:

find

Código:

find caminho opções ações

+informações:

grep

Código:

grep opções padrão arquivo

+informações:

cat

Código:

cat opções arquivo.txt

+informações:

less

Código:

less arquivo.txt

+informações:

echo

Código:

echo opções texto

+informações:

nano

Código:

nano ~/Documentos

+informações:

vim

Código:

vim ~/Documentos

+informações:

wc

Código:

wc opções arquivo.txt

+informações:

touch

Código:

touch nome_do_arquivo

+informações:

nl

Código:

nl arquivo.txt

+informações:

sed

Código:

sed comando arquivo

+informações:

tr

Código:

tr opções conjunto_de_caracteres1 conjunto_de_caracteres2

+informações:

sort uniq tr cut awk

Código:

sort arquivo.txt

+informações:

shuf

Código:

shuf arquivo.txt

+informações:

rev

Código:

rev OPÇÕES ARQUIVO

+informações:

VOLTAR AO TOPO
VOLTAR AO ÍNDICE

VOLTAR AO ÍNDICE
 PRÓXIMA PÁGINA

VOLTAR AO TOPO
VOLTAR AO ÍNDICE

VOLTAR AO ÍNDICE
 PRÓXIMA PÁGINA
nohup

Código:

nohup comando opções

+informações:

top

Código:

top OPÇÕES RECURSO

+informações:

xxd

Código:

xxd OPÇÕES ARQUIVO

+informações:

curl

Código:

curl opções URL

+informações:

cut

Código:

cut opções delimitador campos arquivo

+informações:

head

Código:

head opções arquivo

+informações:

tail

Código:

tail opções arquivo

+informações:

VOLTAR AO TOPO
VOLTAR AO ÍNDICE

VOLTAR AO ÍNDICE
 PRÓXIMA PÁGINA

VOLTAR AO TOPO
VOLTAR AO ÍNDICE

VOLTAR AO ÍNDICE
 PRÓXIMA PÁGINA

Código:

x

+informações:

awk

Código:

awk 'BEGIN { print "Olá Mundo" } #'

+informações:

OpenSSL

Código:

openssl subcomando opções argumentos

+informações:

for

Código:

for i in valor1 valor2 ... do comandos done

+informações:

while

Código:

while condição; do comando; done

+informações:

sleep

Código:

comando | sleep 1m

+informações:

tee

Código:

comando | tee arquivo

+informações:

ln

Código:

ln opções origem destino

+informações:

date

Código:

x

+informações:

Código:

x

+informações:

cal = Mostra um calendário
ldd = fornece uma lista das bibliotecas que são dependências compartilhadas/dinâmicas entre programas. ldd /usr/bin/cal
true = Crie uma saída em branco (nada é exibido) nada acontece.
reboot = Reinicia
shutdown now = desliga
Tem um site, onde você digita os comandos, e ele diz sua função: link

Maior parte desse programas se encontra no pacote da GNU coreutils

abrir lista:

O site https://roadmap.sh disponibiliza guias para as principais linguagens de programação.
Você pode aproveitar esses guias para copiar os nomes das ferramentas necessárias para executá-las. Depois, basta fazer o download dessas ferramentas em seu sistema Linux.

VOLTAR AO TOPO
VOLTAR AO ÍNDICE

VOLTAR AO ÍNDICE
 PRÓXIMA PÁGINA

journalctl

Código:

journalctl parâmetro serviço

+informações:

VOLTAR AO TOPO
VOLTAR AO ÍNDICE

17