Sabrina - freeCodeCamp.org

O manual de comandos do Linux – aprenda comandos do Linux para iniciantes

Sabrina — Wed, 26 Jun 2024 21:00:00 +0000

Artigo original: The Linux Command Handbook – Learn Linux Commands for Beginners

Este manual de comandos do Linux apresentará os 60 comandos principais que você precisará como desenvolvedor. Cada comando inclui código de exemplo e dicas sobre quando usá-lo.

Este Manual de Comando do Linux segue a regra 80/20: você aprenderá 80% de um tópico em cerca de 20% do tempo gasto estudando-o.

Acho que essa abordagem oferece uma visão geral completa.

Este manual não tenta cobrir tudo relacionado ao Linux e seus comandos. Ele se concentra nos pequenos comandos principais que você usará 80% ou 90% do tempo e tenta simplificar o uso dos mais complexos.

Todos esses comandos funcionam em Linux, macOS, WSL e em qualquer lugar onde você tenha um ambiente UNIX.

Espero que o conteúdo deste manual o ajude a alcançar o que deseja: familiarizar-se com o Linux.

Você pode marcar esta página em seu navegador para poder consultar este manual no futuro.

Você pode fazer o download deste manual em PDF/ePUB/Mobi gratuitamente.

Aproveite!

Índice

Introdução ao Linux e shells

O que é Linux?

Linux é um sistema operacional, como o macOS ou Windows.

É também o sistema operacional de código aberto mais popular, oferecendo muita liberdade.

Ele alimenta a grande maioria dos servidores que compõem a Internet. É a base sobre a qual tudo é construído, mas não apenas isso. O Android é baseado em (uma versão modificada do) Linux.

O "núcleo" do Linux (chamado de kernel) nasceu em 1991 na Finlândia e percorreu um longo caminho desde seu início humilde. Passou a ser o kernel do Sistema Operacional GNU, criando a dupla GNU/Linux.

Há uma coisa no Linux que empresas como Microsoft, Apple e Google nunca poderão oferecer: a liberdade de fazer o que quiser com seu computador.

Na verdade, elas estão indo na direção oposta, construindo jardins murados, especialmente no lado dos dispositivos móveis.

Linux é a liberdade definitiva.

É desenvolvido por voluntários, alguns pagos por empresas que dependem dele, outros de maneira independente. Não existe, porém, uma única empresa comercial que possa ditar o que acontece no Linux ou as prioridades do projeto.

Você também pode usar o Linux como seu computador diário. Eu uso o macOS porque gosto muito das aplicações e do design (e também fui desenvolvedor de aplicações para iOS e Mac). Antes de usar o macOS, no entanto, eu usei o Linux como sistema operacional principal do meu computador.

Ninguém pode ditar quais aplicações você pode executar ou "ligar para casa" com aplicações que rastreiam você, sua posição e muito mais.

O Linux também é especial porque não existe apenas "um Linux", como é o caso do Windows ou do macOS. Em vez disso, temos distribuições.

Uma "distro" é feita por uma empresa ou organização e empacota o núcleo do Linux com programas e ferramentas adicionais.

Por exemplo, você tem o Debian, o Red Hat e o Ubuntu, provavelmente as distribuições mais populares.

Existem, porém, muitas, muitas mais. Você também pode criar sua própria distribuição, mas, provavelmente, usará uma popular que tenha muitos usuários e uma comunidade de pessoas ao seu redor. Isso permite que você faça o que precisa sem perder muito tempo reinventando a roda e descobrindo respostas para problemas comuns.

Alguns computadores desktop e laptops vêm com Linux pré-instalado. Você também pode instalá-lo em seu computador Windows ou Mac.

Você, no entanto, não precisa interromper seu computador existente apenas para ter uma ideia de como o Linux funciona.

Eu não tenho um computador Linux.

Se você usa um Mac, você só precisa saber que o macOS é um sistema operacional UNIX. Ele compartilha muitas das mesmas ideias e software que um sistema GNU/Linux usa, porque GNU/Linux é uma alternativa gratuita ao UNIX.

UNIX é um termo genérico que agrupa muitos sistemas operacionais usados em grandes corporações e instituições, a partir da década de 1970

O terminal do macOS dá acesso exatamente aos mesmos comandos que descreverei no restante deste manual.

A Microsoft tem um subsistema oficial do Windows para Linux que você pode (e deve!) instalar no Windows. Isso dará a você a capacidade de executar o Linux de uma maneira muito fácil em seu PC.

Na grande maioria das vezes, porém, você executará um computador Linux na nuvem por meio de um VPS (Virtual Private Server) como o DigitalOcean.

O que é um shell Linux?

Um shell é um interpretador de comandos que expõe uma interface para o usuário trabalhar com o sistema operacional subjacente.

Ele permite executar operações usando texto e comandos e fornece aos usuários recursos avançados, como a capacidade de criar scripts.

Isso é importante: os shells permitem que você execute as coisas de uma maneira mais otimizada do que uma GUI (Interface Gráfica do Usuário) poderia permitir. As ferramentas de linha de comando podem oferecer muitas opções de configuração diferentes sem serem muito complexas de usar.

Existem muitos tipos diferentes de shells. Este artigo se concentra em shells Unix, aqueles que você encontrará comumente em computadores Linux e macOS.

Muitos tipos diferentes de shells foram criados para esses sistemas ao longo do tempo. Alguns deles dominam o espaço: Bash, Csh, Zsh, Fish e muitos mais!

Todas os shells são originários de Bourne Shell, chamada sh. "Bourne" porque seu criador foi Steve Bourne.

Bash significa Bourne-again shell. O sh era proprietário e não de código aberto, e o Bash foi criado em 1989 para criar uma alternativa livre para o projeto GNU e a Free Software Foundation. Como os projetos tinham que pagar para usar o shell Bourne, o Bash se tornou muito popular.

Se você usa um Mac, tente abrir o terminal Mac. Por padrão, ele executa ZSH (ou, pré-Catalina, o Bash).

Você pode configurar seu sistema para executar qualquer tipo de shell – por exemplo, eu uso o shell Fish.

Cada shell tem seus próprios recursos exclusivos e uso avançado, mas todos compartilham uma funcionalidade comum: permitem executar programas e podem ser programados.

No restante deste manual, veremos em detalhes os comandos mais comuns que você utilizará.

O comando `man` no Linux

‌‌O primeiro comando que apresentarei ajudará você a entender todos os outros comandos.

Toda vez que não sei como usar um comando, digito man para obter o manual:

Esta é uma página man (de manual). As páginas de manual são uma ferramenta essencial para aprender como desenvolvedor. Elas contêm tanta informação que, às vezes, é quase demais. A captura de tela acima é apenas uma das 14 telas de explicação do comando ls .

Na maioria das vezes, quando preciso aprender um comando rapidamente, uso este site chamado páginas tldr: https://tldr.sh. É um comando que você pode instalar e executar assim: tldr . Ele fornece uma visão geral muito rápida de um comando, com alguns exemplos úteis de cenários de uso comuns:

Ele não é um substituto para o man, mas uma ferramenta útil para evitar de se perder na enorme quantidade de informações presentes em uma página man. Em seguida, você pode usar a página man para explorar todas as diferentes opções e parâmetros que você pode usar em um comando.

O comando `ls` no Linux

Dentro de uma pasta você pode listar todos os arquivos que a pasta contém usando o comando ls :

ls

‌Se você adicionar um nome ou caminho de pasta, o conteúdo dessa pasta será impresso:

ls /bin

O ls aceita muitas opções. Uma das minhas combinações favoritas é a -al. Tente:

ls -al /bin

Comparado ao comando ls simples, ele retorna muito mais informações.

Você tem, da esquerda para a direita:

as permissões de arquivo (e se o seu sistema suportar ACLs, você também receberá um sinalizador de ACL)
o número de links para esse arquivo
o dono do arquivo
o grupo do arquivo
o tamanho do arquivo em bytes
a data e hora da última modificação do arquivo
o nome do arquivo

Esse conjunto de dados é gerado pela opção l. A opção a também mostra os arquivos ocultos.

Arquivos ocultos são arquivos que começam com um ponto (.).

O comando `cd` no Linux

Depois de ter uma pasta, você pode movê-la usando o comando cd. cd significa alterar diretório (do inglês, change directory). Você o invoca especificando uma pasta para a qual mover. Você pode especificar um nome de pasta ou um caminho completo.

Exemplo:

mkdir fruits
cd fruits

‌ Agora, você está na pasta fruits.

Você pode usar o caminho especial .. para indicar a pasta pai:

cd .. #retorno à pasta pai

O caractere # indica o início do comentário, que dura toda a linha após ser encontrado.

Você pode usar o comando cd junto do caminho especial para formar um caminho:

mkdir fruits
mkdir cars
cd fruits
cd ../cars

Existe outro indicador de caminho especial, que é o ., que indica a pasta atual.

Você também pode usar caminhos absolutos, que começam na pasta raiz /:

cd /etc

O comando `pwd` no Linux

Sempre que você se sentir perdido no sistema de arquivos, chame o comando pwd para saber onde você está:

pwd

Ele imprimirá o caminho da pasta atual.

O comando `mkdir` no Linux

Você pode criar pastas usando o comando mkdir:

mkdir fruits

Você pode criar várias pastas com um comando:

mkdir dogs cars

Você também pode criar várias pastas aninhadas adicionando a opção -p:

mkdir -p fruits/apples

As opções nos comandos UNIX geralmente assumem esse formato. Você os adiciona logo após o nome do comando e eles mudam o comportamento do comando. Muitas vezes, você também pode combinar várias opções.

Você pode descobrir quais opções um comando suporta digitando man . Tente agora com man mkdir, por exemplo, (pressione a tecla q para sair da página de manual). As páginas de manual são a incrível ajuda integrada para UNIX.

O comando `rmdir` no Linux

Assim como você pode criar uma pasta usando mkdir, você pode excluir uma pasta usando rmdir:

mkdir fruits
rmdir fruits

Você também pode excluir várias pastas de uma vez:

mkdir fruits cars
rmdir fruits cars

‌ A pasta que você exclui deve estar vazia.

Para excluir pastas com arquivos, usaremos o comando rm mais genérico, que exclui arquivos e pastas, usando a opção -rf:

rm -rf fruits cars

Tenha cuidado, pois esse comando não pede confirmação e removerá imediatamente tudo o que você solicitar.

Não há bin ao remover arquivos da linha de comando e recuperar arquivos perdidos pode ser difícil.

O comando `mv` no Linux

Depois de ter um arquivo, você pode movê-lo usando o comando mv. Você especifica o caminho atual do arquivo e seu novo caminho:

touch test
mv pear new_pear

O arquivo pear é movido para new_pear. É assim que você renomeia arquivos e pastas.

Se o último parâmetro for uma pasta, o arquivo localizado no caminho do primeiro parâmetro será movido para essa pasta. Nesse caso, você pode especificar uma lista de arquivos e todos eles serão movidos no caminho da pasta identificado pelo último parâmetro:

touch pear
touch apple
mkdir fruits
mv pear apple fruits #pear e apple são movidos para a pasta fruits

O comando `cp` no Linux

Você pode copiar um arquivo usando o comando cp:

touch test
cp apple another_apple

Para copiar pastas você precisa adicionar a opção -r para copiar recursivamente todo o conteúdo da pasta:

mkdir fruits
cp -r fruits cars

‌O comando `open` no Linux

O comando open permite abrir um arquivo usando esta sintaxe:‌

open

Você também pode abrir um diretório, que no macOS abre o aplicativo Finder com o diretório atual aberto:

open

‌ Eu uso isso o tempo todo para abrir o diretório atual:

open .

O símbolo especial . aponta para o diretório atual, enquanto .. aponta para o diretório pai

O mesmo comando também pode ser usado para executar uma aplicação:

open

‌O comando `touch` no Linux

Você pode criar um arquivo vazio usando o comando touch:

touch apple

‌Se o arquivo já existir, ele será aberto no modo de gravação e o carimbo de data/hora do arquivo será atualizado.

O comando `find` no Linux

O comando find pode ser usado para localizar arquivos ou pastas que correspondam a um padrão de pesquisa específico. Ele pesquisa recursivamente.

Vamos aprender como usá-lo por meio de um exemplo.

Encontre todos os arquivos na árvore atual que possuem a extensão .js e imprima o caminho relativo de cada arquivo correspondente:

find . -name '*.js'

É importante usar aspas em torno de caracteres especiais como * para evitar que o shell os interprete.

Encontre diretórios na árvore atual que correspondam ao nome "src":

find . -type d -name src

Use -type f para pesquisar apenas arquivos ou -type l para pesquisar apenas links simbólicos.

-name diferencia maiúsculas de minúsculas. Use -iname para realizar uma pesquisa sem distinção entre maiúsculas e minúsculas.

Você pode pesquisar em várias árvores raiz:

find folder1 folder2 -name filename.txt

Encontre diretórios na árvore atual que correspondam ao nome "node_modules" ou 'public':

find . -type d -name node_modules -or -name public

Você também pode excluir um caminho da pesquisa usando -not -path:

find . -type d -name '*.md' -not -path 'node_modules/*'

Você pode pesquisar arquivos que contenham mais de 100 caracteres (bytes):

find . -type f -size +100c

Pesquise arquivos maiores que 100 KB, mas menores que 1 MB:

find . -type f -size +100k -size -1M

Pesquise arquivos editados há mais de 3 dias:

find . -type f -mtime +3

Pesquise arquivos editados nas últimas 24 horas:

find . -type f -mtime -1

Você pode excluir todos os arquivos que correspondem a uma pesquisa adicionando a opção -delete. Isso exclui todos os arquivos editados nas últimas 24 horas:

find . -type f -mtime -1 -delete

Você pode executar um comando em cada resultado da pesquisa. No exemplo, executamos cat para imprimir o conteúdo do arquivo:

find . -type f -exec cat {} \;

Observe a terminação \;. {} é preenchido com o nome do arquivo em tempo de execução.

O comando `ln` no Linux

O comando ln faz parte dos comandos do sistema de arquivos Linux.

É usado para criar links. O que é um link? É como um ponteiro para outro arquivo ou um arquivo que aponta para outro arquivo. Você deve estar familiarizado com os atalhos do Windows. Eles são semelhantes.

Temos 2 tipos de links: hard links e soft links.

Hard links

Hard links raramente são usados. Eles têm algumas limitações: você não pode vincular a diretórios e não pode vincular a sistemas de arquivos externos (discos).

Um hard link é criado usando a seguinte sintaxe:

ln

Por exemplo, digamos que você tenha um arquivo chamado recipes.txt (um arquivo de texto com receitas). Você pode criar um hard link para ele usando:

ln recipes.txt newrecipes.txt

O novo hard link que você criou é indistinguível de um arquivo normal:

Agora, sempre que você editar qualquer um desses arquivos, o conteúdo será atualizado para ambos.

Se você excluir o arquivo original, o link ainda conterá o conteúdo do arquivo original, pois ele não será removido até que haja um hard link apontando para ele.

Soft links

Soft links são diferentes. Eles são mais poderosos porque você pode vincular a outros sistemas de arquivos e diretórios. Lembre-se, porém, de que, quando o original for removido, o link será quebrado.

Você cria links virtuais usando a opção -s de ln:

ln -s

Por exemplo, digamos que você tenha um arquivo chamado recipes.txt. Você pode criar um soft link para ele usando:

ln -s recipes.txt newrecipes.txt

Nesse caso, você pode ver que há um sinalizador l especial ao listar o arquivo usando ls -al. O nome do arquivo tem um @ no final e também tem uma cor diferente se você tiver as cores ativadas:

‌‌Agora, se você excluir o arquivo original, os links serão quebrados e o shell informará "Esse arquivo ou diretório não existe" se você tentar acessá-lo:

O comando `gzip` no Linux

Você pode compactar um arquivo usando o protocolo de compactação gzip denominado LZ77 usando o comando gzip .

Aqui está o uso mais simples:

gzip filename

Isso compactará o arquivo e acrescentará uma extensão .gz a ele. O arquivo original é excluído.

Para evitar isso, você pode usar a opção -c e usar o redirecionamento de saída para gravar a saída no arquivo filename.gz :

gzip -c filename > filename.gz

‌A opção -c especifica que a saída estará no fluxo de saída padrão, deixando o arquivo original intacto.

Você também pode usar a opção -k:

gzip -k filename

Existem vários níveis de compressão. Quanto maior a compactação, mais tempo levará para compactar (e descompactar). Os níveis variam de 1 (compactação mais rápida e pior) a 9 (compactação mais lenta e melhor) e o padrão é 6.

Você pode escolher um nível específico com a opção: -:‌

gzip -1 filename

Você pode compactar vários arquivos listando-os:

gzip filename1 filename2

Você pode compactar todos os arquivos em um diretório, recursivamente, usando a opção -r :

gzip -r a_folder

A opção -v imprime as informações de porcentagem de compactação. Aqui está um exemplo de uso junto com a opção -k (keep):

gzip também pode ser usado para descompactar um arquivo, usando a opção -d :

gzip -d filename.gz

O comando `gunzip` no Linux

O comando gunzip basicamente equivalente ao comando gzip, exceto que a opção -d está sempre habilitada por padrão.

O comando pode ser invocado desta maneira:‌

gunzip filename.gz

Isso compactará e removerá a extensão .gz colocando o resultado no arquivo com filename . Se esse arquivo existir, ele será sobrescrito.

Você pode extrair para um nome de arquivo diferente usando o redirecionamento de saída usando a opção -c :

gunzip -c filename.gz > anotherfilename

O comando `tar` no Linux

O comando tar é usado para criar um arquivo, agrupando vários arquivos em um único arquivo.

Seu nome vem do passado e significa arquivo em fita (na época em que os arquivos eram armazenados em fitas – em inglês, Tape ARchive).

Este comando cria um arquivo chamado archive.tar com o conteúdo de file1 e file2:

tar -cf archive.tar file1 file2

‌ A opção c significa criar. A opção f é usada para gravar no arquivo.

Para extrair arquivos de um arquivo na pasta atual, use:

tar -xf archive.tar

A opção x significa extrair.

Para extraí-los para um diretório específico, use:

tar -xf archive.tar -C nome_do_diretório

Você também pode simplesmente listar os arquivos contidos em um arquivo:

tar é frequentemente usado para criar um arquivo compactado, compactando o arquivo.

Isso é feito usando a opção z :

tar -czf archive.tar.gz file1 file2

É como criar um arquivo tar e executar gzip nele.

Para desarquivar um arquivo compactado com gzip, você pode usar gunzip, ou gzip -d, e depois desarquivá-lo. tar -xf, no entanto, reconhecerá que é um arquivo compactado e fará isso por você:

tar -xf archive.tar.gz

O comando `alias` no Linux

É comum sempre executar um programa com um conjunto de opções que você gosta de usar.

Por exemplo, pegue o comando ls. Por padrão, imprime muito pouca informação:

‌ Se, no entanto, você usar a opção -al, imprimirá algo mais útil, incluindo a data de modificação do arquivo, o tamanho, o proprietário e as permissões. Ele também listará os arquivos ocultos (arquivos que começam com .):

Você pode criar um outro comando – por exemplo, gosto de chamá-lo de ll, que é um alias para ls -al.

Você faz assim:

alias ll='ls -al'

Depois de fazer isso, você pode chamar ll como se fosse um comando normal do UNIX:

Chamar alias sem qualquer opção listará os aliases definidos:

‌O alias funcionará até que a sessão do terminal seja fechada.

Para torná-lo permanente, você precisa adicioná-lo à configuração do shell. Pode ser ~/.bashrc ou ~/.profile ou ~/.bash_profile se você usar o shell Bash, dependendo do caso de uso.

Tenha cuidado com aspas se você tiver variáveis no comando: se você usar aspas duplas, a variável será resolvida no momento da definição. Se você usar aspas simples, ela será resolvida no momento da invocação. Os dois comandos abaixo são diferentes:

alias lsthis="ls $PWD"
alias lscurrent='ls $PWD'

$PWD refere-se à pasta atual em que o shell está. Se você navegar para uma nova pasta, lscurrent listará os arquivos na nova pasta, enquanto lsthis ainda listará os arquivos na pasta onde você estava quando definiu o alias.

O comando `cat` no Linux

Semelhante a tail em alguns aspectos, temos o cat. A diferença está no fato de que cat também pode adicionar conteúdo a um arquivo. Isso o torna superpoderoso.

Em seu uso mais simples, cat imprime o conteúdo de um arquivo na saída padrão:

cat file

Você pode imprimir o conteúdo de vários arquivos:

cat file1 file2

Usando o operador de redirecionamento de saída >, você pode concatenar o conteúdo de vários arquivos em um novo arquivo:

cat file1 file2 > file3

Usando >>, você pode anexar o conteúdo de vários arquivos em um novo arquivo, criando-o se ele não existir:

cat file1 file2 >> file3

Ao visualizar arquivos de código-fonte, é útil ver os números das linhas. Você pode fazer com que o cat os imprima usando a opção -n :

cat -n file1

Você só pode adicionar um número a linhas que não estejam em branco usando -b, ou também pode remover todas as múltiplas linhas vazias usando -s.

cat é frequentemente usado em combinação com o operador | para alimentar o conteúdo de um arquivo como entrada para outro comando: cat file1 | outro_comando.

O comando `less` no Linux

O comando less é um que eu uso muito. Ele mostra o conteúdo armazenado dentro de um arquivo, em uma interface de usuário agradável e interativa.

Use: less .

Quando estiver dentro de uma sessão less, você pode sair dela pressionando q.

Você pode navegar pelo conteúdo do arquivo usando as teclas das setas para cima e para baixo, ou usando a barra de espaço e b para navegar página por página. Você também pode pular para o final do arquivo pressionando G e voltar ao início pressionando g.

Você pode pesquisar o conteúdo do arquivo pressionando / digitando uma palavra para pesquisar. Isso busca adiante. Você pode pesquisar para trás usando o símbolo ? e digitando uma palavra.

Esse comando apenas visualiza o conteúdo do arquivo. Você pode abrir um editor diretamente pressionando v. Ele usará o editor do sistema, que, na maioria dos casos, é o vim.

Pressionar a tecla F entra no modo de acompanhamento ou modo de observação. Quando o arquivo é alterado por outra pessoa, como outro programa, você pode ver as alterações ao vivo.

Isso não acontece por padrão e você só vê a versão do arquivo no momento em que o abre. Você precisa pressionar ctrl-C para sair deste modo. Nesse caso, o comportamento é semelhante à execução do comando tail -f .

Você pode abrir vários arquivos e navegar por eles usando :n (para ir para o próximo arquivo) e :p (para ir para o anterior).

O comando `tail` no Linux

O melhor caso de uso de tail, na minha opinião, é quando chamado com a opção -f. Ele abre o arquivo no final e observa as alterações no arquivo.

Sempre que houver novo conteúdo no arquivo, ele será impresso na janela. Isso é ótimo para observar arquivos de log, por exemplo:

tail -f /var/log/system.log

Para sair, pressione a tecla ctrl-C.

Você pode imprimir as últimas 10 linhas de um arquivo:

tail -n 10

Você pode imprimir todo o conteúdo do arquivo começando em uma linha específica usando + antes do número da linha:

tail -n +10

tail pode fazer muito mais e, como sempre, meu conselho é verificar o man tail.

O comando `wc` no Linux

O comando wc nos fornece informações úteis sobre um arquivo ou entrada que ele recebe por meio de pipes.

echo test >> test.txt
wc test.txt
1       1       5 test.txt

‌Como exemplo por meio de pipes, podemos contar a saída da execução do comando ls -al :

ls -al | wc
6      47     284

A primeira coluna retornada é o número de linhas. O segundo é o número de palavras. O terceiro é o número de bytes.

Podemos dizer para apenas contar as linhas:

wc -l test.txt

ou apenas as palavras:

wc -w test.txt

apenas os bytes:

wc -c test.txt

Bytes em conjuntos de caracteres ASCII equivalem a caracteres. Com conjuntos de caracteres que não sejam ASCII, o número de caracteres pode ser diferente porque alguns caracteres podem ocupar vários bytes (por exemplo, isso acontece em Unicode).

Nesse caso, o sinalizador -m ajudará você a obter o valor correto:

wc -m test.txt

O comando `grep` no Linux

