Comment afficher les chemins dans $ PATH séparément

Je n'arrive pas à comprendre comment lister les différents chemins $PATHséparément afin qu'ils ressemblent à ceci:

/bin
/usr/bin
/usr/local/bin

etc.

Est-ce que quelqu'un sait la bonne variable pour cela?

Essayez sed:

$ sed 's/:/\n/g' <<< "$PATH"

Ou tr:

$ tr ':' '\n' <<< "$PATH"

Ou python:

$ python2 -c "import os; print os.environ['PATH'].replace(':', '\n')"

Ici, tout ce qui précède remplacera toutes les occurrences de :avec de nouvelles lignes \n.

Utilisez les paramètres de bash :

echo "${PATH//:/$'\n'}"

Cette opération remplace toutes :dans $PATHpar un saut de ligne ( \n) et imprime le résultat. Le contenu de $PATHreste inchangé.
Si vous souhaitez uniquement remplacer le premier :, supprimez la deuxième barre oblique:echo -e "${PATH/:/\n}"

Utiliser IFS:

(set -f; IFS=:; printf "%s\n" $PATH)

IFScontient les caractères sur lesquels bash scinde, donc un IFSavec :make fait scinder le développement de $PATHon :. printfboucle les arguments sur la chaîne de format jusqu'à ce qu'ils soient épuisés. Nous devons désactiver la fonction Globbing (extension de caractères génériques) set -fafin que les caractères génériques dans les noms de répertoires PATH ne soient pas développés.

Utilisant xargs:

xargs -n1 -d: <<< $PATH

De man xargs

-n max-args
          Use  at  most  max-args  arguments per command line.

 -d delim
          Input  items  are terminated by the specified character.

Voici l'équivalent en Go:

$ cat path.go
package main

import (
    "fmt"
    "os"
    "strings"
)

func main() {
    for _, p := range strings.Split(os.Getenv("PATH"), ":") {
        fmt.Println(p)
    }
}

$ go run path.go
/usr/local/sbin
/usr/local/bin
/usr/sbin
/usr/bin
/sbin
/bin
/usr/games
/usr/local/games
/snap/bin
/home/nathan/.local/bin
/home/nathan/go/bin

Voici quelques approches supplémentaires. J'utilise un PATHavec des répertoires contenant des barres obliques inverses, des espaces et même une nouvelle ligne pour montrer qu'ils doivent fonctionner avec n'importe quoi (sauf cutcelui qui échoue sur les nouvelles lignes):

$ echo "$PATH"
/bin:usr/bin/:/usr/local/bin:/some\ horrible thing:/even 
new lines

• Quelques manières de Perl:

  $ perl -pe 's/:/\n/g' <<<"$PATH"
  /bin
  usr/bin/
  /usr/local/bin
  /some\ horrible thing
  /even 
  new lines

  Cela -psignifie "imprimer chaque ligne d'entrée après l'application du script donné par -e". Le script utilise l'opérateur de substitution ( s/oldnew/) pour tout remplacer :par des nouvelles lignes.

  $ perl -lne 'print for split /:/' <<<"$PATH"
  /bin
  usr/bin/
  /usr/local/bin
  /some\ horrible thing
  /even 
  new lines

  Le -lajoute une nouvelle ligne à chaque printappel. Ici, le script scinde son entrée :, puis boucle sur chaque élément scindé et l’imprime.

  $ perl -F: -ane '$"="\n";print "@F"' <<<"$PATH"
  /bin
  usr/bin/
  /usr/local/bin
  /some\ horrible thing
  /even 
  new lines

  Les -amarques perlse comportent comme ceci awk: il divisera chacune de ses lignes en entrée sur le caractère donné par -F(donc :, ici) et sauvegardera le résultat dans le tableau @F. Le $"est une variable Perl spéciale, le "séparateur de liste", dont la valeur est imprimée entre chaque élément d'une liste imprimée. Donc, le définir sur une nouvelle ligne fera print @listimprimer chaque élément de @listpuis une nouvelle ligne. Ici, nous l’utilisons pour imprimer @F.

  $ perl -F: -ane 'print join "\n", @F' <<<"$PATH"
  /bin
  usr/bin/
  /usr/local/bin
  /some\ horrible thing
  /even 
  new lines

  Même idée que ci-dessus, un peu moins golfée. Au lieu de l’utiliser $", nous allons explicitement joininsérer le tableau avec des nouvelles lignes, puis l’imprimer.

