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

Или, в более общем смысле, как удалить элемент из списка, разделенного двоеточиями, в переменной среды Bash?

Я думал, что видел простой способ сделать это несколько лет назад, используя более продвинутые формы расширения переменных Bash, но если это так, я потерял след. Быстрый поиск в Google показал удивительно мало релевантных результатов и ни одного, который я бы назвал «простым» или «элегантным». Например, два метода с использованием sed и awk соответственно:

PATH=$(echo $PATH | sed -e 's;:\?/home/user/bin;;' -e 's;/home/user/bin:\?;;')
PATH=!(awk -F: '{for(i=1;i<=NF;i++){if(!($i in a)){a[$i];printf s$i;s=":"}}}'<<<$PATH)

Ничего простого не существует? Есть ли что-нибудь аналогичное функции split () в Bash?

Обновление:
похоже, мне нужно извиниться за мой намеренно неопределенный вопрос; Меня меньше интересовало решение конкретного варианта использования, чем провоцирование хорошей дискуссии. К счастью, я понял!

Здесь есть несколько очень умных техник. В конце я добавил следующие три функции в свою панель инструментов. Волшебство происходит в path_remove, который основан в основном на умном использовании Мартином Йорком awkпеременной RS.

path_append ()  { path_remove $1; export PATH="$PATH:$1"; }
path_prepend () { path_remove $1; export PATH="$1:$PATH"; }
path_remove ()  { export PATH=`echo -n $PATH | awk -v RS=: -v ORS=: '$0 != "'$1'"' | sed 's/:$//'`; }

Единственный настоящий недостаток - использование sedдля удаления задней кишки. Учитывая то, насколько простым является решение Мартина, я вполне готов с этим жить!


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

15.12.2008 23:19:14
Для любой переменной: WORK=`echo -n ${1} | awk -v RS=: -v ORS=: '$0 != "'${3}'"' | sed 's/:$//'`; eval "export ${2}=${WORK}"но вы должны назвать ее как func $VAR VAR pattern(на основе @ martin-york и @ andrew-aylett)
vesperto 12.11.2019 17:08:41
30 ОТВЕТОВ
РЕШЕНИЕ

Минуту с awk:

# Strip all paths with SDE in them.
#
export PATH=`echo ${PATH} | awk -v RS=: -v ORS=: '/SDE/ {next} {print}'`

Изменить: Это ответ на комментарии ниже:

$ export a="/a/b/c/d/e:/a/b/c/d/g/k/i:/a/b/c/d/f:/a/b/c/g:/a/b/c/d/g/i"
$ echo ${a}
/a/b/c/d/e:/a/b/c/d/f:/a/b/c/g:/a/b/c/d/g/i

## Remove multiple (any directory with a: all of them)
$ echo ${a} | awk -v RS=: -v ORS=: '/a/ {next} {print}'
## Works fine all removed

## Remove multiple including last two: (any directory with g)
$ echo ${a} | awk -v RS=: -v ORS=: '/g/ {next} {print}'
/a/b/c/d/e:/a/b/c/d/f:
## Works fine: Again!

Изменить в ответ на проблему безопасности: (это не относится к вопросу)

export PATH=$(echo ${PATH} | awk -v RS=: -v ORS=: '/SDE/ {next} {print}' | sed 's/:*$//')

Это удаляет все оставшиеся конечные двоеточия, удаляя последние записи, которые эффективно добавили бы .к вашему пути.

49
24.02.2016 06:41:27
Сбой при попытке удалить последний элемент или несколько элементов: в первом случае он добавляет текущий каталог (в виде пустой строки; потенциальная дыра в безопасности), во втором случае добавляет `` в качестве элемента пути.
Fred Foo 13.03.2011 17:26:10
@larsmans: у меня отлично работает. Примечание: Пустой не совпадает с текущим каталогом, который является "./"
Martin York 13.03.2011 18:01:30
Пустая строка как «член» из PATHпеременных делает , как специальное правило, обозначает текущий каталог всех оболочек Unix , так как , по крайней мере V7 Unix в 1979 году он все еще в bash. Проверьте руководство или попробуйте сами.
Fred Foo 13.03.2011 22:58:30
@Martin: POSIX не требует такого поведения, но документирует и разрешает это: pubs.opengroup.org/onlinepubs/9699919799/basedefs/…
Fred Foo 13.03.2011 23:04:29
Есть еще более тонкая проблема при удалении последнего элемента с этим: awk, кажется, добавляет нулевой байт в конец строки . Это означает, что если вы добавите другой каталог в PATH позже, он фактически не будет найден.
sschuberth 24.10.2012 20:36:48