O comando grep é uma ferramenta muito útil. Quando você dominá-lo, ele o ajudará tremendamente na programação do dia a dia.

Se você está se perguntando, grep significa impressão de expressão regular global.

Você pode usar grep para pesquisar arquivos ou combiná-lo com pipes para filtrar a saída de outro comando.

Por exemplo, aqui está como podemos encontrar as ocorrências da linha document.getElementById no arquivo index.md:

grep -n document.getElementById index.md

‌ Usar a opção -n mostrará os números das linhas:‌

grep -n document.getElementById index.md

Uma coisa muito útil é dizer ao grep para imprimir 2 linhas antes e 2 linhas depois da linha correspondente para dar a ele mais contexto. Isso é feito usando a opção -C, que aceita várias linhas:

grep -nC 2 document.getElementById index.md

A pesquisa diferencia maiúsculas de minúsculas por padrão. Use o sinalizador -i para não diferenciar.

Conforme mencionado, você pode usar grep para filtrar a saída de outro comando. Podemos replicar a mesma funcionalidade acima usando:

less index.md | grep -n document.getElementById

A string de pesquisa pode ser uma expressão regular e isso torna o grep muito poderoso.

Outra coisa que você pode achar muito útil é inverter o resultado, excluindo as linhas que correspondem a uma string específica, usando a opção -v :

O comando `sort` no Linux

Suponha que você tenha um arquivo de texto que contém nomes de cachorros:

Essa lista não está ordenada.

O comando sort ajuda você a classificá-los por nome:

Use a opção r para reverter a ordem:

A classificação por padrão diferencia maiúsculas de minúsculas e é alfabética. Use a opção --ignore-case para classificar sem distinção entre maiúsculas e minúsculas e a opção -n para classificar usando uma ordem numérica.

Se o arquivo tiver linhas duplicadas:

Você pode usar a opção -u para removê-los:

sort não funciona apenas em arquivos, como muitos comandos UNIX fazem – ele também funciona com pipes. Portanto, você pode usá-lo na saída de outro comando. Por exemplo, você pode ordenar os arquivos retornados por ls com:

ls | sort

sort é muito poderoso e tem muito mais opções, que você pode explorar chamando man sort.

O comando `uniq` no Linux

uniq é um comando que ajuda a classificar linhas de texto.

Você pode obter essas linhas de um arquivo ou usar pipes da saída de outro comando:

uniq dogs.txt

ls | uniq

Você precisa considerar este ponto importante: o uniq detectará apenas linhas duplicadas adjacentes.

Isso implica que você provavelmente o usará junto com sort:

sort dogs.txt | uniq

O comando sort tem sua própria maneira de remover duplicatas com a opção -u (unique). Mas uniq tem mais poder.

Por padrão, ele remove linhas duplicadas:

Você pode instruí-lo para exibir apenas linhas duplicadas, por exemplo, com a opção -d :

sort dogs.txt | uniq -d

Você pode usar o comando -u para exibir apenas linhas não duplicadas:

Você pode contar as ocorrências de cada linha com a opção -c :

Use a combinação especial:

sort dogs.txt | uniq -c | sort -nr

Assim, você classificará essas linhas pelas mais frequentes:

O comando `diff` no Linux

diff é um comando útil. Suponha que você tenha 2 arquivos que contêm quase as mesmas informações, mas não consegue encontrar a diferença entre os dois.

diff processará os arquivos e dirá qual é a diferença.

Suponha que você tem dois arquivos: dogs.txt e moredogs.txt. A diferença é que moredogs.txt contêm mais um nome de cachorro:

diff dogs.txt moredogs.txt dirá que o segundo arquivo tem mais uma linha, a linha 3 com o nome Vanille:

Se você inverter a ordem dos arquivos, será informado que falta a linha 3 no segundo arquivo, cujo conteúdo é Vanille:

Usar a opção -y vai comparar os 2 arquivos linha por linha:

A opção -u entretanto, será mais familiar para você, porque é a mesma usada pelo sistema de controle de versão Git para exibir diferenças entre versões:

A comparação de diretórios funciona da mesma maneira. Você deve usar a opção -r para comparar recursivamente (entrando em subdiretórios):

Caso você esteja interessado em quais arquivos diferem, e não no conteúdo, use as opções r e q :

Existem muitas outras opções que você pode explorar na página de manual executando man diff:

O comando `echo` no Linux

O comando echo faz um trabalho simples: imprime na saída o argumento passado para ele.

Esse exemplo:

echo "hello"

Isso imprimirá hello no terminal.

Podemos anexar a saída a um arquivo:

echo "hello" >> output.txt

Podemos interpolar variáveis de ambiente:

echo "The path variable is $PATH"

Cuidado, pois os caracteres especiais precisam ser escapados com uma barra invertida \. $ por exemplo:

Este é apenas o começo. Podemos fazer algumas coisas legais quando se trata de interagir com os recursos do shell.

Podemos repetir os arquivos na pasta atual:

echo *

Podemos repetir os arquivos da pasta atual que começam com a letra o:

echo o*

Qualquer comando e recurso válido do Bash (ou qualquer shell que você esteja usando) pode ser usado aqui.

Você pode imprimir o caminho da sua pasta pessoal:

echo ~

Você também pode executar comandos e imprimir o resultado na saída padrão (ou em arquivo, como você viu):

echo $(ls -al)

Observe que os espaços em branco não são preservados por padrão. Você precisa colocar o comando entre aspas duplas para fazer isso:

Você pode gerar uma lista de strings, por exemplo, intervalos:

echo {1..5}

O comando `chown` no Linux

Cada arquivo/diretório em um sistema operacional como Linux ou macOS (e todo sistema UNIX em geral) tem um proprietário.

O proprietário de um arquivo pode fazer tudo com ele. Pode decidir o destino desse arquivo.

O proprietário (e o usuário root ) também pode alterar o proprietário para outro usuário, usando o comando chown:

chown

Assim:

chown flavio test.txt

‌Por exemplo, se você tiver um arquivo que pertence ao root, você não poderá escrever nele como outro usuário:

Você pode usar chown para transferir a propriedade para você:

É bastante comum precisar alterar a propriedade de um diretório e recursivamente de todos os arquivos contidos, além de todos os subdiretórios e arquivos contidos neles também.

Você pode fazer isso usando o sinalizador -R :

chown -R

Arquivos/diretórios não têm apenas um proprietário. Eles também têm um grupo. Através deste comando, você pode alterar isso simultaneamente enquanto altera o proprietário:

chown :

Exemplo:

chown flavio:users test.txt

Você também pode alterar o grupo de um arquivo usando o comando chgrp:

chgrp

O comando `chmod` no Linux

Cada arquivo nos sistemas operacionais Linux/macOS (e sistemas UNIX em geral) possui 3 permissões: leitura, gravação e execução.

Vá para uma pasta e execute o comando ls -al.

As strings estranhas que você vê em cada linha de arquivo, como drwxr-xr-x, definem as permissões do arquivo ou pasta.

Vamos dissecá-lo.

A primeira letra indica o tipo de arquivo:

- significa que é um arquivo normal
d significa que é um diretório
l significa que é um link

Então você tem 3 conjuntos de valores:

O primeiro conjunto representa as permissões do proprietário do arquivo
O segundo conjunto representa as permissões dos membros do grupo ao qual o arquivo está associado
O terceiro conjunto representa as permissões de todos os outros

Esses conjuntos são compostos por 3 valores. rwx significa que uma pessoa específica tem acesso de leitura (r, de read em inglês), gravação (w, de write em inglês) e execução (de eXecute em inglês). Qualquer coisa removida é trocada por -, que permite formar várias combinações de valores e permissões relativas: rw-, r--, r-x, e assim por diante.

Você pode alterar as permissões concedidas a um arquivo usando o comando chmod.

chmod pode ser usado de 2 maneiras. O primeiro usa argumentos simbólicos, o segundo usa argumentos numéricos. Vamos começar primeiro com os símbolos, o que é mais intuitivo.

Você digita chmod seguido por um espaço e uma letra:

a significa tudo
u significa usuário
g significa grupo
o significa outros

Em seguida, você digita + ou - para adicionar uma permissão ou removê-la. Em seguida, você insere um ou mais símbolos de permissão (r, w, x).

Tudo seguido do nome do arquivo ou pasta.

Aqui estão alguns exemplos:

chmod a+r nome_do_arquivo #todos podem ler
chmod a+rw nome_do_arquivo #todos podem ler e gravar
chmod o-rwx nome_do_arquivo #outros (que não sejam o proprietário, que não estejam no mesmo grupo do arquivo) não têm permissão de ler, gravar ou executar o arquivo

‌ Você pode aplicar as mesmas permissões a várias personas adicionando várias letras antes do +/-:

chmod og-r nome_do_arquivo #outros e grupo não podem mais ler

‌Caso esteja editando uma pasta, você pode aplicar as permissões a todos os arquivos contidos nessa pasta usando o sinalizador -r (recursivo).

Argumentos numéricos são mais rápidos, mas acho difícil lembrá-los quando você não os usa no dia a dia. Você usa um algarismo que representa as permissões da persona. Este valor numérico pode ser no máximo 7 e é calculado da seguinte forma:

1 se tiver permissão de execução
2 se tiver permissão de gravação
4 se tiver permissão de leitura

Isso nos dá 4 combinações:

0 Nenhuma permissão
1 pode executar
2 pode escrever
3 pode escrever, executar
4 pode ler
5 pode ler, executar
6 pode ler e escrever
7 pode ler, escrever e executar

Nós os usamos em grupos de 3, para definir as permissões de todos os 3 grupos ao todo:

chmod 777 nome_do_arquivo
chmod 755 nome_do_arquivo
chmod 644 nome_do_arquivo

O comando `umask` no Linux

Ao criar um arquivo, você não precisa decidir as permissões antecipadamente. As permissões têm padrões.

Esses padrões podem ser controlados e modificados usando o comando umask .

Digitar umask sem argumentos mostrará o umask, atual, neste caso 0022:

O que 0022 significa? Esse é um valor octal que representa as permissões.

Outro valor comum é 0002.

Use umask -S para ver uma notação legível por humanos:

Neste caso, o usuário (u), proprietário do arquivo, possui permissões de leitura, escrita e execução nos arquivos.

Os demais usuários pertencentes ao mesmo grupo (g) possuem permissão de leitura e execução, igual a todos os demais usuários (o).

Na notação numérica, normalmente alteramos os últimos 3 dígitos.

Aqui está uma lista que dá um significado ao número:

0 ler, escrever, executar
1 ler e escrever
2 ler e executar
3 somente leitura
4 escrever e executar
5 escrever apenas
6 executar apenas
7 nenhuma permissão

Observe que esta notação numérica difere daquela que usamos em chmod.

Podemos definir um novo valor para a máscara definindo o valor em formato numérico:

umask 002

ou você pode alterar a permissão de uma função específica:

umask g+r

O comando `du` no Linux

O comando du calculará o tamanho de um diretório como um todo:

du

O número 32 aqui é um valor expresso em bytes.

Rodar du * calculará o tamanho de cada arquivo individualmente:

Você pode definir du para exibir valores em MegaBytes, usando du -m, e GigaBytes, usando du -g.

A opção -h mostrará uma notação legível para tamanhos, adaptando-se ao tamanho:

Adicionar a opção -a também imprimirá o tamanho de cada arquivo nos diretórios:

Uma coisa útil é classificar os diretórios por tamanho:

du -h  | sort -nr

‌Em seguida, use head para obter apenas os 10 primeiros resultados:

O comando `df` no Linux

O comando df é usado para obter informações de uso do disco.

Em sua forma básica, ele imprimirá informações sobre os volumes montados:

Usar a opção -h (df -h) mostrará esses valores em um formato legível:

Você também pode especificar um nome de arquivo ou diretório para obter informações sobre o volume específico em que ele reside:

O comando `basename` no Linux

Suponha que você tenha um caminho para um arquivo, por exemplo /Users/flavio/test.txt.

Rodar

basename /Users/flavio/test.txt

retornará a string test.txt:

Se você executar basename em uma string de caminho que aponta para um diretório, obterá o último segmento do caminho. Neste exemplo, /Users/flavio é um diretório:

O comando `dirname` no Linux

Suponha que você tenha um caminho para um arquivo, por exemplo /Users/flavio/test.txt.

Rodar