• Simple grepavec la magie PCRE:

  $ grep -oP '(^|:)\K[^:]+' <<<"$PATH"
  /bin
  usr/bin/
  /usr/local/bin
  /some\ horrible thing
  /even 
  new lines

  Le -ofait d' grepimprimer uniquement la partie correspondante de chaque ligne, de sorte que chaque correspondance est imprimée sur une ligne distincte. Le -Ppermet PCRE (PCRE). La regex recherche des segments de non :( [^:]+) qui suivent le début de la ligne ( ^) ou un :caractère. Il \Ks’agit d’une astuce PCRE qui signifie "jeter tout élément correspondant avant ce point" et qui est utilisée ici pour éviter d’imprimer :aussi.

• Et une cutsolution (celle-ci échoue sur les nouvelles lignes, mais peut traiter les barres obliques inverses et les espaces):

  $ cut -d: -f 1- --output-delimiter=$'\n' <<<"$PATH"
  /bin
  usr/bin/
  /usr/local/bin
  /some\ horrible thing
  /even 
  new lines

  Les options utilisées permettent de -d:définir le délimiteur d'entrée sur :, -f 1-ce qui signifie d'imprimer tous les champs (du premier au dernier) et de --output-delimiter=$'\n'définir le délimiteur de sortie. Le $'\n'est cité ANSI C et est un moyen d'imprimer un caractère de nouvelle ligne dans la coquille.

Dans tous les exemples ci-dessus, j'utilise l' opérateur string ( <<<) de bash (et de certains autres shells ) pour transmettre une chaîne en tant qu'entrée à un programme. Donc command <<<"foo"est équivalent à echo -n "foo" | command. Notez que je cite toujours "$PATH", sans les guillemets, le shell aurait mangé le caractère de nouvelle ligne.

@ 7stud a donné une autre approche dans les commentaires qu'il est trop bon de ne pas inclure:

$ perl -0x3a -l012 -pe '' <<<"$PATH"

C'est ce qu'on appelle le golf . Le -0spécifie le séparateur d'enregistrement d'entrée en tant que nombre octal ou hexadécimal. C'est ce qui définit une "ligne" et sa valeur par défaut est \nun caractère de nouvelle ligne. Ici, nous mettons cela à un :qui est x3aen hexadécimal (essayez printf '\x3a\n'). Le -lfait trois choses. Tout d'abord, il supprime le séparateur d'enregistrement d'entrée ( $/) à la fin de chaque ligne (ce qui supprime effectivement le :here), et deuxièmement, il définit le séparateur d'enregistrement de sortie ( $\) sur la valeur octale ou hexadécimale qui lui est donnée ( 012is \n). Si $\est défini, il est ajouté à la fin de chaque printappel, ainsi une nouvelle ligne sera ajoutée à chacun print.

La -pevolonté p Rint chaque ligne d'entrée après l' application du script donné par -e. Ici, il n'y a pas de script car tout le travail est effectué avec l'option flags comme décrit ci-dessus!

La seule façon de ne pas avoir été mentionnée est la façon dont je l'utilise depuis des années:

echo $PATH | tr ":" "\n"

alors, dans votre .profile ou .bash_profile ou autre, vous pouvez ajouter:

alias path='echo $PATH | tr ":" "\n"'

Dans cette réponse:

1. C
2. Python
3. Rubis
4. Awk alternative

1. C

Comme tous les langages de script ont déjà été utilisés, je vais utiliser C. Il est assez facile d’obtenir des variables d’environnement avec une get_env()fonction (voir la documentation de la bibliothèque GNU C ). Le reste est simplement une manipulation de personnage

bash-4.3$ cat get_path.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
    char *path = getenv("PATH");
    int length = strlen(path) -1;
    for(int i=0;i<=length;i++){
        if (path[i] == ':')
            path[i] = '\n';
        printf("%c",path[i]);
    }
    printf("\n");
    return 0;
}
bash-4.3$ gcc get_path.c
bash-4.3$ ./a.out 
/home/xieerqi/bin
/usr/local/sbin
/usr/local/bin
/usr/sbin
/usr/bin
/sbin
/bin
/usr/games
/usr/local/games
/snap/bin
/opt/microchip/xc16/v1.25/bin
/opt/microchip/xc32/v1.40/bin
/opt/microchip/xc8/v1.35/bin
/home/xieerqi/bin
/home/xieerqi/bin/sh

2. Python

Mais aussi parce que "pourquoi pas", voici la version alternative de Python via des arguments en ligne de commande sys.argv

python -c 'import sys; print "\n".join(sys.argv[1].split(":"))' "$PATH"

3. rubis

Ruby ne vient pas avec Ubuntu par défaut, contrairement au compilateur C et à l'interpréteur Python, mais si jamais vous vous retrouviez à l'utiliser, la solution dans Ruby serait la suivante:

ruby -ne 'puts $_.split(":")' <<< "$PATH"

