# Leitura e Manipulação

### Copiando Arquivos

Ao copiar arquivos, podemos utilizar a flag `-a` para manter todos os dados originais do arquivo.

```bash
cp -a <original_file> <new_file>
```

### Salvando Saída de um Comando em Diversos Arquivos

Todos os arquivos terão a mesma saída.

```bash
<command> | tee <file1> <file2> ... <file10>
```

### printf

Escrevendo no terminal cmo quebras de linha. Útil para colocar trechos de código em arquivos bash script.

```bash
printf 'Mensagem de teste

Conteúdo qualquer

Att,
'
```

###

### Cat

Esse é sem dúvidas um dos comandos mais utilizados (se não o mais) para ler arquivos.

Caso a saída do comando cat não tenha cores, pode utilizar os comandos abaixo para adicionar e depois utilize o comando `ccat` no lugar `cat`.

```bash
sudo apt install python-pygment
echo "alias ccat='pygmentize -g'" >> ~/.bashrc
source ~/.bashrc
```

\
Lê o arquivo e corta em pedaços onde tenha `:` (dois pontos) e pega a segunda (`-f2`) ocorrência

```bash
cat <arquivo.txt> | cut -d":" -f2
```

Mostra somente da linha 1 a 10

```bash
cat <file.txt> | cut -b 1-10
```

Exibe a primeira e a terceira ocorrência

```bash
cut -d <delimiter> -f1,3 <file>
```

Remove todas as letras `a`

```bash
cat <arquivo.txt> | tr -d "a"
```

Remove todas as letras `a` e `s`

```
cat <arquivo.txt> | tr -d "as"
```

Substitui tudo o que for `a` por `x`

```bash
cat <arquivo.txt> | tr "a" "x"
```

Mostra somente as linhas (e o número dessas linhas) que não estão em branco

```bash
cat -b <file>
```

Organiza a saída de um determinado arquivo com colunas utilizando `:` (dois pontos) como um delimitador

```bash
cat /etc/passwd | column -t -s:
```

Exibe o arquivo em uma linha única

```bash
cat <arquivo.txt> | tr -s '\n' ' '

# O mesmo que:
tr -s '\n' ' ' < <arquivo.txt>
```

Apesar do cat ser uma ferramenta para leitura de arquivos, nós também podemos escrever arquivos.

```
cat > <file.txt>
```

Após executar o comando acima, dê um `ENTER`, escreva o conteúdo que deseja salvar no arquivo, depois dê outro `ENTER` e então, `CTRL` + `C` para salvar.

### Tac

Semelhante ao `cat`, porém este lê o conteúdo de um arquivo começando do final

```
tac <file>
```

### Grep

Pesquisando strings em arquivos de forma recursiva

```bash
grep -irn <search_string>
```

> **EXPLICAÇÃO:**\
> **i** = Case Insensitive\
> **r** = Recursivo\
> **n** = Número da linha

Procurando por determinada string em um arquivo e mostra 3 linhas antes e 3 linhas depois da ocorrência encontrada

```bash
grep -A3 -B3 <find_string> <file>
```

Quebra um arquivo por espaço e organiza cada palavra em uma linha

```bash
grep -o -E '\w+' <file.txt>
```

Verifica todos os usuários que estão no grupo `sudo`

```bash
grep sudo /etc/group
```

Buscando todas as linhas que começam com a letra `m`

```bash
grep ^m <file>
```

Buscando todas as linhas que terminal com a letra s

```bash
grep s$ <file>
```

Lendo arquivo binário como se fosse um arquivo de text

```bash
grep -a <string> <file.bin>
```

Procurando por strings com 32 caracteres que possuem apenas letras e números

```bash
grep '[a-z0-9]\{32\}' <file.txt>
```

###

### Tee

#### Copiando Arquivos

```bash
tee <new_file> < <original_file>
```

#### Criando Arquivos com Conteúdo

```bash
echo <content> | tee -a <filename>
```

### Sponge

Modifica a saída de um determinado arquivo e salva o resultado nele mesmo. Caso precise, pode utilizar a saída de vários arquivos simultaneamente e enviar para um único arquivo ou até mesmo jogar saída de comandos, semelhante ao uso do **`>`**.

```bash
grep '<search>' <file> | sponge <file>
```

###

### Sort

Ordenando em ordem alfabética

```bash
sort <arquivo.txt>
```

Ordenando em ordem alfabética e removendo as linhas duplicadas

```bash
sort -u <arquivo.txt>
sort <arquivo.txt> | uniq
```

Mostra somente as linhas repetidas de um arquivo

```bash
sort <arquivo.txt> | uniq -cd
```

Conta a quantidade de linhas repetidas

```bash
# Do menor para o maior
sort <arquivo.txt> | uniq -c | sort -u

# Do maior para o menor
sort <arquivo.txt> | uniq -c | sort -ur
```

### Substring

Pega determinado caractere de uma string ou arquivo (em cada linha)

```bash
echo abcdef | cut -c 1   # a
echo abcdef | cut -c 3   # c
echo abcdef | cut -c 1,3 # ac
echo abcdef | cut -c 1-3 # abc
cat <file>  | cut -c 1
```

### Listando Palavras por Quantidade de Caracteres

No exemplo abaixo estamos lendo um arquivo e exibindo somente as palavras que contém 6 caracteres.

```bash
grep -o -w '\w\{6,6\}' <file.txt>
```

