Como adicionar um diretório ao caminho no Linux
Comandos não são apenas comandos do sistema operacional de disco. O caminho é uma lista de diretórios nos quais o shell procura comandos do sistema operacional e outros comandos. Os comandos são como arquivos de programa curtos. Então, os comandos são executáveis. Cada aplicativo instalado no computador vem com um arquivo executável. Para executar o aplicativo, o arquivo executável está envolvido primeiro. Esses arquivos executáveis também são chamados de comandos.
Sem a variável do caminho, cada comando seria comandado com o caminho absoluto, como em,
/home/John/dir1/dir2/comando.exe
onde o primeiro / é o diretório raiz; John é o diretório do usuário do usuário, John; DIR1 e DIR2 são subdiretos; e comando.exe é o nome do arquivo executável.
Muitos outros nomes são possíveis para o arquivo executável. De fato, comando.exe é simbólico aqui. Portanto, se o diretório/home/John/dir1/dir2 (sem o arquivo), estiver na variável do caminho, o usuário John, executará o comando.exe no prompt, John@host: ~ $ simplesmente digitando, comando.exe, sem o caminho anterior. Aquilo é:
John@host: ~ comando.exe
e depois pressionar Enter.
Para ver a lista atual de diretórios de caminho no computador, digite:
$ ECHO $ PATH
e pressione Enter, no terminal. O resultado seria algo como,
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin
A questão agora é: como é um diretório (e seu caminho anterior), adicionado à variável do caminho? Com algumas instalações, o diretório é adicionado automaticamente. Com outros, tem que ser adicionado manualmente. Este artigo explica as duas maneiras principais, nas quais o diretório é adicionado. O diretório não é adicionado (incluído) como seria feito a uma matriz. As duas maneiras principais são chamadas de adição temporária e adição permanente. Bash é o shell usado para os exemplos de código neste artigo.
Conteúdo do artigo
- Introdução - Veja acima
- Adição temporária
- Adição permanente
- Conclusão
Adição temporária
Adição temporária significa que a adição só ocorre na memória. Não é salvo para uso quando o computador é reiniciado.
O comando de exportação interno de Bourne Shell
Em termos simples, o comando de exportação é:
$ export [nome [= valor]]
Nesse caso, transfere um valor para uma variável na memória.
A variável de caminho na memória já pode ter valor como,
Caminho =/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin
Suponha que o diretório a ser adicionado seja/home/John/dir1/dir2. Se o comando de exportação for digitado como,
$ Caminho de exportação =/Home/John/Dir1/Dir2
Então/home/John/dir1/dir2 substituiria tudo o que já está na memória como valor para a variável do caminho.
Se o comando de exportação for digitado como,
$ Caminho de exportação = $ PATH:/Home/John/Dir1/Dir2
Então,/home/John/dir1/dir2 se anexaria no final do que já está na variável. Então, a nova variável seria:
Caminho =/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin:/ Home/John/Dir1/Dir2
Observe que, na linha anterior de código acima, a parte do valor que já está lá está separada da nova parte com um cólon, que é ':'. $ Caminho na linha de código, expande (é substituído) pelo valor do caminho já na memória.
Agora, o mesmo comando pode estar em mais de um diretório. Quando um comando executável é digitado sem o caminho anterior no prompt, o shell começa a pesquisar o valor (string) da variável do caminho na memória, da esquerda para a direita. Então, com a linha de código acima,/home/John/dir1/dir2 chegaria finalmente, na pesquisa. Quem quer que seu diretório chegue por último? - Ninguém. Portanto, uma maneira melhor de incluir (adicionar) o diretório é a seguinte:
$ Caminho de exportação =/Home/John/Dir1/Dir2: $ PATH
/Home/John/Dir1/Dir2 está agora no começo, separado do próximo diretório, com um cólon. Então, com um prompt de “John@host: ~ $”,
John@host: ~ $ Caminho de exportação =/Home/John/Dir1/Dir2: $ PATH
Depois de digitar e pressionar Enter, o comando, comando.exe no diretório, dir2, seria executado com:
John@host: ~ comando.exe
Enquanto o computador não for fechado, o usuário continuará a executar o comando.exe sem digitar o caminho anterior.
Quando o computador é desligado, tudo em memória de acesso aleatório é apagado. A má notícia é que o usuário do computador terá que repetir esse processo de adicionar seu diretório à variável do caminho toda vez que o computador for reiniciado. Ninguém quer fazer isso hoje. Portanto, a abordagem de adição permanente é a abordagem recomendada. Isto é, a adição ao caminho, deve ser salva (no disco rígido).
Adição permanente
Da discussão acima, a idéia é salvar a mudança feita (no disco rígido). Portanto, se a alteração for salva em um arquivo que o shell lê sempre que as botas do computador, isso ficaria bem. Ou seja, cada vez que as botas do computador, a variável do caminho na memória será atualizada adequadamente. Quando um computador começa, na inicialização, ele lê certos arquivos. Um dos arquivos que o shell Bash for Linux lê é: ~//.Bashrc . O nome do arquivo é .Bashrc , começando com o ponto. Está no diretório do usuário.
Bash é apenas uma concha, provavelmente a concha mais popular para Linux, hoje. Outra concha para Linux é Zsh. Com o ZSH, o arquivo correspondente é ~/.ZSHRC, Ainda no diretório do usuário. Quando o shell começa, na inicialização, lê este arquivo. Para Bash, o arquivo é, ~/.Bashrc . Portanto, se o código de adição acima for digitado no ~//.Arquivo Bashrc, o diretório sempre estará na memória, como ~//.O BASHRC sempre o incluirá no caminho, cada vez que as botas de computador. Permanece na memória, até que o computador seja desligado.
Em Bash, ~/.Bashrc é um arquivo oculto, então o uso comum do comando, LS não mostrará. ~/.Bashrc contém alguns comandos Bash (shell). Ubuntu é uma variante do Linux. Ubuntu vem com um editor de texto. No computador do autor, o fundo do editor de texto do Ubuntu é preto.
O comando de adição acima (sem o prompt) deve ser incluído no ~//.Arquivo Bashrc. É bom adicioná -lo no final do arquivo para não temperar com seu conteúdo disponível, que provavelmente está funcionando bem.
Para abrir ~/.Bashrc no Ubuntu, digite o seguinte no prompt de comando no terminal e pressione Enter:
$ nano ~//.Bashrc
Onde nano é o editor de texto. Aqui, Nano é um comando (executável), cujo argumento é, ~/.Bashrc . O conteúdo do arquivo deve abrir no editor de texto para sobrepor a janela do terminal.
O ~//.O arquivo BashRC será aberto no editor de texto, provavelmente com um fundo preto. O cursor estará piscando no canto superior esquerdo.
Pressione a tecla de sepultura no teclado continuamente até que o cursor chegue ao final do arquivo. Adicione uma nova linha de,
$ Caminho de exportação =/Home/John/Dir1/Dir2: $ PATH
Isso não é tudo. A mudança para o ~/.O arquivo Bashrc não foi salvo. Para salvar o arquivo com a alteração feita, pressione Ctrl+O e siga outras instruções que aparecerem. Para sair do editor de texto, pressione Ctrl+X e a janela normal do terminal deve substituir a janela do editor de texto. Outros comandos do shell podem então ser emitidos.
Se "eco $ path" for emitido, o novo diretório não será visto na tela. Existem duas maneiras de continuar a partir daqui: reinicie o computador ou obter o novo conteúdo do ~/.arquivo BashRC na memória com o comando de origem. É simples usar o comando de origem, como segue:
$ fonte ~//.Bashrc
Se o comando de origem for emitido sem reiniciar, "Echo $ Path" mostrará o novo diretório adicionado no resultado (exibição). O comando de interesse pode então ser digitado sem o caminho anterior.
Observação: Não confunda entre o final do valor do caminho (lista) e o final do ~//.Arquivo Bashrc. Além disso, não confunda entre um diretório no caminho na memória e um arquivo executável no diretório no disco rígido.
Conclusão
O caminho é uma variável interna em conchas Linux. O valor do caminho é uma lista de diretórios separados por dois pontos. Existe um comando (arquivo executável) no disco rígido para cada um desses diretórios. Se um comando for emitido na venda sem precedentes com um caminho, o shell analisará esses diretórios para o comando. Se não vir o comando em nenhum dos diretórios, o comando não será executado. Nesse caso, para executar o comando, o comando deve ser precedido com seu caminho. O comando pode estar em mais de um diretório no valor do caminho. Assim que o shell vê o primeiro diretório com o comando, ele executa o comando. O valor do caminho é na verdade uma string que consiste em diretórios separados por colonos.
O problema é como adicionar o diretório para o executável de um novo aplicativo no caminho. Em alguns casos, isso é feito automaticamente pelo programa de instalação do novo aplicativo. Em outros casos, deve ser feito manualmente. Existem duas maneiras de fazê -lo manualmente, referido como: adição temporária e adição permanente. A adição temporária usa o comando de exportação e apenas adiciona o diretório enquanto o computador está ligado. A adição permanente deve salvar a linha de comando de exportação no ~//.Arquivo de inicialização do BASHRC (BASH) para futuras operações.