dirname /Users/flavio/test.txt

retornará a string /Users/flavio:

O comando `ps` no Linux

Seu computador está executando vários processos diferentes o tempo todo.

Você pode inspecionar todos eles usando o comando ps:

Essa é a lista de processos iniciados pelo usuário em execução na sessão atual.

Aqui eu tenho algumas instâncias de fish shell, a maioria abertas pelo VS Code dentro do editor, e uma instância de Hugo executando a visualização de desenvolvimento de um site.

Esses são apenas os comandos atribuídos ao usuário atual. Para listar todos os processos precisamos passar algumas opções para os ps.

O mais comum que eu uso é o ps ax:

O opção a também é usada para listar os processos de outros usuários, não apenas os seus. x mostra processos não vinculados a nenhum terminal (não iniciados pelos usuários através de um terminal).

Como você pode ver, os comandos mais longos são cortados. Use o comando ps axww para continuar a listagem de comandos em uma nova linha em vez de cortá-la:

Precisamos especificar w 2 vezes para aplicar esta configuração (não é um erro de digitação).

Você pode procurar um processo específico combinando grep com um pipe, assim:

ps axww | grep "Visual Studio Code"

As colunas retornadas por ps representam algumas informações importantes.

A primeira informação é o PID, o ID do processo. Isso é fundamental quando você deseja fazer referência a esse processo em outro comando, por exemplo, para eliminá-lo.

Então temos TT que nos informa o ID do terminal usado.

Então STAT nos informa o estado do processo:

I um processo que está ocioso (suspenso por mais de 20 segundos)‌‌R um processo executável‌‌S um processo que está dormindo por menos de 20 segundos‌‌T um processo parado‌‌U um processo em espera ininterrupto‌‌Z um processo morto (um zumbi)

Se você tiver mais de uma carta, a segunda representa mais informações, que podem ser muito técnicas.

É comum ter + que indica que o processo está em primeiro plano no seu terminal. s significa que o processo é um líder de sessão.

TIME nos diz há quanto tempo o processo está em execução.

O comando `top` no Linux

O comando top é usado para exibir informações dinâmicas em tempo real sobre os processos em execução no sistema.

É muito útil entender o que está acontecendo.

Seu uso é simples – basta digitar top e o terminal ficará totalmente imerso nesta nova visualização:

O processo é demorado. Para sair, você pode digitar a letra q ou ctrl-C.

Muitas informações nos são fornecidas: o número de processos, quantos estão em execução ou em suspensão, a carga do sistema, o uso da CPU e muito mais.

Abaixo, a lista de processos que ocupam mais memória e CPU é constantemente atualizada.

Por padrão, como você pode ver na coluna %CPU destacada, eles são classificados pela CPU usada

Você pode adicionar um sinalizador para classificar os processos pela memória utilizada:

top -o mem

O comando `kill` no Linux

Os processos do Linux podem receber sinais e reagir a eles.

Essa é uma maneira de interagirmos com programas em execução.

O programa kill pode enviar uma variedade de sinais para um programa.

Não é usado apenas para encerrar um programa, como o nome sugere, mas essa é sua função principal.

Nós o usamos desta maneira:

kill

Por padrão, isso envia o sinal TERM para o ID do processo especificado.

Podemos usar sinalizadores para enviar outros sinais, incluindo:

kill -HUP 
kill -INT 
kill -KILL 
kill -TERM 
kill -CONT 
kill -STOP

‌HUP significa desligar. É enviado automaticamente quando uma janela de terminal que iniciou um processo é fechada antes de encerrar o processo.

INT significa interrupção e envia o mesmo sinal usado quando pressionamos ctrl-C no terminal, o que geralmente encerra o processo.

KILL não é enviado para o processo, mas para o kernel do sistema operacional, que imediatamente interrompe e finaliza o processo.

TERM significa terminar. O processo vai receber esse sinal e terminar sozinho. É o sinal padrão enviado por kill.

CONT significa continuar. Pode ser usado para retomar um processo interrompido.

STOP não é enviado para o processo, mas para o kernel do sistema operacional, que interrompe imediatamente (mas não encerra) o processo.

Você pode ver números usados, como kill -1 . Nesse caso,

1 corresponde ao HUP.‌‌2 corresponde ao INT.‌‌9 corresponde ao KILL.‌‌15 corresponde ao TERM.‌‌18 corresponde ao CONT.‌‌15 corresponde ao STOP.

O comando `killall` no Linux

Semelhante ao comando kill, killall enviará o sinal para vários processos ao mesmo tempo, em vez de enviar um sinal para um ID de processo específico.

Essa é a sintaxe:‌

killall

Aqui, nome é o nome de um programa. Por exemplo, você pode ter várias instâncias do programa top em execução. killall top encerrará todas elas.

Você pode especificar o sinal, como acontece com kill (e verifique o tutorial kill para ler mais sobre os tipos específicos de sinais que podemos enviar), por exemplo:

killall -HUP top

O comando `jobs` no Linux

Quando executamos um comando no Linux/macOS, podemos configurá-lo para execução em segundo plano usando o símbolo & após o comando.

Por exemplo, podemos executar top em segundo plano:

top &

Isso é muito útil para programas de longa duração.

Podemos voltar a esse programa usando o comando fg. Isso funciona bem se tivermos apenas um trabalho em segundo plano, caso contrário, precisaremos usar o número do trabalho: fg 1, fg 2 e assim por diante.

Para obter o número do trabalho, usamos o comando jobs.

Digamos que executemos top & e então top -o mem &. Temos 2 instâncias principais em execução. jobs nos mostrará isso:

Agora, podemos voltar para um daqueles que usam fg . Para parar o programa novamente podemos clicar em cmd-Z.

Executar jobs -l também imprimirá o ID do processo de cada trabalho.

O comando `bg` no Linux

Quando um comando está em execução, você pode suspendê-lo usando ctrl-Z.

O comando interromperá imediatamente e você retornará ao terminal shell.

Você pode retomar a execução do comando em segundo plano, para que ele continue em execução, mas não o impeça de realizar outros trabalhos no terminal.

Neste exemplo, tenho 2 comandos parados:

Posso executar o bg 1 para retomar em segundo plano a execução do job nº 1.

Eu também poderia ter dito bg sem nenhuma opção, pois o padrão é escolher job nº 1 da lista.

O comando `fg` no Linux

Quando um comando está sendo executado em segundo plano, porque você o iniciou com & no final (exemplo: top &) ou porque você o colocou em segundo plano (com o comando bg), você pode colocá-lo em primeiro plano usando fg.

Executar

fg

retomará em primeiro plano o último trabalho que foi suspenso.

Você também pode especificar qual trabalho deseja retomar para primeiro plano passando o número do trabalho, que pode ser obtido usando o comando jobs.

Executar fg 2 retomará o job nº 2:

O comando `type` no Linux

Um comando pode ser um destes 4 tipos:

um executável
um programa embutido no shell
uma função shell
um apelido

O comando type pode ajudar a descobrir isso, caso queiramos saber ou estejamos apenas curiosos. Ele dirá como o comando será interpretado.

A saída dependerá do shell usado. Este é o Bash:

Este é o Zsh:

Este é o Fish:

Uma das coisas mais interessantes aqui é que, para aliases, ele dirá para que serve o alias. Você pode ver o ll alias, no caso de Bash e Zsh, mas o Fish o fornece por padrão, então ele dirá que é uma função interna do shell.

O comando `which` no Linux

Suponha que você tenha um comando que pode executar porque está no caminho do shell, mas deseja saber onde ele está localizado.

Você pode fazer isso usando which. O comando retornará o caminho para o comando especificado:

which funcionará apenas para executáveis armazenados em disco, não para aliases ou funções de shell integradas.

O comando `nohup` no Linux

Às vezes, você precisa executar um processo de longa duração em uma máquina remota e depois desconectar.

Ou você, simplesmente, deseja evitar que o comando seja interrompido se houver algum problema de rede entre você e o servidor.

A maneira de executar um comando mesmo depois de efetuar logout ou fechar a sessão em um servidor é usar o comando nohup.

Use nohup para permitir que o processo continue funcionando mesmo depois de você sair.

O comando `xargs` no Linux

O comando xargs é usado em um shell UNIX para converter a entrada padrão em argumentos para um comando.

Em outras palavras, através do uso de xargs, a saída de um comando é usada como entrada de outro comando.

Aqui está a sintaxe que você usará:

comando1 | xargs comando2

Usamos um pipe (|) para passar a saída para xargs. Isso cuidará da execução do comando comando2, usando a saída de comando1 como seu(s) argumento(s).

Vamos fazer um exemplo simples. Você deseja remover alguns arquivos específicos de um diretório. Esses arquivos estão listados dentro de um arquivo de texto.

Temos 3 arquivos: file1, file2, file3.

No todelete.txt temos uma lista de arquivos que queremos excluir, neste exemplo file1 e file3:

Vamos canalizar a saída de cat todelete.txt para o comando rm, através de xargs, assim:

cat todelete.txt | xargs rm

Esse é o resultado, os arquivos que listamos agora foram excluídos:

A forma como funciona é que xargs executará rm 2 vezes, uma para cada linha retornada por cat.

Este é o uso mais simples de xargs. Existem várias opções que podemos usar.

Um dos mais úteis, na minha opinião (especialmente quando se começa a aprender xargs), é -p. Usar esta opção fará com que o xargs imprima um prompt de confirmação com a ação que será executada:

A opção -n permite que você diga ao xargs para realizar uma iteração por vez, para que você possa confirmá-las individualmente com -p. Aqui dizemos ao xargs para realizar uma iteração por vez com -n1:

A opção -I é outra amplamente utilizada. Ela permite que você coloque a saída em um espaço reservado e, então, você pode fazer várias coisas.

Uma delas é executar vários comandos:

comando1 | xargs -I % /bin/bash -c 'comando2 %; comando3 %

Você pode trocar o símbolo % que usei acima por qualquer outra coisa – é uma variável.

O comando do editor `vim` no Linux

vim é um editor de arquivos muito popular, especialmente entre programadores. Ele é desenvolvido ativamente e atualizado com frequência, e há uma grande comunidade em torno dele. Há até uma conferência sobre o Vim!

vi em sistemas modernos é apenas um apelido para vim, que significa que vim melhorou.

Você inicia executando o vi na linha de comando.

Você pode especificar um nome de arquivo no momento da chamada para editar esse arquivo específico:

vi test.txt

Você deve saber que o Vim possui 2 modos principais:

modo de comando (ou normal)
modo de inserção

Ao iniciar o editor, você está no modo de comando. Você não pode inserir texto como espera de um editor baseado em GUI. Você tem que entrar no modo de inserção.

Você pode fazer isso pressionando a tecla i. Depois de fazer isso, a palavra -- INSERT -- aparece na parte inferior do editor:

Agora, você pode começar a digitar e preencher a tela com o conteúdo do arquivo:

Você pode mover-se pelo arquivo com as teclas de seta ou usando as teclas h - j - k - l. h-l para esquerda e direita, j-k para baixo e para cima.

Quando terminar de editar, você pode pressionar a tecla esc para sair do modo de inserção e voltar ao modo de comando.

Neste ponto, você pode navegar no arquivo, mas não pode adicionar conteúdo a ele (e tome cuidado com as teclas que você pressiona, pois podem ser comandos).

Uma coisa que você pode querer fazer agora é salvar o arquivo. Você pode fazer isso pressionando: (dois pontos) e w.

Você pode salvar e sair pressionando :, w e q: :wq

Você pode sair sem salvar pressionando :, q e !: :q!

Você pode desfazer e editar acessando o modo de comando e pressionando u. Você pode refazer (cancelar um desfazer) pressionando ctrl-r.

Esses são os princípios básicos para trabalhar com o Vim. A partir daqui começa uma infinitude de informações na qual não podemos entrar nesta pequena introdução.

Mencionarei apenas os comandos que ajudarão você a começar a editar com o Vim:

pressionar a tecla x exclui o caractere atualmente destacado
pressionar A vai para o final da linha atualmente selecionada
pressionar 0 para ir para o início da linha
ir para o primeiro caractere de uma palavra e pressionar d seguido de w para excluir essa palavra. Se você seguir com e em vez de w, o espaço em branco antes da próxima palavra será preservado
usar um número entre d e w para excluir mais de 1 palavra – por exemplo, usar d3w para excluir 3 palavras adiante
pressionar d seguido de d para excluir uma linha inteira. Pressionar d seguido de $ para deletar toda a linha de onde está o cursor, até o final

