Jak manipulować elementami $PATH w skryptach powłoki?

Reposting mojej odpowiedzi do Jaki jest najbardziej elegancki sposób na usunięcie ścieżki ze zmiennej $PATH w 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[*]}"

Lub jednowierszowy:

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

Istnieje kilka odpowiednich programów w odpowiedziach na " Jak nie powielać zmiennej path w csh ". Koncentrują się bardziej na zapewnieniu, że nie ma powtarzających się elementów, ale skrypt, który podaję, może być użyty jako:

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

Zakładając, że masz jeden lub więcej katalogów w $head_dirs i jeden lub więcej katalogów w $tail_dirs i jeden lub więcej katalogów w $remove_dirs, to używa powłoki do połączenia części head, current i tail w ogromną wartość i następnie usuwa każdy z katalogów wymienionych w $remove_dirs z wyniku (nie jest to błąd, jeśli nie istnieją), a także eliminuje drugie i kolejne wystąpienia dowolnego katalogu w ścieżce.

Nie dotyczy to umieszczania składników ścieżki w określonym miejscu (innym niż na początku lub końcu, a tylko pośrednio). Nie, określenie, gdzie chcesz dodać nowy element, lub który element chcesz zastąpić, jest niechlujne.

Do usunięcia elementu możesz użyć sed:

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

Usunie ścieżki zawierające "foo"ze ścieżki.

Możesz również użyć sed do wstawienia nowej linii przed lub po danej linii.

Edit: Można usunąć duplikaty poprzez sortowanie i uniq:

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

Tylko zauważ, że sam bash może wyszukiwać i zastępować. Może wykonać wszystkie normalne" raz lub wszystkie", przypadki [w] wrażliwych opcjach, których można się spodziewać.

Ze strony man:

${parametr / wzór / Ciąg}

Wzorzec jest rozwijany tak, aby wytworzyć wzorzec, tak jak w rozszerzeniu pathname. Parametr jest rozwijany, a najdłuższe dopasowanie wzorca do jego wartości jest zastępowane łańcuchem znaków. Jeśli Ipattern zaczyna się od/, wszystkie dopasowania wzorca są zamieniane na string. Normalnie tylko pierwszy mecz zostaje zastąpiony. Jeśli wzorzec zaczyna się od#, musi być zgodny na początku rozszerzonej wartości parametru. Jeśli wzorzec zaczyna się od%, musi być zgodny na końcu rozszerzonej wartości parametru. Jeśli string jest null, dopasowania wzorca są usuwane i / następujący wzór może zostać pominięty. Jeśli parametr jest @ lub * , operacja substytucji jest stosowana do każdego parametru pozycyjnego z kolei, a rozszerzenie jest listą wynikową. Jeśli parametr jest zmienną tablicową z @ lub *, operacja substytucji jest zastosowana do każdego członu tablicy z kolei, a rozszerzenie jest listą wynikową.

Można również dokonać podziału pól, ustawiając $IFS (separator pól wejściowych) na żądany ogranicznik.

OK, dzięki wszystkim respondentom. Przygotowałem zamkniętą wersję odpowiedzi Florina. Pierwsze przejście wygląda tak:

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

Nadal wymaga zalewkowania błędów we wszystkich funkcjach i prawdopodobnie powinienem trzymać się powtarzającego się rozwiązania ścieżki, gdy przy tym jestem.

Używasz go wykonując . /include/path/path_tools.bash W działającym skrypcie i wywołując funkcje replace-path*.

Jest to łatwe przy użyciu awk.

Zastąp

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

Uruchom go za pomocą

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

Append

Wstawki w podanej pozycji. Domyślnie dołącza się na końcu.

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

Uruchom go za pomocą

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

Usuń duplikaty

Ten zachowuje pierwsze przypadki.

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

Zacznij tak:

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

Sprawdź, czy wszystkie elementy istnieją

Poniżej zostanie wyświetlony komunikat o błędzie dla wszystkich wpisów, które nie są istniejących w systemie plików i zwraca wartość niezerową.

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

Aby po prostu sprawdzić, czy wszystkie elementy są ścieżkami i uzyskać kod powrotu, możesz również użyć test:

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

Przypuśćmy

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

Jeśli chcesz usunąć/lib / jvm / java-1.6.0 / bin / postępuj jak poniżej

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

sed pobierze dane wejściowe z echo $PATH i zastąpi/lib/jvm/java-1.6.0/ bin/: pustym

W ten sposób można usunąć

• kolejność ścieżek nie jest rozdzielana
• obsługuje skrzynki narożne, takie jak pusta ścieżka, spacja w ścieżce z wdziękiem
• częściowe dopasowanie dir nie daje fałszywych alarmów
• traktuje ścieżkę na głowie i ogonie ścieżki w odpowiedni sposób. Nie.: śmieci i takie tam.

Powiedz, że masz / foo: / some / path: / some / path / dir1: / some / path / dir2: / bar i chcesz zastąpić / some / path Wtedy poprawnie zastępuje "/ some / path " ale pozostawia "/ some / path / dir1 " lub "/ some / path / dir2", jako czego byś się spodziewał.

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  
}  

Related post jaki jest najbardziej elegancki sposób na usunięcie ścieżki ze zmiennej $PATH w Bash?

Pierwszą rzeczą, która wpadnie mi do głowy, aby zmienić tylko część łańcucha, jest zamiana sed.

Przykład: if echo $PATH => "/usr/pkg/bin:/usr/bin:/bin:/usr/pkg/gry:/usr/pkg/X11R6 / bin" następnie zmienić "/ usr / bin " NA "/ usr / local / bin " można zrobić tak:

# # tworzy standardowy plik wyjściowy

# # znak " = "jest używany zamiast slash (" / " ), ponieważ byłoby to niechlujne, # alternatywny znak cytowania powinien być mało prawdopodobny w ścieżce

## separator ścieżek znak ": "jest zarówno usunięty, jak i ponownie dodany tutaj, # może wymagać dodatkowego dwukropka po ostatniej ścieżce

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

To rozwiązanie zastępuje cały element ścieżki, więc może być zbędne, jeśli nowy element jest podobny.

Jeśli nowe ścieżki ' - s nie są dynamiczne, ale zawsze mieszczą się w jakimś stałym zestawie, możesz zapisać te W Zmiennej i przypisać w razie potrzeby:

PATH=$TEMP_PATH_1; / align = "left" / .. ; \n PATH = $TEMP_PATH_2; # polecenia itd... ;

Może to nie to, o czym myślałeś. niektóre z odpowiednich poleceń w bash / unix to:

Pushd popd cd ls # może l-1A dla pojedynczej kolumny; znajdź grep który # może potwierdzić, że plik jest tam, skąd się wziął; env typ

..i wszystko to i wiele innych ma pewne znaczenie dla ścieżek lub katalogów w ogóle. Tekst zmieniający część można zrobić na wiele sposobów!

Dowolne wybrane rozwiązanie będzie miało 4 części:

1) Pobierz ścieżkę jak to jest 2) odszyfruj ścieżkę, aby znaleźć część wymagającą zmian 3) określanie, jakie zmiany są potrzebne/integrowanie tych zmian 4) Walidacja/końcowa integracja/ustawienie zmiennej

Zgodnie z odpowiedzią dj_segfault , robię to w skryptach dołączających / poprzedzających zmienne środowiskowe, które mogą być wykonywane wiele razy:

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

Używanie tej samej techniki do usuwania, zastępowania lub manipulowania wpisami w ścieżce jest trywialne, biorąc pod uwagę dopasowanie wzorców do nazw plików i obsługę list wzorców rozszerzenia parametrów powłoki.