¿Cómo puedo anular la exportación de una variable sin perder su valor?

Digamos que exporté una variable:

foo=bar
export foo

Ahora, me gustaría desexportarlo. Es decir, si lo hago, sh -c 'echo "$foo"'no debería hacerlo bar. foono debería aparecer en sh -cel entorno del todo. sh -ces simplemente un ejemplo, una manera fácil de mostrar la presencia de una variable. El comando podría ser cualquier cosa, puede ser algo cuyo comportamiento se ve afectado simplemente por la presencia de la variable en su entorno.

Yo puedo:

1. unset la variable, y la pierdes
2. Elimínelo usando envpara cada comando:env -u foo sh -c 'echo "$foo"'
   • poco práctico si desea continuar usando el shell actual por un tiempo.

Idealmente, me gustaría mantener el valor de la variable, pero que no se muestre en absoluto en un proceso secundario, ni siquiera como una variable vacía.

Supongo que podría hacer:

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

Esto corre el riesgo de pisotear otherfoo, si ya existe.

¿Es esa la única forma? ¿Hay alguna forma estándar?

No hay una forma estándar.

Puede evitar usar una variable temporal usando una función. La siguiente función se encarga de mantener las variables no establecidas y las variables vacías vacías. Sin embargo, no admite características que se encuentran en algunos shells, como variables de solo lectura o de tipo.

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

En ksh, bash y zsh, puede exportar una variable con typeset +x foo. Esto conserva propiedades especiales como los tipos, por lo que es preferible usarlo. Creo que todos los proyectiles que tienen typesetincorporado tienen typeset +x.

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

EDIT: Para bashúnica, como se ha señalado en los comentarios:

La -nopción para exporteliminar la exportpropiedad de cada nombre de pila. (Ver help export)

Así que para bash, el comando que desea es:export -n foo

Escribí una función POSIX similar, pero esto no arriesga la ejecución de código arbitrario:

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

También manejará tantos argumentos como desee para proporcionarlo. Si un argumento es un nombre válido que de otro modo no está establecido, se ignora en silencio. Si un argumento es un nombre incorrecto, escribe en stderr y se detiene según corresponda, aunque cualquier nombre válido que precede a un inválido en su línea de comando aún se procesará.

Pensé en otra forma. Me gusta mucho mejor.

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

Bueno, ambos usan muchas de las mismas técnicas. Básicamente, si un shell var está desarmado, una referencia a él no se expandirá con una +expansión de parámetros. Pero si se establece, independientemente de su valor, una expansión de parámetros como: ${parameter+word}se expandirá a word, y no al valor de la variable. Y así, las variables de shell se autoevalúan y sustituyen automáticamente en caso de éxito.

También pueden fallar a sí mismos . En la función de la parte superior si un nombre mal se encuentra muevo $1en $2y la licencia $1nula debido a que el siguiente que hago es o bien returnel éxito si todos los argumentos han sido procesados y el bucle llega a su fin, o, si el arg no era válida, el shell ampliar la $2en $1:?que matará a una concha con guión y devolver una interrupción de un interactivo al escribir worden stderr.

En el segundo getoptshace las tareas. Y no asignará un nombre incorrecto, más bien escribirlo escribirá un mensaje de error estándar para stderr. Además, guarda el valor del argumento $OPTARG si el argumento era el nombre de una variable establecida en primer lugar. Entonces, después de hacer getoptstodo lo que se necesita es la expansión de evalun conjunto OPTARGen la asignación apropiada.