Ну, в bash, поскольку он поддерживает регулярные выражения, я бы просто сделал:

PATH=${PATH/:\/home\/user\/bin/}
3
15.12.2008 23:23:54
Разве это не только расширение пути, а не регулярные выражения?
dreamlax 16.12.2008 00:07:20
Хотя bash поддерживает регулярные выражения (по состоянию на bash 3), это не пример, а подстановка переменных.
Robert Gamble 16.12.2008 00:11:22
Это расширение переменной шаблона, и решение имеет несколько проблем. 1) он не будет соответствовать первому элементу. 2) он будет соответствовать всему, что начинается с «/ home / user / bin», а не просто «/ home / user / bin». 3) требует экранирования специальных символов. В лучшем случае я бы сказал, что это неполный пример.
nicerobot 16.12.2008 00:27:30

Мой грязный хак

echo ${PATH} > t1
vi t1
export PATH=$(cat t1)
54
9.03.2016 16:30:42
Это никогда не хороший знак , когда наиболее очевидным решением является де -Автоматизация процесса. :-D
Ben Blank 17.12.2008 17:21:48
ТАК гораздо безопаснее, чем «элегантные» альтернативы.
Jortstek 5.03.2020 05:03:16

Я написал ответ на это здесь (тоже используя awk). Но я не уверен, что это то, что вы ищете? По крайней мере, мне кажется ясным, что он делает, вместо того, чтобы пытаться вписаться в одну строчку. Для простого лайнера, который только удаляет вещи, я рекомендую

echo $PATH | tr ':' '\n' | awk '$0 != "/bin"' | paste -sd:

Замена есть

echo $PATH | tr ':' '\n' | 
    awk '$0 != "/bin"; $0 == "/bin" { print "/bar" }' | paste -sd:

или (короче, но менее читабельно)

echo $PATH | tr ':' '\n' | awk '$0 == "/bin" { print "/bar"; next } 1' | paste -sd:

В любом случае, на тот же вопрос и множество полезных ответов смотрите здесь .

4
23.05.2017 12:34:37
И если вы хотите удалить строки, которые содержат частичную строку, используйте awk '$0 !~ "/bin"'. Т.е. сохраните строки, которые не содержат '/ bin', с помощью оператора awk !~.
thoni56 5.02.2019 07:37:20

Поскольку это, как правило, довольно проблематично, так как в этом случае НЕТ элегантного способа, я рекомендую избегать проблемы, переставив решение: создайте свой путь PATH, а не пытайтесь его разрушить.

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

Общая проблема со сборками программного обеспечения заключается в том, что он ломается на некоторых машинах, в конечном счете из-за того, как кто-то настроил свою оболочку по умолчанию (PATH и другие переменные среды). Элегантное решение состоит в том, чтобы сделать ваши сценарии сборки защищенными, полностью указав среду оболочки. Кодируйте ваши сценарии сборки, чтобы установить переменные PATH и другие переменные среды на основе компонентов, которыми вы управляете, таких как расположение компилятора, библиотек, инструментов, компонентов и т. Д. Сделайте каждый настраиваемый элемент чем-то, что вы можете индивидуально установить, проверить и затем используйте соответствующим образом в вашем сценарии.

Например, у меня есть Java-ориентированная сборка на основе Maven, унаследованная моим новым работодателем. Сценарий сборки известен своей хрупкостью, и еще один новый сотрудник и я потратили три недели (не полный рабочий день, просто здесь и там, но еще много часов), чтобы заставить его работать на наших машинах. Важным шагом было то, что я взял под контроль PATH, чтобы точно знать, какая Java, какая Maven и какая WebLogic вызывались. Я создал переменные окружения, чтобы они указывали на каждый из этих инструментов, затем я рассчитал PATH, основываясь на этих плюс нескольких других. Подобные методы укротили другие настраиваемые параметры, пока мы наконец не создали воспроизводимую сборку.

