Как манипулировать элементами $PATH в сценариях оболочки?

https://stackoverflow.com/questions/273909

07-07-2019
|

Вопрос

Есть ли идиоматический способ удаления элементов из переменных оболочки типа PATH?

То есть я хочу взять

PATH=/home/joe/bin:/usr/local/bin:/usr/bin:/bin:/path/to/app/bin:.

и удалять или заменять тот /path/to/app/bin не затирая остальную часть переменной.Дополнительные баллы за то, что позволили мне помещать новые элементы в произвольных позициях.Цель будет распознаваться по четко определенной строке и может находиться в любой точке списка.

Я знаю, что видел, как это делается, и, вероятно, смогу что-то собрать самостоятельно, но я ищу хороший подход.Портативность и стандартизация являются плюсом.

Я использую bash, но примеры приветствуются и в вашей любимой оболочке.

Здесь речь идет о необходимости удобного переключения между несколькими версиями (одна для анализа, другая для работы над платформой) большого пакета научного анализа, который создает пару десятков исполняемых файлов, хранит данные в файловой системе и использует переменную среды. чтобы помочь найти все это.Я хотел бы написать сценарий, который выбирает версию, и мне нужно иметь возможность удалить $PATH элементы, относящиеся к текущей активной версии, и замените их теми же элементами, относящимися к новой версии.

Это связано с проблемой предотвращения повторных $PATH элементы при повторном запуске сценариев входа в систему и тому подобное.

Предыдущий аналогичный вопрос: Как избежать дублирования переменной пути в csh
Последующий аналогичный вопрос: Какой самый элегантный способ удалить путь из переменной $PATH в Bash?

Решение

Обращение к предлагаемому решению от dmckee:

Хотя некоторые версии Bash допускают использование дефисов в именах функций, другие (MacOS X) — нет.
Я не вижу необходимости использовать return непосредственно перед завершением функции.
Я не вижу необходимости во всех точках с запятой.
Я не понимаю, почему вы экспортируете значение поэлементно по шаблону.Думать о export как эквивалент установки (или даже создания) глобальной переменной — чего следует избегать, когда это возможно.
Я не уверен, чего ты ожидаешь »replace-path PATH $PATH /usr', но он не делает того, чего я ожидал.

Рассмотрим значение PATH, которое начинается с:

.
/Users/jleffler/bin
/usr/local/postgresql/bin
/usr/local/mysql/bin
/Users/jleffler/perl/v5.10.0/bin
/usr/local/bin
/usr/bin
/bin
/sw/bin
/usr/sbin
/sbin

Результат, который я получил (от 'replace-path PATH $PATH /usr') является:

.
/Users/jleffler/bin
/local/postgresql/bin
/local/mysql/bin
/Users/jleffler/perl/v5.10.0/bin
/local/bin
/bin
/bin
/sw/bin
/sbin
/sbin

Я ожидал вернуть свой исходный путь, поскольку /usr не отображается как (полный) элемент пути, а только как часть элемента пути.

Это можно исправить в replace-path изменив один из sed команды:

export $path=$(echo -n $list | tr ":" "\n" | sed "s:^$removestr\$:$replacestr:" |
               tr "\n" ":" | sed "s|::|:|g")

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

PATH=/bin::/usr/local/bin

После обработки текущий каталог больше не будет находиться в PATH.

Аналогичное изменение для привязки совпадения уместно в path-element-by-pattern:

export $target=$(echo -n $list | tr ":" "\n" | grep -m 1 "^$pat\$")

Замечу попутно, что grep -m 1 не является стандартным (это расширение GNU, также доступное в MacOS X).И действительно,-n вариант для echo также нестандартен;вам лучше просто удалить завершающее двоеточие, которое добавляется в результате преобразования новой строки из echo в двоеточие.Поскольку элемент пути по шаблону используется только один раз, это имеет нежелательные побочные эффекты (он затирает любую ранее существовавшую экспортированную переменную, называемую $removestr), его можно разумно заменить своим телом.Это, наряду с более свободным использованием кавычек во избежание проблем с пробелами или нежелательным расширением имени файла, приводит к:

# path_tools.bash
#
# A set of tools for manipulating ":" separated lists like the
# canonical $PATH variable.
#
# /bin/sh compatibility can probably be regained by replacing $( )
# style command expansion with ` ` style
###############################################################################
# Usage:
#
# To remove a path:
#    replace_path         PATH $PATH /exact/path/to/remove
#    replace_path_pattern PATH $PATH <grep pattern for target path>
#
# To replace a path:
#    replace_path         PATH $PATH /exact/path/to/remove /replacement/path
#    replace_path_pattern PATH $PATH <target pattern> /replacement/path
#
###############################################################################