Comme suggéré par 7stud (Merci beaucoup!) Dans les commentaires , cela peut aussi être raccourci avec

ruby -F: -ane 'puts $F' <<<$PATH

et de cette façon

ruby -0072 -ne 'puts chomp' <<<$PATH

4. Alternative awk

Nous pouvons utiliser la split()fonction pour décomposer la ligne lue en tableau, et utiliser la for-eachboucle pour imprimer chaque élément sur une ligne séparée.

awk '{split($0,arr,":"); for(var in arr) print arr[var]}' <<< $PATH

Nous avons besoin de plus de Java!

public class GetPathByLine {
    public static void main(String[] args) {
        for (String p : System.getenv("PATH").split(":")) {
            System.out.println(p);
        }
    }
}

Enregistrez ceci dans GetPathByLine.javaet compilez en utilisant:

javac GetPathByLine.java

Courir avec:

java GetPathByLine

┌─[17:06:55]─[kazwolfe@BlackHawk]
└──> ~ $ cat GetPathByLine.java 
public class GetPathByLine {
    public static void main(String[] args) {
        for (String p : System.getenv("PATH").split(":")) {
            System.out.println(p);
        }
    }
}
┌─[17:06:58]─[kazwolfe@BlackHawk]
└──> ~ $ javac GetPathByLine.java 
┌─[17:07:02]─[kazwolfe@BlackHawk]
└──> ~ $ java GetPathByLine 
/usr/local/sbin
/usr/local/bin
/usr/sbin
/usr/bin
/sbin
/bin
/usr/games
/usr/local/games
/snap/bin

À travers awk.

echo $PATH | awk -F: '{for(i=1;i<=NF;i++)print $i}'

À travers le python.

$ echo $PATH | python3 -c 'import fileinput
for line in fileinput.input():
    for i in line.split(":"):
        print(i)'

Notez que l'indentation est très important en python.

J'utilise les "Bash Path Functions" de Stephen Collyer (voir son article dans Linux Journal ). Cela me permet d'utiliser la "liste séparée par des deux-points" comme type de données dans la programmation shell. Par exemple, je peux produire une liste de tous les répertoires du répertoire actuel en:

dirs="";for i in * ; do if [ -d $i ] ; then addpath -p dirs $i; fi; done  

Ensuite, listpath -p dirsproduit une liste.

Explication de la réponse @Cyrus

echo "${PATH//:/$'\n'}"

Remarques:

Citation ANSI-C - cela explique $ 'some \ ntext'

Shell Parameter Expansion - explique $ {paramètre / modèle / chaîne}. Si le modèle commence par '/', toutes les correspondances de modèle sont remplacées par une chaîne.

Nous avons donc:

1. un motif /: commençant par '/' pour remplacer toutes les correspondances
2. une chaîne $ '\ n' qui est citée avec la contraction $ 'anytext' pour traiter le symbole de nouvelle ligne (\ n).

Une autre méthode AWK consiste à traiter chaque répertoire comme un enregistrement séparé plutôt que comme un champ séparé .

awk 'BEGIN{RS=":"} {print $0}' <<<"$PATH"

Je trouve cette syntaxe particulièrement intuitive. Mais, si vous le souhaitez, vous pouvez le raccourcir en rendant l’ print $0implicite (c’est l’action par défaut, elle 1vaut true, elle est exécutée pour chaque ligne):

awk 'BEGIN{RS=":"} 1' <<<"$PATH"

Le séparateur d'enregistrement par défaut d'entrée et de sortie d'AWK est la nouvelle ligne (saut de ligne). En définissant le séparateur d’enregistrement d’entrée ( RS) sur :avant de lire l’entrée, AWK analyse automatiquement un séparateur deux-points $PATHdans ses noms de répertoire constitutent. AWK s'étend $0à chaque enregistrement entier, la nouvelle ligne reste le séparateur d'enregistrement de sortie et aucune boucle gsubn'est nécessaire.

ek@Io:~$ echo "$PATH"
/home/ek/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin
ek@Io:~$ awk 'BEGIN{RS=":"} {print $0}' <<<"$PATH"
/home/ek/bin
/usr/local/sbin
/usr/local/bin
/usr/sbin
/usr/bin
/sbin
/bin
/usr/games
/usr/local/games
/snap/bin

AWK est souvent utilisé pour analyser des enregistrements dans des champs distincts, mais il n'est pas nécessaire de créer une liste de noms de répertoires.

Cela fonctionne même pour les entrées contenant des espaces (espaces et tabulations), voire plusieurs espaces consécutifs:

ek@Io:~$ awk 'BEGIN{RS=":"} {print $0}' <<<$'ab\t\t c:de    fg:h'
ab               c
de    fg
h

Autrement dit, à moins que AWK reconstruise l’enregistrement (voir ci-dessous), il n’ya aucun problème à avoir des espaces ou des tabulations (les séparateurs de champs par défaut) dans l’entrée. Votre PATHprobablement ne contient pas d'espaces sur un système Ubuntu, mais si c'est le cas, cela fonctionnera toujours.

Il convient de noter, en guise de remarque, que la capacité d'AWK d'interpréter un enregistrement en tant que collection de champs devient utile pour le problème connexe de la construction d'une table de composants de répertoire :

ek@Io:~$ awk -F/ 'BEGIN{RS=":"; OFS="\t"} {$1=$1; print $0}' <<<"$PATH"
        home    ek      bin
        usr     local   sbin
        usr     local   bin
        usr     sbin
        usr     bin
        sbin
        bin
        usr     games
        usr     local   games
        snap    bin

La $1=$1tâche curieuse sert à forcer AWK à reconstruire l'enregistrement .

(Ceci est probablement plus utile dans les cas où un traitement supplémentaire doit être effectué sur les composants, plutôt que dans l'exemple exact de la simple impression du tableau.)

jq -Rr 'gsub(":";"\n")' <<<$PATH

Comment afficher les chemins dans $ PATH séparément

Ce sont mes méthodes préférées pour ce faire, en fonction de mes cas d'utilisation respectifs et de mes préoccupations concernant la compatibilité et l'utilisation des ressources.

tr

Tout d’abord, si vous avez besoin d’une solution rapide, facile à mémoriser et lisible, il suffit de lui envoyer un message d’écho PATHpour qu’elle traduise ( tr) afin de transformer les deux points en nouvelles lignes:

echo $PATH | tr : "\n"

Il y a l'inconvénient d'utiliser deux processus en raison de la canalisation, mais si nous ne faisons que pirater un terminal, en sommes-nous vraiment préoccupés?

Expansion des paramètres du shell de Bash

Si vous souhaitez une solution relativement permanente dans votre .bashrcutilisation interactive, vous pouvez aliaser la commande suivante path, mais la lisibilité de cette solution est discutable:

alias path="echo \"${PATH//:/$'\n'}\""

Si motif commence par '/', toutes les correspondances de motif sont remplacées par une chaîne. Normalement, seul le premier match est remplacé.

La commande ci-dessus remplace les deux-points par des nouvelles lignes à l'aide de l' extension des paramètres de shell de Bash :

${parameter/pattern/string}

Pour l'expliquer:

          # v--v---------delimiters, a'la sed
echo "${PATH//:/$'\n'}"
          #  ^^ ^^^^^----string, $ required to get newline character.
          #   \----------pattern, / required to substitute for *every* :.

Bonne chance de vous en souvenir lorsque vous vous contentez de pirater la ligne de commande, si vous ne l'avez pas encore aliasée.

IFS, testé en bash et dash

Alternativement, une approche relativement compatible, lisible et compréhensible qui ne repose pas sur autre chose que le shell utilise la fonction suivante (je suggère dans votre .bashrc.)

La fonction suivante transforme temporairement le séparateur de champs interne (ou d'entrée) en deux points, et lorsqu'un tableau est attribué à printf, il s'exécute jusqu'à son épuisement:

path () {
    local IFS=:
    printf "%s\n" ${PATH}
    }

Cette méthode de création de fonctions , IFSet printfsont fournis par posix, donc il devrait fonctionner dans la plupart posix comme des coquilles ( en particulier Dash, qui Ubuntu généralement alias comme sh).

Python

Devez-vous utiliser Python pour cela? Vous pourriez. C’est la commande Python la plus courte à laquelle je puisse penser:

python -c "print('\n'.join('${PATH}'.split(':')))"

ou seulement Python 3 (et peut-être plus lisible?):

python3 -c "print(*'${PATH}'.split(':'), sep='\n')"

Celles-ci devraient également fonctionner dans n’importe quel environnement shell habituel, tant que vous avez Python.

Cette solution est plus simple que les solutions Java , C , go and awk :

$ LPATH=$PATH wine cmd /c echo %LPATH::=$'\n'% 2> /dev/null
/usr/local/bin
/usr/local/sbin
/usr/bin
/usr/sbin

Voici une autre grande possibilité:

$ jrunscript -classpath /usr/share/java/bsh.jar -e 'print(java.lang.System.getenv("PATH").replaceAll(":","\n"))'
/usr/local/bin
/usr/local/sbin
/usr/bin
/usr/sbin

Cela nécessiterait l'installation de certaines dépendances:

sudo apt-get install openjdk-8-jdk-headless bsh