Кстати, не используйте Maven, с Java все в порядке, и покупайте WebLogic только в том случае, если вам абсолютно необходима его кластеризация (но в противном случае нет, и особенно это касается его проприетарных функций).

С наилучшими пожеланиями.

0
16.12.2008 00:21:26
иногда у вас нет root-прав, и ваш администратор управляет вами PATH. Конечно, вы можете создать свой собственный, но каждый раз, когда ваш админ перемещает что-то, вы должны выяснить, где он это сделал. Такого рода побеждает цель иметь администратора.
Shep 24.04.2012 18:40:24

Как и в случае с @litb, я добавил ответ на вопрос « Как мне манипулировать элементами $ PATH в сценариях оболочки », поэтому мой основной ответ здесь.

Функциональность «split» в bashи других производных оболочки Bourne наиболее аккуратно достигается с $IFSпомощью межполевого разделителя. Например, чтобы установить позиционные аргументы ( $1, $2, ...) к элементам PATH, использование:

set -- $(IFS=":"; echo "$PATH")

Он будет работать нормально, если в $ PATH нет пробелов. Заставить его работать с элементами пути, содержащими пробелы, - нетривиальное упражнение, оставленное для заинтересованного читателя. Вероятно, проще справиться с этим, используя язык сценариев, такой как Perl.

У меня также есть скрипт, clnpathкоторый я широко использую для настройки моего PATH. Я задокументировал это в ответе на вопрос « Как избежать дублирования переменной PATH в csh ».

0
23.05.2017 12:34:37
IFS =: a = ($ PATH); IFS = расщепление тоже хорошо. работает, если они тоже содержат пробелы. но затем вы получили массив, и вам придется возиться с циклами for и таковыми, чтобы удалить имена.
Johannes Schaub - litb 16.12.2008 00:48:34
Да; это становится неудобным - как и в случае с моим обновленным комментарием, на данном этапе, вероятно, проще использовать язык сценариев.
Jonathan Leffler 16.12.2008 00:55:52

Вот самое простое решение, которое я могу придумать:

#!/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, который содержит «usr». Вы можете заменить "* usr *" на "/ home / user / bin", чтобы удалить только этот элемент.

обновление в сшуберт

Даже если я думаю , что помещения в $PATHявляются ужасной идеей, вот решение , которое обрабатывает его:

PATH=$(IFS=':';t=($PATH);n=${#t[*]};a=();for ((i=0;i<n;i++)); do p="${t[i]%%*usr*}"; [ "${p}" ] && a[i]="${p}"; done;echo "${a[*]}");

или

IFS=':'
t=($PATH)
n=${#t[*]}
a=()
for ((i=0;i<n;i++)); do
  p="${t[i]%%*usr*}"
  [ "${p}" ] && a[i]="${p}"
done
echo "${a[*]}"
26
23.05.2017 12:18:20
Как один вкладыш: PATH = $ (IFS = ':'; t = ($ PATH); неустановленный IFS; t = ($ {t [@] %% * usr *}); IFS = ':'; echo "$ {т [*]} ");
nicerobot 16.12.2008 04:10:08
Это решение не работает с путями в PATH, которые содержат пробелы; он заменяет их двоеточиями.
sschuberth 27.10.2012 21:01:15

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

Вот немного менее элегантная версия, которая удаляет один каталог из $PATHиспользования только строк. Я проверил это.

#!/bin/bash
#
#   remove_from_path dirname
#
#   removes $1 from user's $PATH

if [ $# -ne 1 ]; then
  echo "Usage: $0 pathname" 1>&2; exit 1;
fi

delendum="$1"
NEWPATH=
xxx="$IFS"
IFS=":"
for i in $PATH ; do
  IFS="$xxx"
  case "$i" in
    "$delendum") ;; # do nothing
    *) [ -z "$NEWPATH" ] && NEWPATH="$i" || NEWPATH="$NEWPATH:$i" ;;
  esac
done

PATH="$NEWPATH"
echo "$PATH"
0
16.12.2008 02:53:52

Вот Perl с одним вкладышем:

PATH=`perl -e '$a=shift;$_=$ENV{PATH};s#:$a(:)|^$a:|:$a$#$1#;print' /home/usr/bin`

$aПеременная получает путь , который будет удален. s(Запасной) и printкоманда неявно действуют на $_переменном.

0
16.12.2008 19:54:14

Хорошие вещи здесь. Я использую этот, чтобы не добавлять дуплы в первую очередь.

#!/bin/bash
#
######################################################################################
#
# Allows a list of additions to PATH with no dupes
# 
# Patch code below into your $HOME/.bashrc file or where it
# will be seen at login.
#
# Can also be made executable and run as-is.
#
######################################################################################

# add2path=($HOME/bin .)                  ## uncomment space separated list 
if [ $add2path ]; then                    ## skip if list empty or commented out
for nodup in ${add2path[*]}
do
    case $PATH in                 ## case block thanks to MIKE511
    $nodup:* | *:$nodup:* | *:$nodup ) ;;    ## if found, do nothing
    *) PATH=$PATH:$nodup          ## else, add it to end of PATH or
    esac                          ## *) PATH=$nodup:$PATH   prepend to front