# Remove or replace an element of $1
#
#   $1 name of the shell variable to set (e.g. PATH)
#   $2 a ":" delimited list to work from (e.g. $PATH)
#   $3 the precise string to be removed/replaced
#   $4 the replacement string (use "" for removal)
function replace_path () {
    path=$1
    list=$2
    remove=$3
    replace=$4        # Allowed to be empty or unset

    export $path=$(echo "$list" | tr ":" "\n" | sed "s:^$remove\$:$replace:" |
                   tr "\n" ":" | sed 's|:$||')
}

# Remove or replace an element of $1
#
#   $1 name of the shell variable to set (e.g. PATH)
#   $2 a ":" delimited list to work from (e.g. $PATH)
#   $3 a grep pattern identifying the element to be removed/replaced
#   $4 the replacement string (use "" for removal)
function replace_path_pattern () {
    path=$1
    list=$2
    removepat=$3
    replacestr=$4        # Allowed to be empty or unset

    removestr=$(echo "$list" | tr ":" "\n" | grep -m 1 "^$removepat\$")
    replace_path "$path" "$list" "$removestr" "$replacestr"
}

У меня есть Perl-скрипт под названием echopath что я считаю полезным при отладке проблем с переменными типа PATH:

#!/usr/bin/perl -w
#
#   "@(#)$Id: echopath.pl,v 1.7 1998/09/15 03:16:36 jleffler Exp $"
#
#   Print the components of a PATH variable one per line.
#   If there are no colons in the arguments, assume that they are
#   the names of environment variables.

@ARGV = $ENV{PATH} unless @ARGV;

foreach $arg (@ARGV)
{
    $var = $arg;
    $var = $ENV{$arg} if $arg =~ /^[A-Za-z_][A-Za-z_0-9]*$/;
    $var = $arg unless $var;
    @lst = split /:/, $var;
    foreach $val (@lst)
    {
            print "$val\n";
    }
}

Когда я запускаю измененное решение в тестовом коде ниже:

echo
xpath=$PATH
replace_path xpath $xpath /usr
echopath $xpath

echo
xpath=$PATH
replace_path_pattern xpath $xpath /usr/bin /work/bin
echopath xpath

echo
xpath=$PATH
replace_path_pattern xpath $xpath "/usr/.*/bin" /work/bin
echopath xpath

Результат:

.
/Users/jleffler/bin
/usr/local/postgresql/bin
/usr/local/mysql/bin
/Users/jleffler/perl/v5.10.0/bin
/usr/local/bin
/usr/bin
/bin
/sw/bin
/usr/sbin
/sbin

.
/Users/jleffler/bin
/usr/local/postgresql/bin
/usr/local/mysql/bin
/Users/jleffler/perl/v5.10.0/bin
/usr/local/bin
/work/bin
/bin
/sw/bin
/usr/sbin
/sbin

.
/Users/jleffler/bin
/work/bin
/usr/local/mysql/bin
/Users/jleffler/perl/v5.10.0/bin
/usr/local/bin
/usr/bin
/bin
/sw/bin
/usr/sbin
/sbin

Мне это кажется правильным - по крайней мере, для моего определения проблемы.

Я отмечаю, что echopath LD_LIBRARY_PATH оценивает $LD_LIBRARY_PATH.Было бы неплохо, если бы ваши функции могли это сделать, чтобы пользователь мог набрать:

replace_path PATH /usr/bin /work/bin

Это можно сделать с помощью:

list=$(eval echo '$'$path)

Это приводит к такой редакции кода:

# path_tools.bash
#
# A set of tools for manipulating ":" separated lists like the
# canonical $PATH variable.
#
# /bin/sh compatibility can probably be regained by replacing $( )
# style command expansion with ` ` style
###############################################################################
# Usage:
#
# To remove a path:
#    replace_path         PATH /exact/path/to/remove
#    replace_path_pattern PATH <grep pattern for target path>
#
# To replace a path:
#    replace_path         PATH /exact/path/to/remove /replacement/path
#    replace_path_pattern PATH <target pattern> /replacement/path
#
###############################################################################

# Remove or replace an element of $1
#
#   $1 name of the shell variable to set (e.g. PATH)
#   $2 the precise string to be removed/replaced
#   $3 the replacement string (use "" for removal)
function replace_path () {
    path=$1
    list=$(eval echo '$'$path)
    remove=$2
    replace=$3            # Allowed to be empty or unset

    export $path=$(echo "$list" | tr ":" "\n" | sed "s:^$remove\$:$replace:" |
                   tr "\n" ":" | sed 's|:$||')
}

