Ответ 1

Минута с 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/:*$//')

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

Ответ 2

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

echo ${PATH} > t1
vi t1
export PATH=$(cat t1)

Ответ 3

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

# 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

Pure bash:).

Ответ 4

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

#!/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", чтобы удалить только этот элемент.

обновление за sschuberth

Даже если я думаю, что пробелы в $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[*]}"

Ответ 5

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

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

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

Ответ 6

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

• является чистым Bash,
• не вызывает другие процессы (например, "sed" или "awk" ),
• не меняет IFS,
• не вызывает подкоманду,
• обрабатывает пути с пробелами и

• удаляет все вхождения аргумента в PATH.

  removeFromPath() {
     local p d
     p=":$1:"
     d=":$PATH:"
     d=${d//$p/:}
     d=${d/#:/}
     PATH=${d/%:/}
  }

Ответ 7

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

}

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

Ответ 8

Лучшая чистая опция 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, если он еще не существует над суперпользователем.

Ответ 9

Я только что использовал функции в дистрибутиве 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" <[email protected]>
#Message-Id: <[email protected]>
#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 <[email protected]>

#       @(#)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;:\$;;"`
}

Ответ 10

Я написал ответ на этот здесь (используя 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:

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

Ответ 11

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

PATH=${PATH/:\/home\/user\/bin/}

Ответ 12

Да, добавление двоеточия в конце 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 

Ответ 13

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

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

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

Ответ 14

Самый элегантный чистый 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"                                  
} 

Ответ 15

Большинство других предлагаемых решений зависят только от соответствия строк и не учитывают сегменты маршрута, содержащие специальные имена, такие как ., .. или ~. Функция 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'

Ответ 16

Linux от Scratch определяет три функции 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

Ответ 17

Мне нравятся три функции, показанные в обновлении @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"

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

Ответ 18

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

Что более элегантно, чем awk?

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

Python! Это более читаемое и поддерживаемое решение, и его легко проверить, чтобы убедиться, что он действительно делает то, что вы хотите.

Предположим, вы хотите удалить первый элемент пути?

PATH="$(echo "$PATH" | python -c "import sys; path = sys.stdin.read().split(':'); del path[0]; print(':'.join(path))")"

(Вместо того, чтобы переходить из echo, os.getenv['PATH'] будет немного короче и будет иметь тот же результат, что и выше, но я беспокоюсь, что Python может что-то сделать с этой переменной окружения, поэтому, вероятно, лучше всего пропустите его непосредственно из среды, о которой вы заботитесь.)

Аналогично удалению с конца:

PATH="$(echo "$PATH" | python -c "import sys; path = sys.stdin.read().split(':'); del path[-1]; print(':'.join(path))")"

Чтобы сделать эти многоразовые функции оболочки, которые вы можете, например, вставить в свой .bashrc файл:

strip_path_first () {
    PATH="$(echo "$PATH" | 
    python -c "import sys; path = sys.stdin.read().split(':'); del path[0]; print(':'.join(path))")"
}

strip_path_last () {
    PATH="$(echo "$PATH" | 
    python -c "import sys; path = sys.stdin.read().split(':'); del path[-1]; print(':'.join(path))")"
}

Ответ 19

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

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

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

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

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

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

Ответ 20

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

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

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

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

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

Ответ 21

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

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

#!/bin/bash
#
#   remove_from_path dirname
#
#   removes $1 from user $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"

Ответ 22

Здесь однострочный Perl:

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

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

Ответ 23

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

#!/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

Ответ 24

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

# 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

Ответ 25

Расширенный подтягивающий однострочный (ну, вроде):

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; } 

Ответ 26

Добавление двоеточий в 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 

Ответ 27

В path_remove_all (через proxxy):

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

Ответ 28

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

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

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

Ответ 29

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

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 в dotfiles. Они полностью поддерживают удаление/добавление/добавление/вставку в начале/середине/конце строки PATH.

Ответ 30

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

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