done
export PATH
fi
## debug add2path
echo
echo " PATH == $PATH"
echo
0
13.01.2010 09:28:52
Вы можете упростить вашу инструкцию case, добавив case ":$PATH:" in (*:"$nodup":*) ;; (*) PATH="$PATH:$nodup" ;; esac
glenn jackman 23.06.2011 02:05:03

При включенном расширенном перемещении можно сделать следующее:

# delete all /opt/local paths in PATH
shopt -s extglob 
printf "%s\n" "${PATH}" | tr ':' '\n' | nl
printf "%s\n" "${PATH//+(\/opt\/local\/)+([^:])?(:)/}" | tr ':' '\n' | nl 

man bash | less -p extglob
0
20.01.2010 18:28:13

Расширенное однослойное сглаживание (ну вроде):

path_remove ()  { shopt -s extglob; PATH="${PATH//+(${1})+([^:])?(:)/}"; export PATH="${PATH%:}"; shopt -u extglob; return 0; } 

Кажется, нет необходимости избегать слэшей в $ 1.

path_remove ()  { shopt -s extglob; declare escArg="${1//\//\\/}"; PATH="${PATH//+(${escArg})+([^:])?(:)/}"; export PATH="${PATH%:}"; shopt -u extglob; return 0; } 
0
21.01.2010 10:14:13

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

# PATH => /bin:/opt/a dir/bin:/sbin
WORK=:$PATH:
# WORK => :/bin:/opt/a dir/bin:/sbin:
REMOVE='/opt/a dir/bin'
WORK=${WORK/:$REMOVE:/:}
# WORK => :/bin:/sbin:
WORK=${WORK%:}
WORK=${WORK#:}
PATH=$WORK
# PATH => /bin:/sbin

Чистый баш :).

44
9.12.2013 23:03:08
Я добавил бы этот учебный раздел для некоторого дополнительного замораживания: tldp.org/LDP/abs/html/string-manipulation.html
Cyber Oliveira 8.10.2011 18:16:17
Я использовал это, потому что это выглядело как самое простое решение. Это было очень быстро и просто, и вы можете легко проверить свою работу с помощью echo $ WORK прямо перед последней строкой, где вы фактически изменили переменную PATH.
Phil Gran 21.08.2012 19:15:37
Абсолютно маленький драгоценный камень. Именно то, что я пытался сделать, когда я нашел этот пост. -Спасибо, Андрей! КСТАТИ: Может быть, вы хотели бы добавить двойные кавычки вокруг ": $ PATH:", на всякий случай он должен содержать пробелы (то же самое, что "/ usr / bin") и последнюю строку "$ WORK".
user1985657 9.12.2013 15:33:23
Спасибо, @ PacMan-- :). Я почти уверен (только что попробовал), что вам не нужны пробелы для присваиваний WORKи, PATHпоскольку расширение переменной происходит после того, как строка разбита на секции для присваивания переменных и выполнения команд. REMOVEможет потребоваться заключить в кавычки, или вы можете просто поместить вашу строку прямо в замену, если она является константой.
Andrew Aylett 9.12.2013 23:00:51
Я всегда запутался, когда строки были сохранены, поэтому я всегда начинал заключать в кавычки строки. Еще раз спасибо за разъяснение этого. :)
user1985657 11.12.2013 19:12:22