# Remove or replace an element of $1
#
#   $1 name of the shell variable to set (e.g. PATH)
#   $2 a grep pattern identifying the element to be removed/replaced
#   $3 the replacement string (use "" for removal)
function replace_path_pattern () {
    path=$1
    list=$(eval echo '$'$path)
    removepat=$2
    replacestr=$3            # Allowed to be empty or unset

    removestr=$(echo "$list" | tr ":" "\n" | grep -m 1 "^$removepat\$")
    replace_path "$path" "$removestr" "$replacestr"
}

Следующий пересмотренный тест теперь тоже работает:

echo
xpath=$PATH
replace_path xpath /usr
echopath xpath

echo
xpath=$PATH
replace_path_pattern xpath /usr/bin /work/bin
echopath xpath

echo
xpath=$PATH
replace_path_pattern xpath "/usr/.*/bin" /work/bin
echopath xpath

Он производит тот же результат, что и раньше.

Другие советы

Делаю репост моего ответа на Какой самый элегантный способ удалить путь из переменной $PATH в Bash? :

#!/bin/bash
IFS=:
# convert it to an array
t=($PATH)
unset IFS
# perform any array operations to remove elements from the array
t=(${t[@]%%*usr*})
IFS=:
# output the new array
echo "${t[*]}"

или однострочный:

PATH=$(IFS=':';t=($PATH);unset IFS;t=(${t[@]%%*usr*});IFS=':';echo "${t[*]}");

Для удаления элемента вы можете использовать sed:

#!/bin/bash
NEW_PATH=$(echo -n $PATH | tr ":" "\n" | sed "/foo/d" | tr "\n" ":")
export PATH=$NEW_PATH

удалит пути, содержащие «foo».

Вы также можете использовать sed для вставки новой строки до или после заданной строки.

Редактировать:вы можете удалить дубликаты, пройдя через sort и uniq:

echo -n $PATH | tr ":" "\n" | sort | uniq -c | sed -n "/ 1 / s/.*1 \(.*\)/\1/p" | sed "/foo/d" | tr "\n" ":"

В ответах на "Как избежать дублирования переменной пути в csh".Они больше концентрируются на обеспечении отсутствия повторяющихся элементов, но предоставленный мной сценарий можно использовать как:

export PATH=$(clnpath $head_dirs:$PATH:$tail_dirs $remove_dirs)

Предполагая, что у вас есть один или несколько каталогов в $head_dirs, один или несколько каталогов в $tail_dirs и один или несколько каталогов в $remove_dirs, затем он использует оболочку для объединения головной, текущей и хвостовой частей в массивное значение, а затем удаляет каждую из них. каталогов, перечисленных в $remove_dirs из результата (это не ошибка, если они не существуют), а также исключение второго и последующих вхождений любого каталога в пути.

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

Просто обратите внимание, что bash сам может выполнять поиск и замену.Он может выполнять все обычные действия «один раз или все», в деликатных случаях, которые вы ожидаете.

Со страницы руководства:

${параметр/шаблон/строка}

Шаблон расширяется для создания шаблона, как и при расширении имени пути.Параметр расширяется, и самое длинное совпадение шаблона с его значением заменяется строкой.Если Ipattern начинается с /, все совпадения шаблона заменяются строкой.Обычно заменяется только первое совпадение.Если шаблон начинается с #, он должен соответствовать началу расширенного значения параметра.Если шаблон начинается с %, он должен соответствовать концу расширенного значения параметра.Если строка равна нулю, совпадения с шаблоном удаляются, а следующий шаблон / можно опустить.Если параметр @ или *, операция замены применяется к каждому позиционному параметру по очереди, а расширение является результирующей списком.Если параметр является переменной массивы, подписываемой с @ или *, операция замены применяется к каждому члену массива по очереди, а расширение является результирующим списком.

Вы также можете выполнить разделение полей, установив $IFS (разделитель входных полей) на нужный разделитель.

ОК, спасибо всем ответившим.Я подготовил инкапсулированную версию ответа Флорина.Первый проход выглядит так:

# path_tools.bash
#
# A set of tools for manipulating ":" separated lists like the
# canonical $PATH variable.
#
# /bin/sh compatibility can probably be regained by replacing $( )
# style command expansion with ` ` style
###############################################################################
# Usage:
#
# To remove a path:
#    replace-path         PATH $PATH /exact/path/to/remove    
#    replace-path-pattern PATH $PATH <grep pattern for target path>    
#
# To replace a path:
#    replace-path         PATH $PATH /exact/path/to/remove /replacement/path   
#    replace-path-pattern PATH $PATH <target pattern> /replacement/path
#    
###############################################################################
# Finds the _first_ list element matching $2
#
#    $1 name of a shell variable to be set
#    $2 name of a variable with a path-like structure
#    $3 a grep pattern to match the desired element of $1
function path-element-by-pattern (){ 
    target=$1;
    list=$2;
    pat=$3;

    export $target=$(echo -n $list | tr ":" "\n" | grep -m 1 $pat);
    return
}

