Как отображать пути в $ PATH отдельно

Использовать расширение параметра bash:

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

Использование IFS:

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

IFS содержит символы, на которых bash расщепляется, поэтому IFS с : заставляет bash разделить расширение $PATH на : , printf помещает аргументы в строку формата до тех пор, пока аргументы не будут исчерпаны. Нам нужно отключить globbing (расширение подстановки) с помощью set -f, чтобы подстановочные знаки в именах каталогов PATH не расширялись.

Использование xargs:

xargs -n1 -d: <<< $PATH

Из man xargs

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

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

Вот эквивалент в 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

Вот еще несколько подходов. Я использую PATH с каталогами, содержащими обратную косую черту, пробелы и даже новую строку, чтобы показать, что они должны работать с чем угодно (кроме cut, который не работает на символах новой строки):

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

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

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

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

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

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

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

Во всех приведенных выше примерах я использую оператор bash (и некоторые другие оболочки) здесь string (<<<) для передачи строки в качестве ввода в программу. Таким образом, command <<<"foo" эквивалентен echo -n "foo" | command. Обратите внимание, что я всегда цитирую "$PATH", без кавычек оболочка бы съела символ новой строки.

здесь строка дала другой подход в комментариях, который слишком хорош, чтобы не включать:

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

Это то, что известно как комментарии . [F50] определяет разделитель входных данных как восьмеричное или шестнадцатеричное число. Это то, что определяет «строку», а значение по умолчанию - \n, символ новой строки. Здесь мы устанавливаем его в :, который является x3a в шестнадцатеричном формате (try printf '\x3a\n'). [F55] делает три вещи. Сначала он удаляет разделитель входных записей ($/) с конца каждой строки, эффективно удаляя : здесь - и во-вторых, устанавливает разделитель выходной записи ($\) на любое восьмеричное или шестнадцатеричное значение, которое оно задано (012 - \n). Если $\ определен, он добавляется к концу каждого вызова print, поэтому это приведет к добавлению новой строки к каждому print.

-pe будет печатать каждую строку ввода после применения сценария, заданного -e. Здесь нет сценария, потому что вся работа выполняется флажками параметров, как описано выше!

В этом ответе:

1. C

Поскольку все языки сценариев уже приняты, я перейду к C. Очень легко получить переменные среды с помощью функции get_env() (см. Документацию библиотеки GNU C). Остальное - это просто манипуляция персонажами

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

Но также и потому, что «почему бы нет», вот альтернативная версия python через аргументы командной строки sys.argv

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

3. Ruby

Ruby не работает с Ubuntu по умолчанию, в отличие от C-компилятора и интерпретатора Python, но если вы когда-нибудь захотите его использовать, решение в Ruby будет следующим:

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

Как было предложено 7stud (Большое спасибо!) в документации GNU C Library , это также можно сократить с помощью

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

и таким образом

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

4. Альтернативный awk

Мы можем использовать функцию split() для разбивки строки, считанной в массив, и использовать цикл for-each для печати каждого элемента в отдельной строке.

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

Вероятно, единственный способ, о котором не упоминалось, - это то, как я использовал его в течение многих лет:

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

, поэтому в вашем .profile или. bash_profile или что-то еще, вы можете добавить:

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

Через awk.

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

Через python.

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

Обратите внимание, что отступ очень важен для python.

Нам нужно больше Java!

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

Сохраните это значение в GetPathByLine.java и скомпилируйте, используя:

javac GetPathByLine.java

Запустите с помощью:

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

Я использую «Функции пути Bash Path» Стивена Коллиера (см. его статью в Журнале Linux). Это позволяет мне использовать «разделенный двоеточиями список» в качестве типа данных в программировании оболочки. Например, я могу создать список всех каталогов в текущем каталоге:

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

Затем listpath -p dirs создает список.

Другой способ AWK - рассматривать каждый каталог как отдельную запись, а не как отдельное поле.

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

Я нахожу этот синтаксис особенно интуитивным. Но, если хотите, вы можете сократить его, сделав print $0 неявным (это действие по умолчанию, а 1 оценивается как true, что приведет к его выполнению для каждой строки):

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

Разделитель входных и выходных данных по умолчанию AWK - это новая строка (разрыв строки). Установив разделитель входных данных (RS) на : перед чтением ввода, AWK автоматически анализирует разграниченный двоеточием $PATH в его именах constitentent. AWK расширяет $0 до каждой целой записи, новая строка остается разделителем записи записи , и не требуется цикл или gsub.

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 часто используется для (! d6)

Это работает даже для ввода, содержащего пробелы (пробелы и табуляции), даже несколько последовательных пробелов:

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

То есть, если вы не заставите AWK перестроить запись (см. ниже), нет проблем с наличием пробелов или вкладок (разделителей полей по умолчанию) на входе. Ваш PATH, вероятно, не содержит пробелов в системе Ubuntu, но если это произойдет, это все равно будет работать.

Стоит упомянуть в качестве примечания, что AWK способность интерпретировать запись как коллекцию полей rebuild , полезная для связанной задачи построения таблицы каталога field :

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

Любопытный Назначение $1=$1 служит для принудительного восстановления AWK для записи записи.

(Это, вероятно, более полезно для случаев, когда дополнительная обработка должна выполняться на компонентах, чем для точного примера, показанного просто для печати таблицу.)

Объяснение для ответа @Cyrus

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

Примечания:

ANSI-C Quoting - он объясняет $ 'some \ ntext'

ANSI-C Quoting - объясняет $ {parameter / pattern / string}. Если шаблон начинается с '/', все совпадения шаблона заменяются строкой.

Итак, у нас есть: