¿Cómo manipulo elementos $ PATH en scripts de shell?
https://stackoverflow.com/questions/273909
-
07-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
¿Hay alguna forma idiomática de eliminar elementos de las variables de shell tipo PATH?
Eso es lo que quiero tomar
PATH=/home/joe/bin:/usr/local/bin:/usr/bin:/bin:/path/to/app/bin:.
y eliminar o reemplazar el / path / to / app / bin sin bloquear el resto de la variable. Puntos extra por permitirme poner nuevos elementos en posiciones arbitrarias. El objetivo será reconocible por una cadena bien definida, y puede aparecer en cualquier punto de la lista.
Sé que he visto esto hecho, y probablemente puedo improvisar algo por mi cuenta, pero estoy buscando un buen enfoque. Portabilidad y estandarización un plus.
Uso bash, pero los ejemplos también son bienvenidos en tu shell favorito.
El contexto aquí es el de tener que cambiar convenientemente entre múltiples versiones (una para hacer análisis, otra para trabajar en el marco) de un gran paquete de análisis científico que produce un par de docenas de ejecutables, tiene datos escondidos alrededor del sistema de archivos, y utiliza la variable de entorno para ayudar a encontrar todo esto. Me gustaría escribir un script que seleccione una versión, y necesito poder eliminar los elementos $ PATH relacionados con la versión actualmente activa y reemplazarlos con los mismos elementos relacionados con la nueva versión.
Esto está relacionado con el problema de evitar elementos repetidos de $ PATH al volver a ejecutar scripts de inicio de sesión y similares.
- Pregunta similar anterior: Cómo evitar duplicar la variable de ruta en csh
- Pregunta similar posterior: ¿Cuál es la forma más elegante de eliminar una ruta de la variable $ PATH en Bash?
Solución
Abordar la solución propuesta de dmckee:
- Si bien algunas versiones de Bash pueden permitir guiones en los nombres de funciones, otras (MacOS X) no lo hacen.
- No veo la necesidad de usar return inmediatamente antes del final de la función.
- No veo la necesidad de todos los punto y coma.
- No veo por qué tiene un elemento de ruta exportar un valor. Piense en
exportcomo equivalente a establecer (o incluso crear) una variable global, algo que debe evitarse siempre que sea posible. - No estoy seguro de lo que espera que haga '
replace-path PATH $ PATH / usr', pero no hace lo que yo esperaría.
Considere un valor de RUTA que comienza con:
.
/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
El resultado que obtuve (de ' replace-path PATH $ PATH / usr ') es:
.
/Users/jleffler/bin
/local/postgresql/bin
/local/mysql/bin
/Users/jleffler/perl/v5.10.0/bin
/local/bin
/bin
/bin
/sw/bin
/sbin
/sbin
Hubiera esperado recuperar mi ruta original ya que / usr no aparece como un elemento de ruta (completo), solo como parte de un elemento de ruta.
Esto se puede solucionar en replace-path modificando uno de los comandos sed :
export $path=$(echo -n $list | tr ":" "\n" | sed "s:^$removestr\$:$replacestr:" |
tr "\n" ":" | sed "s|::|:|g")
Usé ':' en lugar de '|' para separar partes del sustituto ya que '|' podría (en teoría) aparecer en un componente de ruta, mientras que por definición de RUTA, un colon no puede. Observo que el segundo sed podría eliminar el directorio actual del medio de una RUTA. Es decir, un valor legítimo (aunque perverso) de PATH podría ser:
PATH=/bin::/usr/local/bin
Después de procesar, el directorio actual ya no estará en la RUTA.
Un cambio similar para anclar la coincidencia es apropiado en path-element-by-pattern :
export $target=$(echo -n $list | tr ":" "\n" | grep -m 1 "^$pat\# 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\#!/usr/bin/perl -w
#
# "@(#)$Id: echopath.pl,v 1.7 1998/09/15 03:16:36 jleffler Exp 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
quot;
#
# 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";
}
}
quot;)
replace_path "$path" "$list" "$removestr" "$replacestr"
}
quot;)
Observo de pasada que grep -m 1 no es estándar (es una extensión GNU, también disponible en MacOS X). Y, de hecho, la opción -n para echo tampoco es estándar; sería mejor eliminar simplemente los dos puntos finales que se agregan en virtud de convertir la nueva línea de eco en dos puntos. Dado que path-element-by-pattern se usa solo una vez, tiene efectos secundarios indeseables (disimula cualquier variable exportada preexistente llamada $ removestr ), puede ser reemplazada sensiblemente por su cuerpo. Esto, junto con un uso más liberal de las comillas para evitar problemas con espacios o expansión de nombre de archivo no deseado, conduce a:
.
/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
Tengo un script de Perl llamado echopath que encuentro útil al depurar problemas con variables similares a PATH:
replace_path PATH /usr/bin /work/bin
Cuando ejecuto la solución modificada en el código de prueba a continuación:
list=$(eval echo '
El resultado es:
# 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 '
Esto me parece correcto, al menos, para mi definición de cuál es el problema.
Observo que echopath LD_LIBRARY_PATH evalúa $ LD_LIBRARY_PATH . Sería bueno que sus funciones pudieran hacer eso, para que el usuario pueda escribir:
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
Eso se puede hacer usando:
<*>
Esto lleva a esta revisión del código:
<*>
La siguiente prueba revisada ahora también funciona:
<*>
Produce el mismo resultado que antes.
$path)
El resultado es:
<*>
Esto me parece correcto, al menos, para mi definición de cuál es el problema.
Observo que echopath LD_LIBRARY_PATH evalúa $ LD_LIBRARY_PATH . Sería bueno que sus funciones pudieran hacer eso, para que el usuario pueda escribir:
<*>
Eso se puede hacer usando:
<*>
Esto lleva a esta revisión del código:
<*>
La siguiente prueba revisada ahora también funciona:
<*>
Produce el mismo resultado que antes.
$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 '
Esto me parece correcto, al menos, para mi definición de cuál es el problema.
Observo que echopath LD_LIBRARY_PATH evalúa $ LD_LIBRARY_PATH . Sería bueno que sus funciones pudieran hacer eso, para que el usuario pueda escribir:
<*>
Eso se puede hacer usando:
<*>
Esto lleva a esta revisión del código:
<*>
La siguiente prueba revisada ahora también funciona:
<*>
Produce el mismo resultado que antes.
$path)
El resultado es:
<*>Esto me parece correcto, al menos, para mi definición de cuál es el problema.
Observo que echopath LD_LIBRARY_PATH evalúa $ LD_LIBRARY_PATH . Sería bueno que sus funciones pudieran hacer eso, para que el usuario pueda escribir:
Eso se puede hacer usando:
<*>Esto lleva a esta revisión del código:
<*>La siguiente prueba revisada ahora también funciona:
<*>Produce el mismo resultado que antes.
$path) removepat=$2 replacestr=$3 # Allowed to be empty or unset removestr=$(echo "$list" | tr ":" "\n" | grep -m 1 "^$removepat\<*>quot;) replace_path "$path" "$removestr" "$replacestr" }Esto me parece correcto, al menos, para mi definición de cuál es el problema.
Observo que echopath LD_LIBRARY_PATH evalúa $ LD_LIBRARY_PATH . Sería bueno que sus funciones pudieran hacer eso, para que el usuario pueda escribir:
Eso se puede hacer usando:
<*>Esto lleva a esta revisión del código:
<*>La siguiente prueba revisada ahora también funciona:
<*>Produce el mismo resultado que antes.
$path)El resultado es:
<*>Esto me parece correcto, al menos, para mi definición de cuál es el problema.
Observo que echopath LD_LIBRARY_PATH evalúa $ LD_LIBRARY_PATH . Sería bueno que sus funciones pudieran hacer eso, para que el usuario pueda escribir:
Eso se puede hacer usando:
<*>Esto lleva a esta revisión del código:
<*>La siguiente prueba revisada ahora también funciona:
<*>Produce el mismo resultado que antes.
Otros consejos
Volver a publicar mi respuesta en ¿Cuál es la forma más elegante de eliminar una ruta de la variable $ PATH en 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[*]}"
o el one-liner:
PATH=$(IFS=':';t=($PATH);unset IFS;t=(${t[@]%%*usr*});IFS=':';echo "${t[*]}");
Para eliminar un elemento, puede usar sed:
#!/bin/bash
NEW_PATH=$(echo -n $PATH | tr ":" "\n" | sed "/foo/d" | tr "\n" ":")
export PATH=$NEW_PATH
eliminará las rutas que contienen " foo " del camino.
También puede usar sed para insertar una nueva línea antes o después de una línea dada.
Editar: puede eliminar duplicados pasando por sort y uniq:
echo -n $PATH | tr ":" "\n" | sort | uniq -c | sed -n "/ 1 / s/.*1 \(.*\)/\1/p" | sed "/foo/d" | tr "\n" ":"
Hay un par de programas relevantes en las respuestas a " Cómo evitar duplicar la variable de ruta en csh " ;. Se concentran más en asegurar que no haya elementos repetidos, pero el script que proporciono se puede usar como:
export PATH=$(clnpath $head_dirs:$PATH:$tail_dirs $remove_dirs)
Suponiendo que tiene uno o más directorios en $ head_dirs y uno o más directorios en $ tail_dirs y uno o más directorios en $ remove_dirs, usa el shell para concatenar las partes head, current y tail en un valor masivo, y luego elimina cada uno de los directorios enumerados en $ remove_dirs del resultado (no es un error si no existen), así como elimina la segunda y posteriores ocurrencias de cualquier directorio en la ruta.
Esto no se refiere a colocar componentes de ruta en una posición específica (que no sea al principio o al final, y solo indirectamente). Notacionalmente, especificar dónde desea agregar el nuevo elemento, o qué elemento desea reemplazar, es complicado.
Solo una nota de que bash en sí mismo puede buscar y reemplazar. Puede hacer todo lo normal " una vez o todo " ;, casos [en] opciones sensibles que esperaría.
Desde la página del manual:
$ {parámetro / patrón / cadena}
El patrón se expande para producir un patrón igual que en la expansión del nombre de ruta. El parámetro se expande y la coincidencia más larga del patrón contra su valor se reemplaza con una cadena. Si Ipattern comienza con /, todas las coincidencias de patrón se reemplazan con una cadena. Normalmente solo se reemplaza el primer partido. Si el patrón comienza con #, debe coincidir al comienzo del valor expandido del parámetro. Si el patrón comienza con%, debe coincidir al final del valor expandido del parámetro. Si la cadena es nula, se eliminan las coincidencias de patrón y se puede omitir el / patrón siguiente. Si el parámetro es @ o *, la operación de sustitución se aplica a cada parámetro posicional a su vez, y la expansión es la lista resultante. Si el parámetro es una variable de matriz con subíndice @ o *, la operación de sustitución se aplica a cada miembro de la matriz a su vez, y la expansión es la lista resultante.
También puede dividir campos configurando $ IFS (separador de campo de entrada) en el delimitador deseado.
OK, gracias a todos los que respondieron. He preparado una versión encapsulada de la respuesta de Florin. El primer pase se ve así:
# 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;
}
Todavía necesita captura de errores en todas las funciones, y probablemente debería seguir una solución de ruta repetida mientras estoy en ello.
Lo usas haciendo un replace-path * .
Todavía estoy abierto a nuevas y / o mejores respuestas.
Esto es fácil usando awk.
Reemplazar
{
for(i=1;i<=NF;i++)
if($i == REM)
if(REP)
print REP;
else
continue;
else
print $i;
}
Comience usando
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
Añadir
Inserciones en la posición dada. Por defecto, se agrega al final.
{
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
}
Comience usando
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
Eliminar duplicados
Este mantiene las primeras ocurrencias.
{
for(i = 1; i <= NF; i++) {
if(!used[$i]) {
print $i
used[$i] = 1
}
}
}
Comience así:
echo $PATH | awk -F: -f rem_dup.awk | paste -sd:
Validar si existen todos los elementos
Lo siguiente imprimirá un mensaje de error para todas las entradas que no existen en el sistema de archivos y devolverá un valor distinto de cero.
echo -n $PATH | xargs -d: stat -c %n
Para verificar simplemente si todos los elementos son rutas y obtener un código de retorno, también puede usar test :
echo -n $PATH | xargs -d: -n1 test -d
supongamos
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
Si desea eliminar /lib/jvm/java-1.6.0/bin/ haga lo siguiente
export PATH=$(echo $PATH | sed 's/\/lib\/jvm\/java-1.6.0\/bin\/://g')
sed tomará información de echo $ PATH y reemplazará /lib/jvm/java-1.6.0/bin/: con vacío
de esta manera puedes eliminar
- La orden de RUTA no se distribuye
- Maneja casos de esquina como ruta vacía, espacio en ruta con gracia
- La coincidencia parcial de dir no da falsos positivos
- Trata el camino en la cabeza y la cola de la RUTA de manera adecuada. No : basura y demás.
Di que tienes / foo: / some / path: / some / path / dir1: / some / path / dir2: / bar y quieres reemplazar / some / path Luego reemplaza correctamente " / some / path " pero deja " / some / path / dir1 " o " / some / path / dir2 " ;, como es de esperar.
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
}
Publicación relacionada ¿Cuál es la forma más elegante de eliminar una ruta de la variable $ PATH en Bash?
Prefiero usar ruby ??a los gustos de awk / sed / foo en estos días, así que este es mi enfoque para lidiar con los engañados,
# add it to the path
PATH=~/bin/:$PATH:~/bin
export PATH=$(ruby -e 'puts ENV["PATH"].split(/:/).uniq.join(":")')
crear una función para reutilizar,
mungepath() {
export PATH=$(ruby -e 'puts ENV["PATH"].split(/:/).uniq.join(":")')
}
Hash, matrices y cadenas en un revestimiento de rubí :)
Lo primero que aparece en mi cabeza para cambiar solo una parte de una cadena es una sustitución sed.
ejemplo: si echo $ PATH = > " / usr / pkg / bin: / usr / bin: / bin: / usr / pkg / games: / usr / pkg / X11R6 / bin " luego para cambiar "/ usr / bin" a "/ usr / local / bin" podría hacerse así:
## produce un archivo de salida estándar
## el " = " se usa el carácter en lugar de la barra diagonal (" / ") ya que eso sería desordenado, # caracteres alternativos de comillas deberían ser poco probables en RUTA
## el carácter separador de ruta ": " se elimina y se vuelve a agregar aquí, # podría querer dos puntos extra después de la última ruta
echo $ RUTA | sed '= / usr / bin: = / usr / local / bin: ='
Esta solución reemplaza un elemento de ruta completo, por lo que podría ser redundante si new-element es similar.
Si los nuevos PATH'-s no son dinámicos pero siempre están dentro de un conjunto constante, puede guardar esos en una variable y asignarlos según sea necesario:
RUTA = $ TEMP_PATH_1; # comandos ...; \norte RUTA = $ TEMP_PATH_2; # comandos, etc ...;
Puede que no sea lo que estabas pensando. Algunos de los comandos relevantes en bash / unix serían:
pushd popd discos compactos ls # quizás l -1A para una sola columna; encontrar grep cuál # podría confirmar que el archivo es de donde crees que vino; env tipo
... y todo eso y más tienen algunos relacionados con PATH o directorios en general. ¡La parte que altera el texto se puede hacer de muchas maneras!
Cualquier solución elegida tendría 4 partes:
1) busca la ruta tal como está 2) decodifica el camino para encontrar la parte que necesita cambios 3) determinar qué cambios son necesarios / integrar esos cambios 4) validación / integración final / configuración de la variable
En línea con respuesta de dj_segfault , hago esto en scripts que agregan / anteponen variables de entorno que pueden ejecutarse varias veces :
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}}
Usar esta misma técnica para eliminar, reemplazar o manipular entradas en PATH es trivial dada la coincidencia de patrones similar a la expansión del nombre de archivo y el soporte de la lista de patrones de la expansión de parámetros de shell.