# Removes or replaces an element of $1
#
#   $1 name of the shell variable to set (i.e. PATH) 
#   $2 a ":" delimited list to work from (i.e. $PATH)
#   $2 the precise string to be removed/replaced
#   $3 the replacement string (use "" for removal)
function replace-path () {
    path=$1;
    list=$2;
    removestr=$3;
    replacestr=$4; # Allowed to be ""

    export $path=$(echo -n $list | tr ":" "\n" | sed "s|$removestr|$replacestr|" | tr "\n" ":" | sed "s|::|:|g");
    unset removestr
    return 
}

# Removes or replaces an element of $1
#
#   $1 name of the shell variable to set (i.e. PATH) 
#   $2 a ":" delimited list to work from (i.e. $PATH)
#   $2 a grep pattern identifying the element to be removed/replaced
#   $3 the replacement string (use "" for removal)
function replace-path-pattern () {
    path=$1;
    list=$2;
    removepat=$3; 
    replacestr=$4; # Allowed to be ""

    path-element-by-pattern removestr $list $removepat;
    replace-path $path $list $removestr $replacestr;
}

Все еще требуется перехват ошибок во всех функциях, и мне, вероятно, следует придерживаться решения с повторяющимся путем, пока я этим занимаюсь.

Вы используете его, выполняя . /include/path/path_tools.bash в рабочем сценарии и вызове replace-path* функции.

Я все еще открыт для новых и/или лучших ответов.

Это легко сделать с помощью awk.

Заменять

{
  for(i=1;i<=NF;i++) 
      if($i == REM) 
          if(REP)
              print REP; 
          else
              continue;
      else 
          print $i; 
}

Запустите его, используя

function path_repl {
    echo $PATH | awk -F: -f rem.awk REM="$1" REP="$2" | paste -sd:
}

$ echo $PATH
/bin:/usr/bin:/home/js/usr/bin
$ path_repl /bin /baz
/baz:/usr/bin:/home/js/usr/bin
$ path_repl /bin
/usr/bin:/home/js/usr/bin

Добавить

Вставляется в заданную позицию.По умолчанию он добавляется в конце.

{ 
    if(IDX < 1) IDX = NF + IDX + 1
    for(i = 1; i <= NF; i++) {
        if(IDX == i) 
            print REP 
        print $i
    }
    if(IDX == NF + 1)
        print REP
}

Запустите его, используя

function path_app {
    echo $PATH | awk -F: -f app.awk REP="$1" IDX="$2" | paste -sd:
}

$ echo $PATH
/bin:/usr/bin:/home/js/usr/bin
$ path_app /baz 0
/bin:/usr/bin:/home/js/usr/bin:/baz
$ path_app /baz -1
/bin:/usr/bin:/baz:/home/js/usr/bin
$ path_app /baz 1
/baz:/bin:/usr/bin:/home/js/usr/bin

Удалить дубликаты

Этот сохраняет первые вхождения.

{ 
    for(i = 1; i <= NF; i++) {
        if(!used[$i]) {
            print $i
            used[$i] = 1
        }
    }
}

Начните это так:

echo $PATH | awk -F: -f rem_dup.awk | paste -sd:

Проверьте, существуют ли все элементы

Следующий код выведет сообщение об ошибке для всех записей, которых нет в файловой системе, и вернет ненулевое значение.

echo -n $PATH | xargs -d: stat -c %n

Чтобы просто проверить, являются ли все элементы путями, и получить код возврата, вы также можете использовать test:

echo -n $PATH | xargs -d: -n1 test -d

предполагать

echo $PATH
/usr/lib/jvm/java-1.6.0/bin:lib/jvm/java-1.6.0/bin/:/lib/jvm/java-1.6.0/bin/:/usr/lib/qt-3.3/bin:/usr/lib/ccache:/usr/local/bin:/usr/bin:/bin:/usr/local/sbin:/usr/sbin:/sbin:/home/tvnadeesh/bin

Если вы хотите удалить /lib/jvm/java-1.6.0/bin/, сделайте следующее:

export PATH=$(echo $PATH | sed  's/\/lib\/jvm\/java-1.6.0\/bin\/://g')

