كيف يمكنني التعامل مع عناصر PATH $ في البرامج النصية لـ Shell؟

StackOverflow https://stackoverflow.com/questions/273909

سؤال

هل هناك طريقة اصطلاحية لإزالة العناصر من متغيرات الصدفة المشابهة لـ PATH؟

هذا هو ما أريد أن آخذه

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

و يزيل أو يستبدل ال /path/to/app/bin دون ضرب بقية المتغير.نقاط اضافية للسماح لي يضع عناصر جديدة في المواقف التعسفية.سيتم التعرف على الهدف من خلال سلسلة محددة جيدًا، وقد يحدث في أي نقطة في القائمة.

أعلم أنني رأيت هذا يتم تنفيذه، وربما يمكنني تجميع شيء معًا بمفردي، لكنني أبحث عن أسلوب لطيف.قابلية النقل والتوحيد زائد.

أنا أستخدم bash، ولكن الأمثلة مرحب بها في الصدفة المفضلة لديك أيضًا.

السياق هنا هو الحاجة إلى التبديل بسهولة بين إصدارات متعددة (واحدة لإجراء التحليل، وأخرى للعمل على إطار العمل) لحزمة تحليل علمية كبيرة تنتج عشرات الملفات التنفيذية، وتحتوي على بيانات مخبأة حول نظام الملفات، وتستخدم متغير البيئة للمساعدة في العثور على كل هذه الأشياء.أرغب في كتابة برنامج نصي يحدد الإصدار، وأحتاج إلى أن أكون قادرًا على إزالة ملف $PATH العناصر المتعلقة بالإصدار النشط حاليًا واستبدالها بنفس العناصر المتعلقة بالإصدار الجديد.

ويرتبط هذا بمشكلة منع التكرار $PATH العناصر عند إعادة تشغيل البرامج النصية لتسجيل الدخول وما شابه.

هل كانت مفيدة؟

المحلول

معالجة الحل المقترح من dmckee:

  1. في حين أن بعض إصدارات Bash قد تسمح بالواصلات في أسماء الوظائف، إلا أن الإصدارات الأخرى (MacOS X) لا تسمح بذلك.
  2. لا أرى حاجة لاستخدام return مباشرة قبل نهاية الوظيفة.
  3. لا أرى ضرورة لكل الفواصل المنقوطة.
  4. لا أفهم سبب تصدير قيمة لعنصر المسار حسب النمط.افكر في export كمعادل لإعداد (أو حتى إنشاء) متغير عام - وهو أمر يجب تجنبه كلما أمكن ذلك.
  5. لست متأكدًا مما تتوقعه"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")

لقد استخدمت ':' بدلا من '|' لفصل أجزاء من البديل لأن "|" يمكن (من الناحية النظرية) أن تظهر في مكون PATH ، بينما بتعريف PATH ، لا يمكن للقولون.وألاحظ أن الثاني sed يمكن إزالة الدليل الحالي من منتصف PATH.وهذا يعني أن القيمة المشروعة (وإن كانت ضارة) لـ PATH يمكن أن تكون:

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

بعد المعالجة، لن يكون الدليل الحالي موجودًا على المسار.

من المناسب إجراء تغيير مماثل لتثبيت المباراة path-element-by-pattern:

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

وألاحظ في تمرير ذلك grep -m 1 ليس قياسيًا (إنه امتداد GNU، ومتوفر أيضًا على نظام التشغيل MacOS X).وبالفعل،-n خيار ل 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"
}

لدي برنامج نصي بيرل يسمى 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 لإدراج سطر جديد قبل أو بعد سطر معين.

يحرر:يمكنك إزالة التكرارات عن طريق التوصيل عبر الفرز و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
  • يتعامل مع حالات الزوايا مثل المسار الفارغ والمساحة الموجودة في المسار بأمان
  • المطابقة الجزئية للدير لا تعطي نتائج إيجابية كاذبة
  • يعالج المسار عند رأس وذيل PATH بطرق مناسبة.لا : القمامة وما شابه.

لنفترض أن لديك / foo: / بعض / مسار: / بعض / مسار / dir1: / بعض / مسار / dir2: / شريط وتريد استبدال / بعض / المسار ثم يحل محل "/ بعض / المسار بشكل صحيح" ولكن يترك "/ some / 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؟

أفضّل استخدام روبي على أمثال 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.

مثال:إذا كان صدى $PATH = > "/ usr / pkg / bin: / usr / bin: / bin: / usr / pkg / games: / usr / pkg / X11R6 / bin" ثم لتغيير "/ usr / bin" إلى "/ usr / local / bin" يمكن القيام به على النحو التالي:

## ينتج ملف الإخراج القياسي

## يتم استخدام الحرف "=" بدلا من الشرطة المائلة ("/") لأن ذلك سيكون فوضويا ، # يجب أن يكون حرف الاقتباس البديل غير مرجح في PATH

## تمت إزالة الحرف الفاصل للمسار ":" وإعادة إضافته هنا ، # قد تريد نقطتين إضافيتين بعد المسار الأخير

إيكو $PATH | sed '= / usr / bin: = / usr / local / bin: ='

يستبدل هذا الحل عنصر المسار بالكامل، لذا قد يكون زائدًا عن الحاجة إذا كان العنصر الجديد مشابهًا.

إذا لم تكن مسارات PATH الجديدة ديناميكية ولكن دائمًا ضمن مجموعة ثابتة، فيمكنك حفظها أولئك في متغير وتعيين حسب الحاجة:

PATH=$TEMP_PATH_1;#الأوامر...; المسار = $TEMP_PATH_2 ؛#الأوامر الخ...;

ربما لا يكون ما كنت تفكر فيه.بعض الأوامر ذات الصلة على bash/unix ستكون:

دفع بوبد سي دي ls # ربما l -1A لعمود واحد ؛وجد جريب الذي # يمكن أن يؤكد أن الملف هو المكان الذي تعتقد أنه جاء منه ؛الحياه الفطريه نوع

..وكل ذلك وأكثر بعض تؤثر على 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
scroll top