Para saber mais sobre o Vim, recomendo o FAQ do Vim (em inglês). Você também pode executar o comando vimtutor, que já deve estar instalado em seu sistema e o ajudará muito a iniciar a exploração do vim.

O comando do editor `emacs` no Linux

emacs é um editor incrível e é historicamente considerado o editor de sistemas UNIX. Notoriamente, as guerras violentas entre vi e emacs e discussões acaloradas causaram muitas horas improdutivas para desenvolvedores em todo o mundo.

emacs é muito poderoso. Algumas pessoas usam esse editor o dia todo como uma espécie de sistema operacional (https://news.ycombinator.com/item?id=19127258). Falaremos apenas sobre o básico aqui.

Você pode abrir uma nova sessão do emacs simplesmente invocando emacs:

Usuários do macOS, parem um segundo agora. Se você estiver no Linux, não há problemas, mas o macOS não fornece aplicativos que usam GPLv3 e todos os comandos integrados do UNIX que foram atualizados para GPLv3 não foram atualizados.‌‌‌‌Embora haja um pequeno problema com os comandos que listei até agora, neste caso, usar uma versão do emacs de 2007 não é exatamente o mesmo que usar uma versão com 12 anos de melhorias e mudanças.‌‌‌‌Esse não é um problema com o Vim, que está atualizado. Para corrigir isso, execute brew install emacs e a execução do emacs usará a nova versão do Homebrew (certifique-se de ter o Homebrew instalado).

Você também pode editar um arquivo existente chamando emacs :

Agora, você pode começar a editar. Quando terminar, pressione ctrl-x seguido de ctrl-w. Você confirma a pasta:

O Emacs informa que o arquivo existe, perguntando se ele deve ser sobrescrito:

Responda y e você receberá uma confirmação de sucesso:

Você pode sair do Emacs pressionando ctrl-x seguido de ctrl-c.‌‌Como opção, use ctrl-x seguido de c (mantenha ctrl pressionado).

Há muito para saber sobre o Emacs, certamente mais do que sou capaz de escrever nesta pequena introdução. Eu encorajo você a abrir o Emacs e pressionar ctrl-h r para abrir o manual integrado e ctrl-h t para abrir o tutorial oficial.

O comando do editor `nano` no Linux

nano é um editor amigável para iniciantes.

Execute-o usando nano .

Você pode digitar caracteres diretamente no arquivo sem se preocupar com os modos.

Você pode sair sem editar usando ctrl-X. Se você editou o buffer do arquivo, o editor solicitará sua confirmação e você poderá salvar as edições ou descartá-las.

A ajuda na parte inferior mostra os comandos do teclado que permitem trabalhar com o arquivo:

pico é mais ou menos igual, embora nano é a versão GNU do pico que em algum momento da história não era de código aberto. O nano clone foi feito para satisfazer os requisitos de licença do sistema operacional GNU.

O comando `whoami` no Linux

Digite whoami para imprimir o nome do usuário atualmente conectado à sessão do terminal:

Observação: esse comando é diferente do comando who am i, que imprime mais informações

O comando `who` no Linux

O comando who exibe os usuários logados no sistema.

A menos que você esteja usando um servidor ao qual várias pessoas têm acesso, é provável que você seja o único usuário conectado, várias vezes:

Por que várias vezes? Porque cada shell aberto contará como um acesso.

Você pode ver o nome do terminal utilizado e a hora/dia em que a sessão foi iniciada.

Os sinalizadores -aH dirão who exibirá mais informações, incluindo o tempo ocioso e o ID do processo do terminal:

O comando especial who am i listará os detalhes atuais da sessão do terminal:

O comando `su` no Linux

Enquanto você estiver conectado ao shell do terminal com um usuário, pode ser necessário mudar para outro usuário.

Por exemplo, você está logado como root para realizar alguma manutenção, mas deseja mudar para uma conta de usuário.

Você pode fazer isso com o comando su:

su

Por exemplo: su flavio.

Se você estiver logado como usuário, executar su sem mais nada solicitará que você insira a senha do usuário root, pois esse é o comportamento padrão.

su iniciará um novo shell como outro usuário.

Quando terminar, digitar exit no shell fechará esse shell e retornará ao shell do usuário atual.

O comando `sudo` no Linux

sudo é comumente usado para executar um comando como root.

Você deve estar habilitado para usar o sudo e, quando estiver, poderá executar comandos como root digitando a senha do seu usuário (não a senha do usuário root).

As permissões são altamente configuráveis, o que é ótimo especialmente em um ambiente de servidor multiusuário. Alguns usuários podem ter acesso para executar comandos específicos por meio de sudo.

Por exemplo, você pode editar um arquivo de configuração do sistema:

sudo nano /etc/hosts

De outra forma, isso não seria salvo, pois você não tem a permissão para isso.

Você pode executar sudo -i para iniciar um shell como root:

Você pode usar sudo para executar comandos como qualquer usuário. root é o padrão, mas use a opção -u para especificar outro usuário:

sudo -u flavio ls /Users/flavio

O comando `passwd` no Linux

Os usuários do Linux têm uma senha atribuída. Você pode alterar a senha usando o comando passwd.

Existem duas situações aqui.

A primeira é quando você deseja alterar sua senha. Neste caso, você digita:

passwd

e um prompt interativo solicitará a senha antiga e, em seguida, solicitará a nova:

Quando você é root (ou tem privilégios de superusuário), você pode definir o nome de usuário para o qual deseja alterar a senha:

passwd

Neste caso, você não precisa inserir a antiga.

O comando `ping` no Linux

O comando ping faz ping em um host de rede específico, na rede local ou na Internet.

Você o usa com a sintaxe ping , onde pode ser um nome de domínio ou um endereço IP.

Aqui está um exemplo de ping google.com:

O comando envia uma solicitação ao servidor e o servidor retorna uma resposta.

ping continua enviando a solicitação a cada segundo, por padrão. Ele continuará funcionando até você pará-lo com ctrl-C, a menos que você passe o número de vezes que deseja tentar com a opção -c: ping -c 2 google.com.

Assim que o ping for interrompido, ele imprimirá algumas estatísticas sobre os resultados: a porcentagem de pacotes perdidos e estatísticas sobre o desempenho da rede.

Como você pode ver, a tela imprime o endereço IP do host e o tempo que levou para obter a resposta.

Nem todos os servidores suportam ping, caso a solicitação expire:

Às vezes isso, é feito propositalmente, para "ocultar" o servidor ou apenas para reduzir a carga. Os pacotes de ping também podem ser filtrados por firewalls.

ping funciona usando o protocolo ICMP (Internet Control Message Protocol), um protocolo de camada de rede como TCP ou UDP.

A solicitação envia um pacote ao servidor com a mensagem ECHO_REQUEST e o servidor retorna uma mensagem ECHO_REPLY. Não vou entrar em detalhes, mas esse é o conceito básico.

Fazer ping em um host é útil para saber se o host está acessível (supondo que ele implemente o ping), assim como a distância que ele está em termos de quanto tempo leva para retornar para você.

Normalmente, quanto mais próximo o servidor estiver geograficamente, menos tempo levará para retornar para você. Leis físicas simples fazem com que uma distância maior introduza mais atraso nos cabos.

O comando `traceroute` no Linux

Ao tentar acessar um host na Internet, você passa pelo roteador doméstico. Então você chega à rede do seu ISP, que por sua vez passa por seu próprio roteador de rede upstream e assim por diante, até finalmente chegar ao host.

Você já quis saber quais etapas seus pacotes passam para fazer isso?

O comando traceroute é feito para isso.

Você chama

traceroute

Ele vai reunir (lentamente) todas as informações enquanto o pacote viaja.

Neste exemplo, tentei acessar meu blog com traceroute flaviocopes.com:

Nem todo roteador percorrido nos retorna informações. Neste caso, traceroute imprime * * *. Caso contrário, podemos ver o nome do host, o endereço IP e alguns indicadores de desempenho.

Para cada roteador, podemos ver 3 amostras, o que significa que o traceroute tenta, por padrão, 3 vezes obter uma boa indicação do tempo necessário para alcançá-lo.

É por isso que leva tanto tempo para executar o traceroute em comparação com simplesmente fazer um ping naquele host.

Você pode personalizar esse número com a opção -q:

traceroute -q 1 flaviocopes.com

O comando `clear` no Linux

Digite clear para limpar todos os comandos anteriores que foram executados no terminal atual.

A tela será limpa e você verá apenas o prompt na parte superior:

Observação: este comando possui um atalho útil: ctrl-L

Depois de fazer isso, você perderá o acesso à rolagem para ver a saída dos comandos inseridos anteriormente.

Portanto, você pode querer usar clear -x que ainda limpa a tela, mas permite voltar para ver o trabalho anterior rolando para cima.

O comando `history` no Linux

Cada vez que você executa um comando, ele é memorizado no histórico.

Você pode exibir todo o histórico usando:

history

Isso mostra a história com números:

Você pode usar a sintaxe ! para repetir um comando armazenado no histórico. No exemplo acima, digitar !121 repetirá ls -al | wc -l.

Normalmente, os últimos 500 comandos são armazenados no histórico.

Você pode combinar isso com grep para encontrar um comando que você executou

history | grep docker

Para limpar o histórico, execute history -c.

O comando `export` no Linux

O comando export é usado para exportar variáveis para processos filhos.

O que isso significa?

Suponha que você tenha uma variável TEST definida assim:

TEST="test"

Você pode imprimir seu valor usando echo $TEST:

No entanto, você pode tentar definir um script Bash em um arquivo script.sh com o comando acima:

Ao definir chmod u+x script.sh e executar este script com ./script.sh, a linha echo $TEST não imprimirá nada!

Isso ocorre porque, no Bash, a variável TEST foi definida localmente no shell. Ao executar um script de shell ou outro comando, um subshell é iniciado para executá-lo, que não contém as variáveis locais do shell atuais.

Para disponibilizar a variável ali precisamos definir TEST não assim:

TEST="test"

Defina-o assim:

export TEST="test"

Tente isso e execute ./script.sh. Agora, ele deve imprimir "test":

Às vezes, você precisa acrescentar algo a uma variável. Geralmente, isso é feito com a variável PATH. Você usa esta sintaxe:

export PATH=$PATH:/new/path

É comum usar export quando você cria variáveis dessa maneira. Você, contudo, também pode usá-lo ao criar variáveis nos arquivos de configuração .bash_profile ou .bashrc com Bash, ou em .zshenv com Zsh.

Para remover uma variável, use a opção -n:

export -n TEST

Chamar export sem qualquer opção listará todas as variáveis exportadas.

O comando `crontab` no Linux

Cron jobs são jobs agendados para execução em intervalos específicos. Você pode fazer com que um comando execute algo a cada hora, todos os dias, a cada 2 semanas ou nos finais de semana.

Eles são muito poderosos, principalmente quando usados em servidores para realizar manutenções e automações.

O comando crontab é o ponto de entrada para trabalhar com tarefas cron.

A primeira coisa que você pode fazer é explorar quais cron jobs são definidos por você:

crontab -l

Você pode não ter nenhum, como eu:

Execute

crontab -e

para editar os cron jobs e adicionar novos.

Por padrão, isso abre com o editor padrão, que geralmente é o vim. Eu gosto mais do nano. Você pode usar esta linha para usar um editor diferente:

EDITOR=nano crontab -e

Agora, você pode adicionar uma linha para cada cron job.

A sintaxe para definir cron jobs é meio assustadora. É por isso que costumo usar um site para me ajudar a gerá-los sem erros: https://crontab-generator.org/

Você escolhe um intervalo de tempo para o cron job e digita o comando a ser executado.

Optei por executar um script localizado em /Users/flavio/test.sh a cada 12 horas. Esta é a linha crontab que preciso executar:

* */12 * * * /Users/flavio/test.sh >/dev/null 2>&1

Eu executo crontab -e:

EDITOR=nano crontab -e

e adiciono essa linha. Então, pressiono ctrl-X e pressiono y para salvar.

Se tudo correr bem, o cron job está configurado:

Feito isso, você pode ver a lista de cron jobs ativos executando:

crontab -l

Você pode remover um cron job executando crontab -e novamente, removendo a linha e saindo do editor:

O comando `uname` no Linux

Chamar uname sem nenhuma opção retornará o codinome do sistema operacional:

A opção m mostra o nome do hardware (x86_64 neste exemplo) e a opção p imprime o nome da arquitetura do processador (i386 neste exemplo):

A opção s imprime o nome do sistema operacional. r imprime o lançamento e v imprime a versão:

A opção n imprime o nome da rede do nó:

A opção a imprime todas as informações disponíveis:

No macOS, você também pode usar o comando sw_vers para imprimir mais informações sobre o sistema operacional macOS. Observe que isso difere da versão Darwin (o Kernel), que acima é 19.6.0.

Darwin é o nome do kernel do macOS. O kernel é o "núcleo" do sistema operacional, enquanto o sistema operacional como um todo é chamado de macOS. No Linux, Linux é o kernel, e GNU/Linux seria o nome do sistema operacional (embora todos nos refiramos a ele como "Linux").

O comando `env` no Linux

O comando env pode ser usado para passar variáveis de ambiente sem configurá-las no ambiente externo (o shell atual).

Suponha que você queira executar uma aplicação do Node.js e definir a variável USER para ele.

Você pode executar

env USER=flavio node app.js

e a variável de ambiente USER estará acessível na aplicação do Node.js por meio da interface Node process.env.

Você também pode executar o comando limpando todas as variáveis de ambiente já definidas, usando a opção -i:

env -i node app.js

Nesse caso, você receberá um erro dizendo env: node: No such file or directory porque o comando node não está acessível, pois a variável PATH usada pelo shell para procurar comandos nos caminhos comuns não está definida.

Então, você precisa passar o caminho completo para o programa node:

env -i /usr/local/bin/node app.js

Experimente com um arquivo app.js simples com este conteúdo:

console.log(process.env.NAME)
console.log(process.env.PATH)

Você verá a saída como

undefined
undefined

Você pode passar uma variável env:

env -i NAME=flavio node app.js

e a saída será

flavio
undefined

A remoção da opção-i tornará o PATH disponível novamente dentro do programa:

O comando env também pode ser usado para imprimir todas as variáveis de ambiente. Se executado sem opções:

env

Ele retornará uma lista das variáveis de ambiente definidas, por exemplo:

HOME=/Users/flavio
LOGNAME=flavio
PATH=/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/Library/Apple/usr/bin
PWD=/Users/flavio
SHELL=/usr/local/bin/fish

Você também pode tornar uma variável inacessível dentro do programa que você executa, usando a opção -u. Por exemplo, este código remove a variável HOME do ambiente de comando:

env -u HOME node app.js

O comando `printenv` no Linux

Aqui está um guia rápido para o comando printenv, usado para imprimir os valores das variáveis de ambiente

Em qualquer shell, há um bom número de variáveis de ambiente, definidas pelo sistema ou por seus próprios scripts e configurações de shell.

Você pode imprimir todos eles no terminal usando o comando printenv. A saída será algo assim:

HOME=/Users/flavio
LOGNAME=flavio
PATH=/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/Library/Apple/usr/bin
PWD=/Users/flavio
SHELL=/usr/local/bin/fish

com mais algumas linhas, geralmente.

Você pode anexar um nome de variável como parâmetro, para mostrar apenas o valor dessa variável:

printenv PATH

Conclusão

Muito obrigado por ler este manual.

Espero que ele inspire você a aprender mais sobre o Linux e seus recursos. É um conhecimento perene que não ficará desatualizado tão cedo.

Lembre-se de que você pode fazer download deste manual em PDF/ePUB/Mobi se você quiser!

O autor publica tutoriais de programação diariamente em seu site, flaviocopes.com, se você quiser conferir mais conteúdos excelentes como este.

Você pode entrar em contato com o autor através do Twitter.

Como integrar mapas no React Native usando react-native-maps

Sabrina — Mon, 24 Jun 2024 21:00:00 +0000

Artigo original: How to integrate maps in React Native using react-native-maps

Escrito por: Mukhamed Khasanza

Hoje em dia, quase todas as aplicações para dispositivos móveis têm um recurso de mapas. Eu tive que integrar o Google Maps à minha aplicação para o React Native, e a única opção era o react-native-maps da Airbnb (é o único ainda suportado pela comunidade do React Native).

Encontrei vários tutoriais sobre como configurar essa biblioteca, mas nenhum funcionou totalmente para mim. Isso porque eu tinha que rodar em plataformas iOS e Android, além de dar suporte ao Google Maps para iOS.

Vamos criar uma aplicação do React Native do zero usando react-native-cli para mostrar, passo a passo, como tudo é instalado. Se você quiser integrar o react-native-maps à sua aplicação existente, pule a Etapa 1.

Etapa 1: instalar e configurar a aplicação do React Native

Se você não instalou a interface de linha de comando do React Native, execute: npm install -g react-native-cli. Agora, você pode criar seu projeto, simplesmente usando: react-native init ReactNativeMaps

Aqui estão as versões de dependência no momento da construção deste projeto:

"react": "16.6.1"
"react-native": "0.57.5"
"react-native-maps": "0.22.1" — instalaremos este mais tarde.

Nota da tradução: mantivemos as versões constantes no artigo original, mas, na data da tradução, as versões são 18.2.0 e 1.15.6, respectivamente.

Tente executar sua aplicação, react-native run-ios ou react-native run-android. Normalmente, isso funciona sem problemas.

Etapa 2: adicionar e vincular o pacote react-native-maps

Agora, vamos instalar o react-native-maps: npm install --save react-native-maps. Depois de instalar o pacote, você deve vinculá-lo às suas aplicações nativas: react-native link react-native-maps.

Se você recebeu uma tela semelhante a essa, podemos continuar.

Etapa 3: configurar o Apple Maps (iOS)

Será mais fácil se os configurarmos separadamente por plataforma. Então, vamos primeiro fazer isso no iOS. Antes de integrar o Google Maps, verificaremos se o Apple Maps funciona corretamente. Adicione o seguinte código ao seu componente de renderização atual, onde você deseja renderizar seu MapView.

import MapView from 'react-native-maps'

export default class App extends Component {
  render() {
    return ();
  }
}

Você pode testar qualquer local que quiser. Basta especificar a latitude e a longitude apropriadas. Como você pode ver, eu habilitei a localização do usuário simplesmente adicionando a prop showUserLocation ao componente MapView. Se você estiver executando no dispositivo real, verá sua localização atual.

Então, como você pode ver, por padrão, o Apple Maps já está funcionando. Mais do que isso, se você vinculou tudo corretamente e habilitou a localização do usuário, ele realmente fez muitas coisas para nós (a permissão do usuário para a localização com uma mensagem padrão). Se você veio do desenvolvimento nativo do iOS, então, provavelmente, sabe o que é um arquivo info.plist.

Etapa 4: instalar o Cocoapods e o pacote "GoogleMaps" (iOS)

O Apple Maps foi fácil, certo? Concordo — então, vamos ver o que o Google Maps tem para nós. Temos que instalar o Google Maps SDK para iOS. Usaremos o Cocoapods. Se você não o usou antes, execute sudo gem install cocoapods.

Agora, você tem que criar um Podfile, onde você especificará as dependências da sua aplicação para o iOS. Navegue até sua pasta iOS/ na sua aplicação do React Native e execute: pod init ou você pode usar touch Podfile. Você deve ter algo similar a isto:

# platform :ios, '9.0'

target 'ReactNativeMaps' do

# Pods for ReactNativeMaps

pod 'GoogleMaps'

end

Como você pode ver, adicionei o pod GoogleMaps e agora temos que instalá-lo. Se você ainda estiver na pasta iOS/, execute: pod install . Se você tentar executá-lo agora, provavelmente receberá um erro:

Ok, vamos fazer o que ele quer. Agora, devemos abrir o espaço de trabalho do xCode.

Navegue até a pasta AirGoogleMaps em node_modules/

Arraste-a para o topo do seu projeto do xCode

Tente construir seu projeto do xCode, se estiver falhando.

Você deve adicionar HAVE_GOOGLE_MAPS=1 Preprocessor Macro para Build Settings

Etapa 5: obter a chave da api do Google Maps e executar a aplicação do iOS com o Google Maps

Agora, temos que gerar uma Google Maps API key.

Copie sua chave de API e adicione-a ao arquivo AppDelegate.m.

#import

[GMSServices provideAPIKey:@"SUA_CHAVE_DE_API"]

Informe ao seu componente MapView que está pronto para usar o Google Maps.

Ah, sim. Não se esqueça de executar sua aplicação do iOS. Agora, você já terá o Google Maps à disposição.

Eu espero.

Etapa 6: vamos tentar no Android agora

Ok. Agora, podemos sair do xCode e vamos apenas tentar react-native run-android. Se você estiver recebendo o mesmo que isto:

verifique seu arquivo android/app/build.gradle e substitua compile project(':react-native-maps') por isto:

implementation(project(':react-native-maps')){        exclude group: 'com.google.android.gms', module: 'play-services-base'        exclude group: 'com.google.android.gms', module: 'play-services-maps'    }implementation 'com.google.android.gms:play-services-base:12.0.0'implementation 'com.google.android.gms:play-services-maps:12.0.0'

Não se esqueça de adicionar a API_KEY ao arquivo AndroidManifest.xml.

Sim, agora sua aplicação está rodando em ambas as plataformas. Verifique o repositório do react-native-maps para mais coisas divertidas que você pode fazer com seu componente MapView.

Conclusão

Espero que meu primeiro artigo tenha sido útil para você.

Como usar os buffers de protocolo do Google em Python

Sabrina — Sun, 26 May 2024 21:00:00 +0000

Artigo original: How to Use Google's Protocol Buffers in Python

Quando as pessoas que falam idiomas diferentes estão juntas e conversam, elas tentam usar uma linguagem que todos do grupo possam entender.

Para isso, todos precisam traduzir seus pensamentos, que normalmente estão na sua língua nativa, para todos do grupo. Essa "codificação e decodificação" do idioma, no entanto, leva a uma perda de eficiência, velocidade e precisão.

O mesmo conceito está presente nos sistemas do computador e em seus componentes. Por que deveríamos enviar dados em XML, JSON, ou em outra linguagem de humanos se não precisamos entender diretamente sobre o que eles estão falando? Basta que possamos traduzir para o formato da linguagem humana se precisarmos.

Os buffers de protocolo são uma forma de codificar dados antes do transporte, o que reduz de maneira eficiente os blocos de dados e, portanto, aumenta a velocidade de envio. Eles abstraem os dados em um formato neutro em termos de linguagem e plataforma.

Índice

Por que precisamos dos buffers de protocolo?

O objetivo inicial dos buffers de protocolos foi o de simplificar o trabalho com protocolos de solicitação/resposta. Antes do ProtoBuf, O Google usou um formato diferente para solicitação adicional de manipulação do marshaling para o envio de mensagens.

Além disso, as novas versões dos formatos anteriores exigiam que os desenvolvedores tivessem a certeza de que as novas versões fossem entendidas antes de substituir as antigas, tornando o trabalho com elas um problema.

Isso motivou a Google a projetar uma interface que resolvesse precisamente esses problemas.

Os buffers do protocolo permitem alterações no protocolo sem interferir na compatibilidade. Além disso, servidores podem transmitir os dados e executar operações de leitura nos dados sem modificar o conteúdo.

Como o formato se autodescreve, o ProtoBuf é usado como base para geração automática de código para serializadores e desserializadores.

Outro caso de uso interessante é como a Google o usa para chamadas de procedimento remoto (RPC – texto em inglês) de curta duração e para armazenar dados persistentemente na Bigtable. Devido ao seu caso de uso especifico, eles integraram interfaces de RPC aos buffers de protocolo. Isso permite a geração rápida e direta de códigos stub que podem ser usados como pontos de partidas para a implementação real (mais a respeito de ProtoBuf RPC aqui – texto em inglês).

Outros exemplos de onde o ProtoBuf pode ser usado são os dispositivos IoT conectados através de redes móveis, nas quais a quantidade de dados enviadas deve ser pequena ou para aplicações de países onde larguras de banda altas ainda são raras. O envio de cargas úteis, otimizada em formatos binários, pode levar a diferenças perceptíveis no custo e na velocidade de operação.

Usar a compactação gzip em sua comunicação por HTTPS pode melhorar ainda mais essas métricas.

O que são os buffers de protocolo e como eles funcionam?

De modo geral, os buffers de protocolo podem ser definidos como uma interface para serialização de dados estruturados. Isso define uma forma normalizada de comunicação, totalmente independente de linguagens e plataformas.

O Google anuncia o buffer de protocolo como:

Buffers de protocolo são os mecanismo extensível, neutro em termos de linguagem e de plataforma do Google para serializar dados estruturados – pense no XML, mas menor, mais rápido e mais simples. Você define como deseja que seus dados sejam estruturados uma vez…

A interface ProtoBuf descreve a estrutura de dados a serem enviados. As estruturas de cargas útil são definidas como "mensagens" no que é chamado de Proto-Arquivo. Esses arquivos sempre terminam com a extensão .proto

Por exemplo, a estrutura básica de um arquivo todolist.proto é semelhante a que vemos a seguir. Também veremos um exemplo completo na próxima seção.

syntax = "proto3";

// Não é necessário para Python, ainda deve ser declarado para evitar colisões de nomes
// no namespace Protocol Buffers e em linguagens além do Python

package protoblog;

message TodoList {
   // Os elementos da lista de tarefas serão definidos aqui
      ...
}

Esses arquivos são, então, usados para gerar classes de integração ou stubs para a linguagem de sua escolha usando geradores de código dentro do compilador protoc. A versão atual, Proto3, já suporta todas as principais linguagens de programação. A comunidade oferece suporte a muito mais implementações de código aberto de terceiros.

As classes geradas são os elementos principais dos buffers de protocolo. Eles permitem a criação de elementos instanciando novas mensagens, baseadas nos arquivos .proto, que são, então, utilizados para serialização. Veremos em detalhes como isso é feito com Python na próxima seção.

Independentemente da linguagem de serialização, as mensagens são serializadas em um formato binário, não auto descritivo, que é bastante inútil sem a definição inicial da estrutura.

Os dados binários podem, então, ser armazenados, enviados pela rede e usados de qualquer outra forma que os dados legíveis por humanos, como JSON ou XML, sejam. Após a transmissão ou armazenamento, o fluxo de bytes pode ser desserializado e restaurado usando qualquer classe protobuf compilada específica da linguagem que geramos a partir do arquivo .proto.

Usando Python como exemplo, o processo poderia ser mais ou menos assim:

Primeiro, criamos uma lista de tarefas e a preenchemos com algumas tarefas. Essa lista de tarefas é, então, serializada e enviada pela rede, salva em um arquivo ou armazenada persistentemente em um banco de dados.

O fluxo de bytes enviado é desserializado usando o método parse de nossa classe compilada específica da linguagem.

A maioria das arquiteturas e infraestruturas atuais, especialmente microsserviços, é baseada em comunicação REST, WebSockets ou GraphQL. No entanto, quando a velocidade e a eficiência são essenciais, os RPCs de baixo nível podem fazer uma enorme diferença.

Em vez de protocolos de alta sobrecarga, podemos usar uma forma rápida e compacta de mover dados entre as diferentes entidades para o nosso serviço sem desperdiçar muitos recursos.

Por que isso ainda não é usado em todos os lugares?

Os buffers de protocolo são um pouco mais complicados do que outros formatos legíveis por humanos. Isso os torna comparativamente mais difíceis de depurar e integrar em suas aplicações.

Os tempos de iteração na engenharia também tendem a aumentar, pois as atualizações nos dados exigem a atualização dos arquivos proto antes do uso.

Considerações cuidadosas devem ser feitas, uma vez que o ProtoBuf pode ser uma solução com excesso de engenharia em muitos casos.

Que alternativas eu tenho?

Vários projetos adotam uma abordagem semelhante aos buffers de protocolo do Google.

Os Flatbuffer do Google e uma implementação de terceiros, chamada Cap’n Proto, estão mais focados em remover a etapa de análise e descompactação, que é necessária para acessar os dados reais ao usar ProtoBufs. Eles foram projetados explicitamente para aplicações de desempenho crítico, tornando-os ainda mais rápidos e mais eficientes em termos de memória do que o ProtoBuf.

Ao focar nos recursos RPC do ProtoBuf (usado com gRPC), existem projetos de outras grandes empresas como Facebook (Apache Thrift) ou Microsoft (protocolos Bond) que podem oferecer alternativas.

Buffers de protocolo com o Python

O Python já fornece algumas formas de persistência de dados usando decapagem. A decapagem é útil em aplicações que tenham somente Python. Ela não é adequada para cenários mais complexos onde está envolvido o compartilhamento de dados com outras linguagens ou a alteração de esquemas.

Os buffers de protocolo, por outro lado, são desenvolvidos exatamente para esses cenários. O arquivo .proto, que abordamos rapidamente antes, permite ao usuário gerar código para muitas linguagens suportadas.

Para compilar o arquivo .proto para a classe de linguagem de nossa escolha, usamos protoc, o compilador proto.

Se você não possui o compilador protoc instalado, existem excelentes guias sobre como fazer isso:

MacOS/Linux (em inglês)
Windows (em inglês)

Depois de instalar o protoc em nosso sistema, podemos usar um exemplo estendido de nossa estrutura de lista de tarefas anterior e gerar a classe de integração Python a partir dele.

syntax = "proto3";

// Não necessário para o Python, mas ainda deve ser declarado para evitar colisões de nome 
// no namespace dos Buffers de Protocolo e em linguagens que não sejam o Python
package protoblog;

// O guia de estilo prefere a prefixação de valores de enum em vez de cercá-los
// com uma mensagem de fechamento
enum TaskState {
    TASK_OPEN = 0;
    TASK_IN_PROGRESS = 1;
    TASK_POST_PONED = 2;
    TASK_CLOSED = 3;
    TASK_DONE = 4;
}

message TodoList {
    int32 owner_id = 1;
    string owner_name = 2;

    message ListItems {
        TaskState state = 1;
        string task = 2;
        string due_date = 3;
    }

    repeated ListItems todos = 3;
}

Vamos dar uma olhada mais detalhada na estrutura do arquivo .proto para entendê-lo. Na primeira linha do arquivo proto, definimos se estamos usando Proto2 ou 3. Nesse caso, estamos usando Proto3.

Os elementos mais incomuns dos arquivos proto são os números atribuídos a cada entidade de uma mensagem. Esses números dedicados tornam cada atributo único e são usados para identificar os campos atribuídos na saída codificada em binário.

Um conceito importante de se entender é que apenas os valores de 1 a 15 são codificados com um byte a menos (Hex), o que é útil de entender para que possamos atribuir números mais altos às entidades usadas com menos frequência. Os números não definem a ordem de codificação nem a posição do atributo fornecido na mensagem codificada.

A definição do pacote ajuda a evitar conflitos de nomes. Em Python, os pacotes são definidos por seu diretório. Portanto, fornecer um atributo de pacote não tem nenhum efeito no código em Python gerado.

Observe que os pacotes ainda devem ser declarados para evitar colisões de nomes relacionadas ao buffer de protocolo e para outras linguagens como Java.

Enumerações são listagens simples de valores possíveis para uma determinada variável. Nesse caso, definimos um Enum para os possíveis estados de cada tarefa na lista de tarefas. Veremos como usá-los daqui a pouco, quando observarmos o uso em Python.

Como podemos ver no exemplo, também podemos aninhar mensagens dentro de mensagens. Se quisermos, por exemplo, ter uma lista de todos os dados associados a uma determinada lista de tarefas, podemos usar a palavra-chave repeated, que é comparável a arrays de tamanho dinâmico .

Para gerar código de integração utilizável, usamos o compilador proto, que compila um determinado arquivo .proto em classes de integração específicas da linguagem. No nosso caso, usamos o argumento --python-out para gerar código específico em Python.

protoc -I=. --python_out=. ./todolist.proto

No terminal, invocamos o compilador do protocolo com três parâmetros:

-I: define o diretório onde procuramos quaisquer dependências (usamos ., que é o diretório atual)
--python_out: define o local onde queremos gerar uma classe de integração do Python (novamente usamos ., que é o diretório atual)
O último parâmetro sem nome define o arquivo .proto que será compilado (usamos o arquivo todolist.proto, no diretório atual)

Isso cria um novo arquivo em Python chamado _pb2.py. No nosso caso, é todolist_pb2.py. Ao examinar esse arquivo mais de perto, não seremos capazes de entender muito sobre sua estrutura imediatamente.

Isso ocorre porque o gerador não produz elementos de acesso direto aos dados, mas abstrai ainda mais a complexidade usando metaclasses e descritores para cada atributo. Eles descrevem como uma classe se comporta em vez de cada instância dessa classe.

A parte mais interessante é como usar esse código gerado para criar, construir e serializar dados. Uma integração direta feita com nossa classe gerada recentemente é vista a seguir:

import todolist_pb2 as TodoList

my_list = TodoList.TodoList()
my_list.owner_id = 1234
my_list.owner_name = "Tim"

first_item = my_list.todos.add()
first_item.state = TodoList.TaskState.Value("TASK_DONE")
first_item.task = "Teste de ProtoBuf para o Python"
first_item.due_date = "31.10.2019"

print(my_list)

Ele apenas cria uma lista de tarefas e adiciona um item a ela. Em seguida, imprimimos o próprio elemento da lista de tarefas e podemos ver a versão não binária e não serializada dos dados que acabamos de definir em nosso script.

owner_id: 1234
owner_name: "Tim"
todos {
  state: TASK_DONE
  task: "Teste de ProtoBuf para o Python"
  due_date: "31.10.2019"
}

Cada classe Protocol Buffer possui métodos para ler e escrever mensagens usando uma codificação específica do buffer de protocolo (texto em inglês), que codifica mensagens em formato binário. Esses dois métodos são SerializeToString() e ParseFromString().

import todolist_pb2 as TodoList

my_list = TodoList.TodoList()
my_list.owner_id = 1234

# ...

with open("./serializedFile", "wb") as fd:
    fd.write(my_list.SerializeToString())


my_list = TodoList.TodoList()
with open("./serializedFile", "rb") as fd:
    my_list.ParseFromString(fd.read())

print(my_list)

No exemplo de código acima, escrevemos a string serializada de bytes em um arquivo usando os sinalizadores wb.

Como já escrevemos o arquivo, podemos ler o conteúdo e analisá-lo usando ParseFromString. ParseFromString chama uma nova instância de nossa classe serializada usando os sinalizadores rb e a analisa.

Se serializarmos essa mensagem e se a imprimimos no console, obteremos a representação de bytes semelhante a esta.

b'\x08\xd2\t\x12\x03Tim\x1a(\x08\x04\x12\x18Teste de ProtoBuf para o Python\x1a\n31.10.2019'

Observe o b na frente das aspas. Isso indica que a string a seguir é composta de octetos de bytes em Python.

Se compararmos isso diretamente com, por exemplo, XML, podemos ver o impacto que a serialização do ProtoBuf tem no tamanho.


	1234
	Tim
	
		
			TASK_DONE
			Teste de ProtoBuf para o Python
			31.10.2019

A representação JSON, ajustada, ficaria assim.

{
	"todoList": {
		"ownerId": "1234",
		"ownerName": "Tim",
		"todos": [
			{
				"state": "TASK_DONE",
				"task": "Teste de ProtoBuf para o Python",
				"dueDate": "31.10.2019"
			}
		] 
	}
}

Julgando os diferentes formatos apenas pelo número total de bytes utilizados, ignorando a memória necessária para o overhead de formatação, podemos obviamente ver a diferença.

Além da memória utilizada para os dados, no entanto, também temos 12 bytes extras no ProtoBuf para formatação de dados serializados. Comparando isso com XML, temos 171 bytes extras em XML para formatar dados serializados.

Sem um esquema, precisamos de 136 bytes extras em JSON para formatar dados serializados.

Se estamos falando de milhares de mensagens enviadas pela rede ou armazenadas em disco, o ProtoBuf pode fazer a diferença.

Há uma questão importante, no entanto. A plataforma Auth0.com criou uma extensa comparação entre ProtoBuf e JSON. Ela mostra que, quando comprimido, a diferença de tamanho entre os dois pode ser mínima (apenas cerca de 9%).

Se você estiver interessado nos números exatos, consulte o artigo completo (em inglês), que fornece uma análise detalhada de vários fatores como tamanho e velocidade.

Uma observação interessante é que cada tipo de dados possui um valor padrão. Se os atributos não forem atribuídos ou alterados, eles manterão os valores padrão. No nosso caso, se não alterarmos o TaskState de um ListItem, ele terá o estado "TASK_OPEN" por padrão. A vantagem significativa disso é que os valores não definidos não são serializados, economizando espaço adicional.

Se, por exemplo, alterarmos o estado da nossa tarefa de TASK_DONE para TASK_OPEN, ela não será serializada.

owner_id: 1234
owner_name: "Tim"
todos {
  task: "Teste de ProtoBuf para o Python"
  due_date: "31.10.2019"
}

b'\x08\xd2\t\x12\x03Tim\x1a&\x12\x18Teste de ProtoBuf para o Python\x1a\n31.10.2019'

Considerações finais

Como vimos, os buffers de protocolo são bastante úteis quando se trata de velocidade e eficiência ao trabalhar com dados. Devido à sua natureza poderosa, pode levar algum tempo para se acostumar com o sistema ProtoBuf, embora a sintaxe para definir novas mensagens seja simples.

Como última observação, quero salientar que houve/há discussões em andamento sobre a "utilidade" dos buffers de protocolo para aplicações regulares. Eles foram desenvolvidos explicitamente para problemas que o Google tinha em mente.

Se você tiver alguma dúvida ou feedback, sinta-se à vontade para entrar em contato com o autor em qualquer mídia social, como o Twitter ou por e-mail.

Desvendando a entrevista de front-end

Sabrina — Wed, 03 Apr 2024 00:06:27 +0000

Artigo original: Cracking the front-end interview

As entrevistas técnicas na área de front-end são difíceis. Isso é um fato. Você não precisa apenas de um conhecimento sólido em fundamentos ciência da computação, mas também precisa de um entendimento relacionado ao desempenho da web, construção de sistemas e engines de layout com o CSS.

Apesar de existirem recursos por ai, eu encontrei apenas algumas guias para ajudar você a se preparar para uma entrevista na área de front-end. Então, eu decidi escrever um artigo em tópicos que espero poder ajudar você a se sair bem em sua próxima entrevista.

Antes da entrevista

Antes de sua entrevista, pergunte ao seu recrutador qual o formato da entrevista. Em algumas entrevistas é usado o quadro branco, enquanto em outras é usado um editor de texto on-line como o CoderPad. É importante você saber para que possa praticar no ambiente que ocorrerá na entrevista.

Pergunte para seu recrutador quais tópicos você deve focar quando estiver se preparando. A razão por trás disso é porque além de perguntas especificas de front-end, algumas empresas farão perguntas tradicionais de ciência da computação, sobre tópicos como algoritmos de busca e classificação.

Conceitos de front-end

HTML, CSS, JavaScript e padrões de design em JavaScript são as chaves do que você deverá encontrar durante uma entrevista. Examine a lista e certifique-se de que está confortável com cada tópico.

HTML e CSS

HTML e CSS são o básico do desenvolvimento para front-end. Durante as entrevistas, você deve está preparado para as perguntas sobre nuances do HTML e CSS. Desde já, esteja preparado para programar um layout baseado em um mockup.

Se você precisar relembrar alguma coisa de HTML e CSS, aqui estão alguns conceitos básicos para praticar (em inglês):

Além desses conceitos, estude sobre pré-processadores de CSS, como SASS ou LESS e seus benefícios. Também procure entender as convenções de nomenclaturas do CSS como BEM e OOCSS.

Outro ponto importante é que os entrevistadores buscam candidatos que defendam boas praticas de CSS. Como uma boa referência, esse guia escrito por um desenvolvedor de front-end do Medium proporciona informações sobre como o Medium chegou até sua arquitetura de CSS atual.

Eu mencionei inicialmente que alguns entrevistadores pedirão para você recriar layouts em HTML e CSS. Faça isso em um playground como o CodePen. Pesquise no Dribbble, pois ele tem muitos designs simples que podem ser divertidos de recriar.

Finalmente, como desenvolvedores para front-end, estamos acostumados a fazer mudanças em nosso editor e depois verificar as mudanças em nosso navegador. Porém, na maioria das vezes durante as entrevistas, você não terá esse luxo. Quando você estiver se preparando para a entrevista, tente programar a maior parte de seu layout sem ficar olhando o resultado até o fim.

Conceitos de JavaScript

Se o HTML e o CSS são o básico do desenvolvimento para front-end, o JavaScript é o que faz as coisas acontecerem. As empresas durante a entrevista, gastarão um bom tempo testando seu conhecimento em JavaScript. Muitas questões girarão em torno dos seguintes conceitos (alguns dos textos em inglês):

Quando receber uma pergunta de JavaScript, descubra em qual desses conceitos você esta sendo testado e será muito mais fácil descobrir a resposta certa. Se você se sente confiante em suas habilidades, teste seus conhecimentos aqui, aqui e aqui.

Padrões de design

Os padrões de design em JavaScript fornecem soluções repetíveis de problemas comuns. Esses são alguns padrões de design que são importantes conhecer:

Além dos padrões de design do JavaScript, é bom esta familiarizado com os frameworks do JavaScript. Isso não significa que você tem que aprender outro framework antes da sua entrevista. Em vez disso, aprenda quando e por que as equipes de front-end usam frameworks. Além disso, se você está participando de uma entrevista que envolve algo como React + Flux ou Angular, revise um pouco da documentação de arquitetura do framework antes.

Conceitos da ciência da computação

Algumas empresas contratam engenheiros de software antes de desenvolvedores para front-end. Isso significa que as empresas esperam que você tenha um bom conhecimento em alguns tópicos, como princípios de design de software, arquitetura de código escalável e testes.

Se seu recrutador sugerir que você revise seus conhecimentos em estruturas de dados e algoritmos, esta sessão é pra você. Caso contrário, sinta-se a vontade para pular a seção. Se você não tem formação em ciência da computação, sem problemas. A maior parte desses conceitos são fáceis de aprender.

Estruturas de dados

Essas são as estruturas básicas que eu gostaria de sugerir. Não se prenda apenas na leitura, reserve um tempo para implementá-las em JavaScript. Se você não está familiarizado com testes unitários, teste sua estrutura de dados com uma biblioteca como o Mocha para aprender.

Listas vinculadas
Tabelas hash
Pilhas e filas
Árvores (árvores binárias e heaps)
Grafos

Nota: para grafos, procure saber como implementar travessias de busca em profundidade e em largura.

Para as implementações dessas estruturas de dados, você pode consultar a SanFoundry. Todos os exemplos estão em Java, mas reimplementá-los em JavaScript é fácil.

Ordenação

Uma vez que você estiver confiante sobre estruturas de dados, você pode passar para a ordenação. Implemente os algoritmos em JavaScript, faça anotações sobre suas complexidades de tempo e espaço.

Busca binária
Ordenação de bolha (Bubble sort)
Ordenação de inserção (Insertion sort)
Ordenação de mescla (Merge sort)
Ordenação rápida (Quick sort)
Ordenação de seleção (Selection sort)

Depois de revisar estruturas de dados e algoritmos, teste seus conhecimentos com o Leetcode e com perguntas técnicas sobre JavaScript (links em inglês).

Para encerrar

Eu sei que é muita coisa para absorver, especialmente se você é novo na área de desenvolvimento para front-end. Comece se preparando para suas entrevistas com antecedência, então você se sentirá mais confortável quando chegar a hora.

Além do mais, lembre-se de que, independentemente do resultado, as entrevistas não medem o seu valor como programador. Algumas pessoas são boas nas entrevistas; outras, não. Às vezes você conquista o entrevistador; às vezes, não.

Se você tiver alguma dúvida, deixe uma nota no Twitter para o autor. Ele gostaria saber como foi sua entrevista. Boa sorte!

Se quiser saber mais, siga o autor no Twitter. Lá, ele publica informações sobre design, desenvolvimento para front-end, bots e aprendizagem de máquina.

Sabrina - freeCodeCamp.org

O manual de comandos do Linux – aprenda comandos do Linux para iniciantes

Índice

Introdução ao Linux e shells

O que é Linux?

O que é um shell Linux?

O comando man no Linux

O comando ls no Linux

O comando cd no Linux

O comando pwd no Linux

O comando mkdir no Linux

O comando rmdir no Linux

O comando mv no Linux

O comando cp no Linux

‌O comando open no Linux

‌O comando touch no Linux

O comando find no Linux

O comando ln no Linux

Hard links

Soft links

O comando gzip no Linux

O comando gunzip no Linux

O comando tar no Linux

O comando alias no Linux

O comando cat no Linux

O comando less no Linux

O comando tail no Linux

O comando wc no Linux

O comando grep no Linux

O comando sort no Linux

O comando uniq no Linux

O comando diff no Linux

O comando echo no Linux

O comando chown no Linux

O comando chmod no Linux

O comando umask no Linux

O comando du no Linux

O comando df no Linux

O comando basename no Linux

O comando dirname no Linux

O comando ps no Linux

O comando top no Linux

O comando kill no Linux

O comando killall no Linux

O comando jobs no Linux

O comando bg no Linux

O comando fg no Linux

O comando type no Linux

O comando which no Linux

O comando nohup no Linux

O comando xargs no Linux

O comando do editor vim no Linux

O comando do editor emacs no Linux

O comando do editor nano no Linux

O comando whoami no Linux

O comando who no Linux

O comando su no Linux

O comando sudo no Linux

O comando passwd no Linux

O comando ping no Linux

O comando traceroute no Linux

O comando clear no Linux

O comando history no Linux

O comando export no Linux

O comando crontab no Linux

O comando uname no Linux

O comando env no Linux

O comando printenv no Linux

Conclusão

Como integrar mapas no React Native usando react-native-maps

Etapa 1: instalar e configurar a aplicação do React Native

Etapa 2: adicionar e vincular o pacote react-native-maps

Etapa 3: configurar o Apple Maps (iOS)

Etapa 4: instalar o Cocoapods e o pacote "GoogleMaps" (iOS)

Etapa 5: obter a chave da api do Google Maps e executar a aplicação do iOS com o Google Maps

Etapa 6: vamos tentar no Android agora

Conclusão

Como usar os buffers de protocolo do Google em Python

Índice

Por que precisamos dos buffers de protocolo?

O comando `man` no Linux

O comando `ls` no Linux

O comando `cd` no Linux

O comando `pwd` no Linux

O comando `mkdir` no Linux

O comando `rmdir` no Linux

O comando `mv` no Linux

O comando `cp` no Linux

‌O comando `open` no Linux

‌O comando `touch` no Linux

O comando `find` no Linux

O comando `ln` no Linux

O comando `gzip` no Linux

O comando `gunzip` no Linux

O comando `tar` no Linux

O comando `alias` no Linux

O comando `cat` no Linux

O comando `less` no Linux

O comando `tail` no Linux

O comando `wc` no Linux

O comando `grep` no Linux

O comando `sort` no Linux

O comando `uniq` no Linux

O comando `diff` no Linux

O comando `echo` no Linux

O comando `chown` no Linux

O comando `chmod` no Linux

O comando `umask` no Linux

O comando `du` no Linux

O comando `df` no Linux

O comando `basename` no Linux

O comando `dirname` no Linux

O comando `ps` no Linux

O comando `top` no Linux

O comando `kill` no Linux

O comando `killall` no Linux

O comando `jobs` no Linux

O comando `bg` no Linux

O comando `fg` no Linux

O comando `type` no Linux

O comando `which` no Linux

O comando `nohup` no Linux

O comando `xargs` no Linux

O comando do editor `vim` no Linux

O comando do editor `emacs` no Linux

O comando do editor `nano` no Linux

O comando `whoami` no Linux

O comando `who` no Linux

O comando `su` no Linux

O comando `sudo` no Linux

O comando `passwd` no Linux

O comando `ping` no Linux

O comando `traceroute` no Linux

O comando `clear` no Linux

O comando `history` no Linux

O comando `export` no Linux

O comando `crontab` no Linux

O comando `uname` no Linux

O comando `env` no Linux

O comando `printenv` no Linux