Jak mogę wyeksportować zmienną bez utraty jej wartości?

Powiedzmy, że wyeksportowałem zmienną:

foo=bar
export foo

Teraz chciałbym go wyeksportować. To znaczy, jeśli nie, sh -c 'echo "$foo"'nie powinienem bar. foow ogóle nie powinien pojawić się w sh -cśrodowisku. sh -cjest jedynie przykładem, łatwym sposobem na pokazanie obecności zmiennej. Poleceniem może być cokolwiek - może to być coś, na którego zachowanie wpływa po prostu obecność zmiennej w jej otoczeniu.

Mogę:

1. unset zmienną i zgub ją
2. Usuń go za pomocą envkażdego polecenia:env -u foo sh -c 'echo "$foo"'
   • niepraktyczne, jeśli chcesz nadal używać bieżącej powłoki.

Idealnie chciałbym zachować wartość zmiennej, ale nie pokazywać jej wcale w procesie potomnym, nawet jako pustej zmiennej.

Chyba mógłbym zrobić:

otherfoo="$foo"; unset foo; foo="$otherfoo"; unset otherfoo

Grozi to tupnięciem otherfoo, jeśli już istnieje.

Czy to jedyny sposób? Czy są jakieś standardowe sposoby?

Nie ma standardowego sposobu.

Można uniknąć używania zmiennej tymczasowej za pomocą funkcji. Poniższa funkcja dba o to, aby nieuzbrojone zmienne nieuzbrojone i puste zmienne puste. Nie obsługuje jednak funkcji znalezionych w niektórych powłokach, takich jak zmienne tylko do odczytu lub zmienne typowane.

unexport () {
  while [ "$#" -ne 0 ]; do
    eval "set -- \"\${$1}\" \"\${$1+set}\" \"\$@\""
    if [ -n "$2" ]; then
      unset "$3"
      eval "$3=\$1"
    fi
    shift; shift; shift
  done
}
unexport foo bar

W ksh, bash i zsh możesz wyeksportować zmienną za pomocą typeset +x foo. Zachowuje to specjalne właściwości, takie jak typy, więc lepiej go używać. Myślę, że wszystkie powłoki, które mają typesetwbudowane, mają typeset +x.

case $(LC_ALL=C type typeset 2>&1) in
  typeset\ *\ builtin) unexport () { typeset +x -- "$@"; };;
  *) unexport () { … };; # code above
esac

EDIT: W przypadku bashtylko, jak wskazano w komentarzach:

-nOpcja exportusuwa exportnieruchomość z każdej podanej nazwie. (Patrz help export.)

Więc dla bash, komenda chcesz to:export -n foo

Napisałem podobną funkcję POSIX, ale nie ryzykuje to wykonania dowolnego kodu:

unexport()
    while case ${1##[0-9]*} in                   ### rule out leading numerics
          (*[!_[:alnum:]]*|"")                   ### filter out bad|empty names
          set "" ${1+"bad name: '$1'"}           ### prep bad name error
          return ${2+${1:?"$2"}}                 ### fail w/ above err or return 
          esac
    do    eval  set '"$'"{$1+$1}"'" "$'"$1"'" "$'@\" ###  $1 = (  $1+ ? $1 : "" )
          eval  "${1:+unset $1;$1=\$2;} shift 3"     ### $$1 = ( $1:+ ? $2 : -- )
    done

Będzie również obsługiwał tyle argumentów, ile chcesz. Jeśli argument jest prawidłową nazwą, która nie jest jeszcze ustawiona, jest dyskretnie ignorowany. Jeśli argument jest złą nazwą, zapisuje go do stderr i zatrzymuje odpowiednio, chociaż każda poprawna nazwa poprzedzająca niepoprawną w wierszu poleceń będzie nadal przetwarzana.

Myślałem o innym sposobie. Bardziej mi się podoba.

unexport()
        while   unset OPTARG; OPTIND=1           ### always work w/ $1
                case  ${1##[0-9]*}    in         ### same old same old
                (*[!_[:alnum:]]*|"")             ### goodname && $# > 0 || break
                    ${1+"getopts"} : "$1"        ### $# ? getopts : ":"
                    return                       ### getopts errored or ":" didnt
                esac
        do      eval   getopts :s: '"$1" -"${'"$1+s}-\$$1\""
                eval   unset  "$1;  ${OPTARG+$1=\${OPTARG}#-}"
                shift
        done

Oba wykorzystują wiele takich samych technik. Zasadniczo, jeśli zmienna powłoki jest rozbrojona, odniesienie do niej nie będzie rozszerzane wraz z +rozszerzaniem parametrów. Ale jeśli jest ustawiony - niezależnie od jego wartości - rozszerzenie parametru takie jak: ${parameter+word}zostanie rozwinięte do word- a nie do wartości zmiennej. Tak więc zmienne powłoki wykonują autotest i zastępują się sukcesem.

Mogą również zawieść . W górnej funkcji, jeśli zostanie znaleziona zła nazwa, przechodzę $1do $2i pozostawiam $1null, ponieważ następną rzeczą, którą robię, jest albo returnsukces, jeśli wszystkie argumenty zostały przetworzone i pętla jest na końcu, lub, jeśli argument był nieprawidłowy, powłoka będzie rozwiń, $2w $1:?który zabije skryptowaną powłokę i zwróci przerwanie do interaktywnej podczas pisania worddo stderr.

W drugim getoptswykonuje się zadania. I nie przypisuje złej nazwy - raczej napisz, wypisze standardowy komunikat o błędzie do stderr. Co więcej, zapisuje wartość arg, $OPTARG jeśli argument był w pierwszej kolejności nazwą zmiennej ustawionej. Po zrobieniu getoptswszystko, co jest potrzebne, to rozszerzenie evalzestawu OPTARGdo odpowiedniego zadania.