Да, например, размещение двоеточия в конце переменной PATH делает удаление пути менее неуклюжим и подверженным ошибкам.

path_remove ()  { 
   declare i newPATH
   newPATH="${PATH}:"
   for ((i=1; i<=${#@}; i++ )); do
      #echo ${@:${i}:1}
      newPATH="${newPATH//${@:${i}:1}:/}" 
   done
   export PATH="${newPATH%:}" 
   return 0; 
} 

path_remove_all ()  {
   declare i newPATH
   shopt -s extglob
   newPATH="${PATH}:"
   for ((i=1; i<=${#@}; i++ )); do
      newPATH="${newPATH//+(${@:${i}:1})*([^:]):/}" 
      #newPATH="${newPATH//+(${@:${i}:1})*([^:])+(:)/}" 
   done
   shopt -u extglob 
   export PATH="${newPATH%:}" 
   return 0 
} 

path_remove /opt/local/bin /usr/local/bin

path_remove_all /opt/local /usr/local 
1
21.01.2010 19:58:30

Добавляя двоеточия в PATH, мы также можем сделать что-то вроде:

path_remove ()  { 
   declare i newPATH
   # put a colon at the beginning & end AND double each colon in-between
   newPATH=":${PATH//:/::}:"   
   for ((i=1; i<=${#@}; i++)); do
       #echo ${@:${i}:1}
       newPATH="${newPATH//:${@:${i}:1}:/}"   # s/:\/fullpath://g
   done
   newPATH="${newPATH//::/:}"
   newPATH="${newPATH#:}"      # remove leading colon
   newPATH="${newPATH%:}"      # remove trailing colon
   unset PATH 
   PATH="${newPATH}" 
   export PATH
   return 0 
} 


path_remove_all ()  {
   declare i newPATH extglobVar
   extglobVar=0
   # enable extended globbing if necessary
   [[ ! $(shopt -q extglob) ]]  && { shopt -s extglob; extglobVar=1; }
   newPATH=":${PATH}:"
   for ((i=1; i<=${#@}; i++ )); do
      newPATH="${newPATH//:+(${@:${i}:1})*([^:])/}"     # s/:\/path[^:]*//g
   done
   newPATH="${newPATH#:}"      # remove leading colon
   newPATH="${newPATH%:}"      # remove trailing colon
   # disable extended globbing if it was enabled in this function
   [[ $extglobVar -eq 1 ]] && shopt -u extglob
   unset PATH 
   PATH="${newPATH}" 
   export PATH
   return 0 
} 

path_remove /opt/local/bin /usr/local/bin

path_remove_all /opt/local /usr/local 
0
22.01.2010 17:45:00

В path_remove_all (по доверенности):

-newPATH="${newPATH//:+(${@:${i}:1})*([^:])/}" 
+newPATH="${newPATH//:${@:${i}:1}*([^:])/}"        # s/:\/path[^:]*//g 
0
22.01.2010 18:34:52

Если вы беспокоитесь об удалении дубликатов в $ PATH, самым элегантным способом, IMHO, было бы не добавлять их в первую очередь. В 1 строке:

if ! $( echo "$PATH" | tr ":" "\n" | grep -qx "$folder" ) ; then PATH=$PATH:$folder ; fi

Папка $ может быть заменена на что угодно и может содержать пробелы ("/ home / user / my documents")

1
19.02.2011 05:11:25

Хотя это очень старая тема, я подумал, что это решение может быть интересным:

PATH="/usr/lib/ccache:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games"
REMOVE="ccache" # whole or part of a path :)
export PATH=$(IFS=':';p=($PATH);unset IFS;p=(${p[@]%%$REMOVE});IFS=':';echo "${p[*]}";unset IFS)
echo $PATH # outputs /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games

нашел это в этом сообщении в блоге . Я думаю, что мне больше всего нравится этот :)

0
22.06.2011 21:18:07

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

path_remove () {
    if [[ ":$PATH:" == *":$1:"* ]]; then
        local dirs=":$PATH:"
        dirs=${dirs/:$1:/:}
        export PATH="$(__path_clean $dirs)"
    fi
}
__path_clean () {
    local dirs=${1%?}
    echo ${dirs#?}
}

Выше приведен упрощенный пример последних функций, которые я использую. Я также создал path_add_beforeи path_add_afterпозволил вам вставить путь до / после указанного пути уже в PATH.

Полный набор функций доступен в path_helpers.sh в моих точечных файлах . Они полностью поддерживают удаление / добавление / добавление / вставку в начале / середине / конце строки PATH.

0
20.04.2012 17:14:06

Я только что использовал функции в дистрибутиве bash, которые существуют там, по-видимому, с 1991 года. Они все еще находятся в пакете bash-docs в Fedora и раньше использовались /etc/profile, но не более ...

$ rpm -ql bash-doc |grep pathfunc
/usr/share/doc/bash-4.2.20/examples/functions/pathfuncs
$ cat $(!!)
cat $(rpm -ql bash-doc |grep pathfunc)
#From: "Simon J. Gerraty" <sjg@zen.void.oz.au>
#Message-Id: <199510091130.VAA01188@zen.void.oz.au>
#Subject: Re: a shell idea?
#Date: Mon, 09 Oct 1995 21:30:20 +1000


# NAME:
#       add_path.sh - add dir to path
#
# DESCRIPTION:
#       These functions originated in /etc/profile and ksh.kshrc, but
#       are more useful in a separate file.
#
# SEE ALSO:
#       /etc/profile
#
# AUTHOR:
#       Simon J. Gerraty <sjg@zen.void.oz.au>

#       @(#)Copyright (c) 1991 Simon J. Gerraty
#
#       This file is provided in the hope that it will
#       be of use.  There is absolutely NO WARRANTY.
#       Permission to copy, redistribute or otherwise
#       use this file is hereby granted provided that
#       the above copyright notice and this notice are
#       left intact.

# is $1 missing from $2 (or PATH) ?
no_path() {
        eval "case :\$${2-PATH}: in *:$1:*) return 1;; *) return 0;; esac"
}
# if $1 exists and is not in path, append it
add_path () {
  [ -d ${1:-.} ] && no_path $* && eval ${2:-PATH}="\$${2:-PATH}:$1"
}
# if $1 exists and is not in path, prepend it
pre_path () {
  [ -d ${1:-.} ] && no_path $* && eval ${2:-PATH}="$1:\$${2:-PATH}"
}
# if $1 is in path, remove it
del_path () {
  no_path $* || eval ${2:-PATH}=`eval echo :'$'${2:-PATH}: |
    sed -e "s;:$1:;:;g" -e "s;^:;;" -e "s;:\$;;"`
}
5
8.03.2012 23:09:11

Самое элегантное решение для чистого bash, которое я нашел на сегодняшний день:

pathrm () {                                                                      
  local IFS=':'                                                                  
  local newpath                                                                  
  local dir                                                                      
  local pathvar=${2:-PATH}                                                       
  for dir in ${!pathvar} ; do                                                    
    if [ "$dir" != "$1" ] ; then                                                 
      newpath=${newpath:+$newpath:}$dir                                          
    fi                                                                           
  done                                                                           
  export $pathvar="$newpath"                                                        
}

pathprepend () {                                                                 
  pathrm $1 $2                                                                   
  local pathvar=${2:-PATH}                                                       
  export $pathvar="$1${!pathvar:+:${!pathvar}}"                                  
}

pathappend () {                                                                    
  pathrm $1 $2                                                                   
  local pathvar=${2:-PATH}                                                       
  export $pathvar="${!pathvar:+${!pathvar}:}$1"                                  
} 
1
7.04.2012 05:29:34

function __path_remove () {
local D = ": $ {PATH}:";
["$ {D /: $ 1: /:}"! = "$ D"] && PATH = "$ {D /: $ 1: /:}";
PATH = "$ {PATH / #: /}";
export PATH = "$ {PATH /%: /}";
}

Выкопал это из моего файла .bashrc. Когда вы играете с PATH, и он теряется, awk / sed / grep становится недоступным :-)

6
13.08.2012 00:28:39
Это очень хороший момент. (Я никогда не любил запускать внешние утилиты для таких простых вещей, как эта).
user1985657 11.12.2013 19:33:57

Вот одна строка, которая, несмотря на текущие принятые и получившие наибольшее количество ответов ответы, не добавляет невидимые символы в PATH и может справиться с путями, которые содержат пробелы:

export PATH=$(p=$(echo $PATH | tr ":" "\n" | grep -v "/cygwin/" | tr "\n" ":"); echo ${p%:})

Лично я также нахожу это легким для чтения / понимания, и оно включает только общие команды вместо использования awk.

11
23.05.2017 12:18:20
... и если вы хотите что-то, что может справиться даже с символами новой строки в именах файлов, вы можете использовать это: export PATH=$(p=$(echo $PATH | tr ":" "\0" | grep -v -z "/cygwin/" | tr "\0" ":"); echo ${p%:}) (хотя, возможно, вы захотите спросить себя, зачем вам это нужно, если вы делаете :))
ehdr 14.01.2015 10:47:49
Это удалит частичные совпадения, что, вероятно, не то, что вы хотите; Я бы использовал grep -v "^/path/to/remove\$"илиgrep -v -x "/path/to/remove"
ShadSterling 23.01.2016 03:17:23
Прекрасное решение, но вы действительно думаете, что trболее распространено, чем awk? ;)
K.-Michael Aye 24.05.2016 23:52:29
Абсолютно. Облегченные среды, такие как Git Bash для Windows, скорее идут с простым инструментом tr, чем с интерпретатором awk.
sschuberth 25.05.2016 06:04:26
@ehdr: Вам нужно заменить echo "..."с printf "%s" "..."для того , чтобы работать над путями , как -eи другие подобные. См. Stackoverflow.com/a/49418406/102441
Eric 8.10.2018 14:16:00

Лучший вариант чистого bash, который я нашел до сих пор, таков:

function path_remove {
  PATH=${PATH/":$1"/} # delete any instances in the middle or at the end
  PATH=${PATH/"$1:"/} # delete any instances at the beginning
}

Это основано на не совсем правильный ответ на Добавить каталог в $ PATH , если это уже не существует более на суперпользователя.

6
20.03.2017 10:18:16
Это тоже неплохо. Я проверял это. Если в PATH есть повторяющийся путь (например, два одинаковых), то удаляется только один из них. Вы также можете превратить его в однострочник:removePath () { PATH=${PATH/":$1"/}; PATH=${PATH/"$1:"/}; }
user1985657 11.12.2013 19:26:38
Это решение дает сбой, когда $PATHсодержит подпапку целевого (т.е. подлежащего удалению) пути. Например: a:abc/def/bin:b-> a/bin:b, когда abc/defнужно удалить.
Robin Hsu 14.04.2017 04:06:01

Трейлинг ':' вызван тем, что вы устанавливаете конец строки, а не разделитель. Я использую ограниченные по ресурсам единицы и хотел бы упаковать все в один скрипт без этих странностей:

path_remove () {
    PATH="$(echo -n $PATH | awk -v RS=: -v ORS= '$0 != "'$1'"{print s _ $0;s=":"}')"
}
0
16.05.2014 19:36:52

Большинство других предложенных решений полагаться только на совпадения строк и не учитывает сегменты пути , содержащие специальные имена , как ., ..или ~. Приведенная ниже функция bash разрешает строки каталога в своем аргументе и сегментах пути, чтобы найти логические совпадения каталогов, а также совпадения строк.

rm_from_path() {
  pattern="${1}"
  dir=''
  [ -d "${pattern}" ] && dir="$(cd ${pattern} && pwd)"  # resolve to absolute path

  new_path=''
  IFS0=${IFS}
  IFS=':'
  for segment in ${PATH}; do
    if [[ ${segment} == ${pattern} ]]; then             # string match
      continue
    elif [[ -n ${dir} && -d ${segment} ]]; then
      segment="$(cd ${segment} && pwd)"                 # resolve to absolute path
      if [[ ${segment} == ${dir} ]]; then               # logical directory match
        continue
      fi
    fi
    new_path="${new_path}${IFS}${segment}"
  done
  new_path="${new_path/#${IFS}/}"                       # remove leading colon, if any
  IFS=${IFS0}

  export PATH=${new_path}
}

Тестовое задание:

$ mkdir -p ~/foo/bar/baz ~/foo/bar/bif ~/foo/boo/bang
$ PATH0=${PATH}
$ PATH=~/foo/bar/baz/.././../boo/././../bar:${PATH}  # add dir with special names
$ rm_from_path ~/foo/boo/../bar/.  # remove same dir with different special names
$ [ ${PATH} == ${PATH0} ] && echo 'PASS' || echo 'FAIL'
1
6.10.2014 16:14:53
плюс один за нестандартную коробку
Martin York 23.08.2017 19:37:40

Это, конечно, элегантно, но в нем используется внешний седан. Кроме того, он удаляет все пути, содержащие строку поиска $ 1. Он также не оставляет зависания: в конце, если удаленный путь является последним в PATH.

PATH=`echo $PATH | sed 's/:[^:]*$1[^:]*//g'`

Эта альтернатива оставляет финал висячей: однако.

PATH=`echo $PATH | tr ":" "\n" | grep -v $1 | tr "\n" ":"`

Альтернативы без кавычек:

PATH=$(echo $PATH | sed 's/:[^:]*$1[^:]*//g')

PATH=$(echo $PATH | tr ":" "\n" | grep -v $1 | tr "\n" ":")
0
22.10.2014 19:44:38

Вот решение, которое:

  • чистый баш,
  • не вызывает другие процессы (такие как «sed» или «awk»),
  • не меняется IFS,
  • не разветвляется суб-оболочка,
  • обрабатывает пути с пробелами, и
  • удаляет все вхождения аргумента в PATH.

    removeFromPath () {
       местный пд
       р = ": $ 1:"
       д = ": $ PATH:"
       д = $ {// д $ р /:}
       д = $ {d / #: /}
       PATH = $ {d /%: /}
    }
8
20.03.2015 04:22:43
Мне нравится это решение. Может сделать имена переменных более наглядными?
Anukool 11.06.2015 20:01:02
очень хорошо. Однако не работает для сегментов пути, содержащих звездочку (*). Иногда они попадают туда случайно.
Jörg 14.02.2019 18:00:17

Linux с нуля определяет три функции Bash в /etc/profile:

# Functions to help us manage paths.  Second argument is the name of the
# path variable to be modified (default: PATH)
pathremove () {
        local IFS=':'
        local NEWPATH
        local DIR
        local PATHVARIABLE=${2:-PATH}
        for DIR in ${!PATHVARIABLE} ; do
                if [ "$DIR" != "$1" ] ; then
                  NEWPATH=${NEWPATH:+$NEWPATH:}$DIR
                fi
        done
        export $PATHVARIABLE="$NEWPATH"
}

pathprepend () {
        pathremove $1 $2
        local PATHVARIABLE=${2:-PATH}
        export $PATHVARIABLE="$1${!PATHVARIABLE:+:${!PATHVARIABLE}}"
}

pathappend () {
        pathremove $1 $2
        local PATHVARIABLE=${2:-PATH}
        export $PATHVARIABLE="${!PATHVARIABLE:+${!PATHVARIABLE}:}$1"
}

export -f pathremove pathprepend pathappend

Ссылка: http://www.linuxfromscratch.org/blfs/view/svn/postlfs/profile.html

1
22.11.2015 10:00:54

Мне нравятся три функции, показанные в обновлении @ BenBlank к его первоначальному вопросу. Чтобы обобщить их, я использую форму с двумя аргументами, которая позволяет мне установить PATH или любую другую переменную среды, которую я хочу:

path_append ()  { path_remove $1 $2; export $1="${!1}:$2"; }
path_prepend () { path_remove $1 $2; export $1="$2:${!1}"; }
path_remove ()  { export $1="`echo -n ${!1} | awk -v RS=: -v ORS=: '$1 != "'$2'"' | sed 's/:$//'`"; }

Примеры использования:

path_prepend PATH /usr/local/bin
path_append PERL5LIB "$DEVELOPMENT_HOME/p5/src/perlmods"

Обратите внимание, что я также добавил некоторые кавычки, чтобы обеспечить правильную обработку путей, содержащих пробелы.

2
5.01.2016 20:54:22