sed примет данные от echo $PATH и замените /lib/jvm/java-1.6.0/bin/:с пустым

таким образом вы можете удалить

Порядок PATH не нарушен
Грамотно обрабатывает угловые случаи, такие как пустой путь, пробелы в пути.
Частичное совпадение dir не дает ложных срабатываний
Правильно обрабатывает путь в начале и конце PATH.Нет : мусор и все такое.

Скажем, у вас есть/foo:/some/path:/some/path/dir1:/some/path/dir2:/bar, и вы хотите заменить/немного/path, затем он правильно заменяет «/немного/path», но уходит "// Некоторые/path/dir1 "или"/some/path/dir2 ", как вы ожидаете.

function __path_add(){  
    if [ -d "$1" ] ; then  
        local D=":${PATH}:";   
        [ "${D/:$1:/:}" == "$D" ] && PATH="$PATH:$1";  
        PATH="${PATH/#:/}";  
        export PATH="${PATH/%:/}";  
    fi  
}
function __path_remove(){  
    local D=":${PATH}:";  
    [ "${D/:$1:/:}" != "$D" ] && PATH="${D/:$1:/:}";  
    PATH="${PATH/#:/}";  
    export PATH="${PATH/%:/}";  
}  
# Just for the shake of completeness
function __path_replace(){  
    if [ -d "$2" ] ; then  
        local D=":${PATH}:";   
        if [ "${D/:$1:/:}" != "$D" ] ; then
            PATH="${D/:$1:/:$2:}";  
            PATH="${PATH/#:/}";  
            export PATH="${PATH/%:/}";  
        fi
    fi  
}

Связанный постКакой самый элегантный способ удалить путь из переменной $PATH в Bash?

В наши дни я предпочитаю использовать Ruby, а не awk/sed/foo, поэтому вот мой подход к борьбе с обманщиками:

# add it to the path
PATH=~/bin/:$PATH:~/bin
export PATH=$(ruby -e 'puts ENV["PATH"].split(/:/).uniq.join(":")')

создать функцию для повторного использования,

mungepath() {
   export PATH=$(ruby -e 'puts ENV["PATH"].split(/:/).uniq.join(":")')
}

Хэш, массивы и строки в рубиновом однострочном файле :)

Первое, что пришло мне в голову, чтобы изменить только часть строки, — это подмена sed.

пример:Если echo $ path => "/usr/pkg/bin:/usr/bin:/bin:/usr/pkg/games:/usr/pkg/x11r6/bin", затем изменить "/usr/bin"/"/ USR/Local/Bin "можно сделать так:

## создает стандартный выходной файл

## символ «=» используется вместо Slash ("/"), поскольку это было бы грязно, # Альтернативная цитата символа должна быть маловероятной по пути

## ПАТИНАЯ ПЕРЕДЕЛЕНИЕ ":" "Устранено и заново добавлено здесь, # может захотеть получить дополнительную толстую кишку после последнего пути

Echo $ PATH | sed '=/usr/bin: =/usr/local/bin: ='

Это решение заменяет весь элемент пути, поэтому может быть избыточным, если новый элемент аналогичен.

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

ПУТЬ=$TEMP_PATH_1;# команды...;n path = $ temp_path_2;# команды и т.д...;

Возможно, это не то, о чем вы думали.некоторые из соответствующих команд в bash/unix будут:

pushd popd cd ls # может l -1a для одно столбца;Найдите grep, который # может подтвердить, что файл - это то, откуда вы думаете, что он взялся;Env Type

..и все это и многое другое есть некоторый относительно PATH или каталогов в целом.Часть изменения текста можно выполнить любым количеством способов!

Какое бы решение ни было выбрано, оно будет состоять из 4 частей:

1) Извлечь путь как 2) Декодировать путь, чтобы найти часть, необходимую изменения 3) Определение того, какие изменения необходимы/интегрировать эти изменения 4) проверка/окончательная интеграция/Настройка переменной

В соответствии с Ответ dj_segfault, я делаю это в сценариях, которые добавляют/добавляют переменные среды, которые могут выполняться несколько раз:

ld_library_path=${ORACLE_HOME}/lib
LD_LIBRARY_PATH=${LD_LIBRARY_PATH//${ld_library_path}?(:)/}
export LD_LIBRARY_PATH=${ld_library_path}${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}

Использование этого же метода для удаления, замены или манипулирования записями в PATH тривиально, учитывая сопоставление с шаблоном, подобное расширению имени файла, и поддержку расширения параметров оболочки в виде списка шаблонов.

Лицензировано под: CC-BY-SA с атрибуция

Не связан с StackOverflow