### Substituição de Caracteres

Substitui tudo o que for "espaço" por "XXX"

```bash
sed 's/<find>/<replace>/g' <file> > <output_file>
cat <arquivo.txt> | sed 's/ /XXX/g'
```

Substitui determinado caracter e já salva no arquivo

```bash
sed -i 's/<find>/<replace>/g' <file>
```

Adiciona um prefixo em todas as linhas e já salva no arquivo

```bash
sed -i 's/^/ABCD-/g' <file.txt>
```

Deixa todo o conteúdo de um arquivo em letras maiúsculas

```bash
tr [a-z] [A-Z] < <file.txt>
```

Substitui quebra de linha por espaço

```bash
sed ':a;N;$!ba;s/\n/ /g' file
```

### Range de Linhas

Leitura

```bash
sed -n <start_line>,<end_line>p <file>
```

Exclusão

```bash
sed <start_line>,<end_line>d <file>
```

#### wc

Exibe a quantidade de linhas que o arquivo possui

```bash
wc -l <file>
```

Exibe a quantidade de caracteres que o arquivo possui. Esse comando conta a quebra de linha como caracter, atente-se a isso

```bash
wc -c <file>
```

####

#### AWK

Mostra o conteúdo do arquivo, semelhante ao `cat`

```bash
awk '{print}' <arquivo.txt>
```

Quebra a linha por `:` (dois pontos) e retorna a segunda ocorrência. Por padrão (caso não passe o parâmetro `-F`, por default será um "espaço")

```bash
awk -F ':' '{print $2}' <arquivo.txt>
```

Retornando a primeira e a terceira ocorrência

```bash
awk -F':' '{print "O primeiro parâmetro é \"" $1 "\" e o terceiro parâmetro é \"" $3 "\""}' <file>
```

Quebra linha por `:` (dois pontos) , mas ao invés de mostrar os resultados linha a linha, este separa os resultados por vírgula

```bash
awk -F: '{print $1}' ORS=, </path/to/file>
```

Exibe qualquer linha que contenha a letra `f` (maiúscula ou minúscula) seguido da letra `e` (minúscula)

```bash
awk '/[f-F]e/' <arquivo.txt>
```

Quebra a linha por tudo que contenha `li` e pega a primeira e a segunda ocorrência. Remova `/li/` para que o `awk` pesquise automaticamente por espaços

```bash
awk '/li/ {print $1,$2;}' <arquivo.txt>
```

Pegando a última parte do print do awk

```bash
awk '{print $NF}'
```

Exibe somente palavras com mais de uma determinada quantidade de caracteres

```bash
awk 'length($0) > <qtde_caracteres>' <file.txt>
```

### Quantidade de Caracteres por Linha

```bash
awk 'length($0) >= <qtdade>' <file.txt>
```

### Removendo Linhas

Remove todas as linhas que tem determinada string

```bash
vi <file>
(esc) :g/<string>/d
```

### Head

Recuperando as primeiras linhas do arquivo (por padrão são 10)

```bash
head -n <qtde_de_linhas> <file>
head -<qtde_de_linhas> <file>
```

####

### Tail

Vendo modificações que estão sendo feitas em um arquivo em tempo real

```bash
tail -f <file>
```

Recuperando as últimas linhas do arquivo (por padrão são 10)

```bash
tail -n <qtde_de_linhas> <file>
tail -<qtde_de_linhas> <file>
```

### Watch

Semelhante ao `tail` com a opção `-f`.

```bash
watch -n 1 cat <file>
```

### Executando um Comando em Cada Linha do Arquivo

No exemplo abaixo, iremos ler um determinado arquivo e cada linha do arquivo será encodado em base64, que será salvo em um arquivo de saída

```bash
for i in $(cat <file.txt>); do echo $i | base64 ; done > <output.txt>
while IFS= read -r line; do echo -n "$line" | base64 ; done < <file.txt> > <output.txt>
cat <file.txt> | while read line ; do echo -n $line | base64 ; done
```

Ou podemos também criar um arquivo para realizar uma determinada operação. Para ver o resultado, execute da seguinte forma: ./file.sh \<file.txt>

```bash
#!/bin/bash
while read x ; do
    echo -n '$x' | base64
done < $1
```

### Random

Inserindo determinada quantidade de MB's em um arquivo

```bash
head -c 10M < /dev/urandom > <file>
```

Printando números aleatórios

```bash
# 1 número entre 1 e 10
shuf -i 0-10 -n 1

# 3 números entra 1 e 1000 
shuf -i 0-1000 -n 3
```

### Trabalhando com Loop

```bash
for x in $(cat <file.txt>) ; do echo "Line: $x" ; done
while true ; do echo "Hacked"; done
```

### Convertendo PDF

Ao executar o(s) comando(s) abaixo, será criado um arquivo com o mesmo nome, porém com a sua devida extensão já com os dados convertidos.

```bash
# Convertendo pdf em txt
pdftotext <file.pdf>

# Convertendo pdf em HTML
pdftohtml <file.pdf>
```

### Lendo Arquivos JSON

```bash
cat <file> | jq
cat <file> | python -mjson.tool
```

### Lendo Arquivos XML

```bash
curl -s http://site.com/sitemap.xml | xmllint --format -
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://mysther.gitbook.io/knowledge-base/sistemas-operacionais/linux/utilizacao/trabalhando-com-arquivos/leitura-e-manipulacao.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.