¿Cuál es la forma correcta de modificar variables de entorno como PATH en OS X?

He buscado un poco en Google y he encontrado tres archivos diferentes para editar:

• / etc / caminos
• ~ / .profile
• ~ / .tcshrc

Ni siquiera tengo algunos de estos archivos, y estoy bastante seguro de que .tcshrc está mal, ya que OS X usa bash ahora. ¿Dónde se definen estas variables, especialmente la RUTA?

Estoy ejecutando OS X v10.5 (Leopard).

Bruno está en el buen camino. He realizado una investigación exhaustiva y si desea establecer variables que están disponibles en todas las aplicaciones GUI, su única opción es /etc/launchd.conf.

Tenga en cuenta que environment.plist no funciona para aplicaciones iniciadas a través de Spotlight. Esto está documentado por Steve Sexton aquí .

1. Abrir un indicador de terminal

2. Tipo sudo vi /etc/launchd.conf(nota: es posible que este archivo aún no exista)

3. Ponga contenidos como el siguiente en el archivo

   # Set environment variables here so they are available globally to all apps
   # (and Terminal), including those launched via Spotlight.
   #
   # After editing this file run the following command from the terminal to update
   # environment variables globally without needing to reboot.
   # NOTE: You will still need to restart the relevant application (including
   # Terminal) to pick up the changes!
   # grep -E "^setenv" /etc/launchd.conf | xargs -t -L 1 launchctl
   #
   # See http://www.digitaledgesw.com/node/31
   # and http://stackoverflow.com/questions/135688/setting-environment-variables-in-os-x/
   #
   # Note that you must hardcode the paths below, don't use environment variables.
   # You also need to surround multiple values in quotes, see MAVEN_OPTS example below.
   #
   setenv JAVA_VERSION 1.6
   setenv JAVA_HOME /System/Library/Frameworks/JavaVM.framework/Versions/1.6/Home
   setenv GROOVY_HOME /Applications/Dev/groovy
   setenv GRAILS_HOME /Applications/Dev/grails
   setenv NEXUS_HOME /Applications/Dev/nexus/nexus-webapp
   setenv JRUBY_HOME /Applications/Dev/jruby
   
   setenv ANT_HOME /Applications/Dev/apache-ant
   setenv ANT_OPTS -Xmx512M
   
   setenv MAVEN_OPTS "-Xmx1024M -XX:MaxPermSize=512m"
   setenv M2_HOME /Applications/Dev/apache-maven
   
   setenv JMETER_HOME /Applications/Dev/jakarta-jmeter

4. Guarde sus cambios en vi y reinicie su Mac. O utilice el comando grep/ xargsque se muestra en el comentario del código anterior.

5. Demuestre que sus variables están funcionando abriendo una ventana de Terminal y escribiendo exporty debería ver sus nuevas variables. También estarán disponibles en IntelliJ IDEA y otras aplicaciones GUI que inicie a través de Spotlight.

Cómo configurar el entorno para nuevos procesos iniciados por Spotlight (sin necesidad de reiniciar)

Puede configurar el entorno utilizado por launchd (y, por extensión, todo lo que comenzó desde Spotlight) con launchctl setenv. Por ejemplo, para establecer la ruta:

launchctl setenv PATH /opt/local/bin:/opt/local/sbin:/usr/bin:/bin:/usr/sbin:/sbin

O si desea configurar su ruta .bashrco similar, haga que se refleje en launchd:

PATH=/opt/local/bin:/opt/local/sbin:/usr/bin:/bin:/usr/sbin:/sbin
launchctl setenv PATH $PATH

No hay necesidad de reiniciar, aunque necesitará reiniciar una aplicación si desea que recoja el entorno modificado.

Esto incluye todos los shells que ya se ejecutan en Terminal.app, aunque si está allí puede configurar el entorno más directamente, por ejemplo, con export PATH=/opt/local/bin:/opt/local/sbin:$PATHbash o zsh.

Cómo mantener los cambios después de un reinicio

Para mantener los cambios después de un reinicio , puede establecer las variables de entorno desde /etc/launchd.conf:

setenv PATH /opt/local/bin:/opt/local/sbin:/usr/bin:/bin:/usr/sbin:/sbin

launchd.conf se ejecuta automáticamente cuando reinicia.

Si desea que estos cambios surtan efecto ahora, debe usar este comando para reprocesar launchctl.conf(¡gracias @mklement por la sugerencia!)

egrep -v '^\s*#' /etc/launchd.conf | launchctl

Puede obtener más información sobre launchctlcómo se carga launchd.confcon el comando man launchctl.

Hasta OS X v10.7 (Lion) inclusive , puede configurarlos en:

~/.MacOSX/environment.plist

Ver:

• https://developer.apple.com/legacy/library/qa/qa1067/_index.html
• https://developer.apple.com/library/content/documentation/MacOSX/Conceptual/BPRuntimeConfig/Articles/EnvironmentVars.html

Para PATH en la Terminal, deberías poder configurar .bash_profileo .profile(aunque probablemente tengas que crearlo)

Para OS X v10.8 (Mountain Lion) y más allá , necesita usar launchdylaunchctl .

Solución para aplicaciones de línea de comandos y GUI desde una sola fuente (funciona con Mac OS X v10.10 (Yosemite) y Mac OS X v10.11 (El Capitan))

Supongamos que tiene definiciones de variables de entorno en su ~/.bash_profilegusto en el siguiente fragmento:

export JAVA_HOME="$(/usr/libexec/java_home -v 1.8)"
export GOPATH="$HOME/go"
export PATH="$PATH:/usr/local/opt/go/libexec/bin:$GOPATH/bin"
export PATH="/usr/local/opt/coreutils/libexec/gnubin:$PATH"
export MANPATH="/usr/local/opt/coreutils/libexec/gnuman:$MANPATH"

Necesitamos un Agente de inicio que se ejecutará en cada inicio de sesión y en cualquier momento a pedido que cargue estas variables en la sesión del usuario. También necesitaremos un script de shell para analizar estas definiciones y crear los comandos necesarios para que el agente los ejecute.

Cree un archivo con plistsufijo (por ejemplo, nombrado osx-env-sync.plist) en el ~/Library/LaunchAgents/directorio con los siguientes contenidos:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
  <key>Label</key>
  <string>osx-env-sync</string>
  <key>ProgramArguments</key>
  <array>
    <string>bash</string>
    <string>-l</string>
    <string>-c</string>
    <string>
      $HOME/.osx-env-sync.sh
    </string>
  </array>
  <key>RunAtLoad</key>
  <true/>
</dict>
</plist>

-lel parámetro es crítico aquí; es necesario para ejecutar el script de shell con un shell de inicio de sesión para que ~/.bash_profilese obtenga en primer lugar antes de que se ejecute este script.

Ahora, el script de shell. Créelo en ~/.osx-env-sync.shcon los siguientes contenidos:

grep export $HOME/.bash_profile | while IFS=' =' read ignoreexport envvar ignorevalue; do
  launchctl setenv ${envvar} ${!envvar}
done

Asegúrese de que el script de shell sea ejecutable:

chmod +x ~/.osx-env-sync.sh

Ahora, cargue el agente de lanzamiento para la sesión actual:

launchctl load ~/Library/LaunchAgents/osx-env-sync.plist

(Re) Inicie una aplicación GUI y verifique que puede leer las variables de entorno.

La configuración es persistente. Sobrevivirá a los reinicios y reinicios de sesión.

Después de la configuración inicial (que acaba de hacer), si desea reflejar cualquier cambio en su ~/.bash_profileentorno completo nuevamente, volver a ejecutar el launchctl load ...comando no realizará lo que desea; en su lugar, recibirá una advertencia como la siguiente:

<$HOME>/Library/LaunchAgents/osx-env-sync.plist: Operation already in progress

Para volver a cargar las variables de entorno sin pasar por el proceso de cierre de sesión / inicio de sesión, haga lo siguiente:

launchctl unload ~/Library/LaunchAgents/osx-env-sync.plist
launchctl load ~/Library/LaunchAgents/osx-env-sync.plist

Finalmente, asegúrese de relanzar sus aplicaciones que ya se están ejecutando (incluida Terminal.app) para informarles de los cambios.

También envié el código y las explicaciones aquí a un proyecto de GitHub: osx-env-sync .

Espero que esta sea la solución definitiva, al menos para las últimas versiones de OS X (Yosemite y El Capitan).

1. Hacer:

   vim ~/.bash_profile

   Es posible que el archivo no exista (si no, simplemente puede crearlo).

2. Escriba esto y guarde el archivo:

   export PATH=$PATH:YOUR_PATH_HERE

3. correr

   source ~/.bash_profile

Esencialmente, hay dos problemas que resolver cuando se trata con variables de entorno en OS X. El primero es al invocar programas desde Spotlight (el icono de la lupa en el lado derecho del menú Mac / barra de estado) y el segundo al invocar programas desde el Dock . La invocación de programas desde una aplicación de Terminal / utilidad es trivial ya que lee el medio ambiente de los lugares de concha estándar ( ~/.profile, ~/.bash_profile, ~/.bashrc, etc.)

Al invocar programas desde el Dock, use ~/.MacOSX/environment.plist donde el <dict>elemento contiene una secuencia de <key>KEY</key><string>theValue</string>elementos.

Al invocar programas desde Spotlight, asegúrese de que launchd se haya configurado con todas las configuraciones de clave / valor que necesita.

Para resolver ambos problemas simultáneamente, utilizo un elemento de inicio de sesión (configurado a través de la herramienta de Preferencias del Sistema) en mi cuenta de Usuario. El elemento de inicio de sesión es un script bash que invoca una función Emacs lisp, aunque, por supuesto, se puede usar su herramienta de secuencias de comandos favorita para lograr lo mismo. Este enfoque tiene el beneficio adicional de que funciona en cualquier momento y no requiere un reinicio, es decir, se puede editar ~/.profile, ejecutar el elemento de inicio de sesión en algún shell y tener los cambios visibles para los programas recién invocados, ya sea desde el Dock o Spotlight.

Detalles:

Elemento de inicio de sesión: ~/bin/macosx-startup

#!/bin/bash
bash -l -c "/Applications/Emacs.app/Contents/MacOS/Emacs --batch -l ~/lib/emacs/elisp/macosx/environment-support.el -f generate-environment"

Función Emacs lisp: ~/lib/emacs/elisp/macosx/envionment-support.el

;;; Provide support for the environment on Mac OS X

(defun generate-environment ()
  "Dump the current environment into the ~/.MacOSX/environment.plist file."
  ;; The system environment is found in the global variable:
  ;; 'initial-environment' as a list of "KEY=VALUE" pairs.
  (let ((list initial-environment)
        pair start command key value)
    ;; clear out the current environment settings
    (find-file "~/.MacOSX/environment.plist")
    (goto-char (point-min))
    (setq start (search-forward "<dict>\n"))
    (search-forward "</dict>")
    (beginning-of-line)
    (delete-region start (point))
    (while list
      (setq pair (split-string (car list) "=")
            list (cdr list))
      (setq key (nth 0 pair)
            value (nth 1 pair))
      (insert "  <key>" key "</key>\n")
      (insert "  <string>" value "</string>\n")

      ;; Enable this variable in launchd
      (setq command (format "launchctl setenv %s \"%s\"" key value))
      (shell-command command))
    ;; Save the buffer.
    (save-buffer)))

NOTA: Esta solución es una amalgama de las que vinieron antes de agregar la mía, particularmente la ofrecida por Matt Curtis, pero he tratado deliberadamente de mantener mi ~/.bash_profileplataforma de contenido independiente y poner la configuración del launchdentorno (una instalación solo para Mac) en un script separado .

Otra solución gratuita / de código abierto para Mac OS X v10.8 (Mountain Lion) Preference pane / environment.plist es EnvPane .

El código fuente de EnvPane está disponible en GitHub . Parece que EnvPane tiene características comparables a RCEnvironment , sin embargo, parece que puede actualizar sus variables almacenadas al instante, es decir, sin la necesidad de reiniciar o iniciar sesión, lo cual es bienvenido.

Según lo declarado por el desarrollador:

EnvPane es un panel de preferencias para Mac OS X 10.8 (Mountain Lion) que le permite establecer variables de entorno para todos los programas en sesiones gráficas y terminales. No solo restaura la compatibilidad con ~ / .MacOSX / environment.plist en Mountain Lion, sino que también publica sus cambios en el entorno de inmediato, sin necesidad de cerrar sesión y volver a iniciarla. <SNIP> EnvPane incluye (e instala automáticamente) un Agente de launchd que se ejecuta 1) temprano después de iniciar sesión y 2) cada vez que cambia ~ / .MacOSX / environment.plist. El agente lee ~ / .MacOSX / environment.plist y exporta las variables de entorno de ese archivo a la instancia de launchd del usuario actual a través de la misma API que utilizan launchctl setenv y launchctl unsetenv.

Descargo de responsabilidad: de ninguna manera estoy relacionado con el desarrollador o su proyecto.

PD: Me gusta el nombre (suena como 'Termina el dolor').

Actualización (2017-08-04)

A partir de (al menos) macOS 10.12.6 (Sierra), este método parece haber dejado de funcionar para Apache httpd (tanto para systemla useropción como para la launchctl config). Otros programas no parecen verse afectados. Es concebible que este sea un error en httpd.

Respuesta original

Esto se refiere a OS X 10.10+ (10.11+ específicamente debido al modo sin raíz donde /usr/binya no se puede escribir).

He leído en varios lugares que usar launchctl setenv PATH <new path>para configurar la PATHvariable no funciona debido a un error en OS X (lo que parece cierto por experiencia personal). Descubrí que hay otra forma de PATHconfigurar las aplicaciones que no se inician desde el shell :

sudo launchctl config user path <new path>

Esta opción está documentada en la página de manual de launchctl:

sistema de configuración | valor de parámetro de usuario

Establece información de configuración persistente para dominios launchd (8). Solo se pueden configurar el dominio del sistema y los dominios de usuario. La ubicación del almacenamiento persistente es un detalle de implementación, y los cambios en ese almacenamiento solo deben realizarse a través de este subcomando. Es necesario reiniciar para que los cambios realizados a través de este subcomando surtan efecto.

[...]

camino

Establece la variable de entorno PATH para todos los servicios dentro del dominio de destino en el valor de cadena. El valor de la cadena debe cumplir con el formato descrito para la variable de entorno PATH en Environ (7). Tenga en cuenta que si un servicio especifica su propia RUTA, la variable de entorno específica del servicio tendrá prioridad.

NOTA: Esta función no se puede usar para establecer variables de entorno generales para todos los servicios dentro del dominio. Tiene un alcance intencional para la variable de entorno PATH y nada más por razones de seguridad.

He confirmado que esto funciona con una aplicación GUI iniciada desde Finder (que se usa getenvpara obtener PATH). Tenga en cuenta que solo tiene que hacer esto una vez y el cambio será persistente a través de reinicios.

En Mountain Lion todo el /etc/pathsy /etc/launchd.confla edición No tiene ningún efecto!

Los foros de desarrolladores de Apple dicen:

"Cambie el Info.plist del .app para que contenga un diccionario" LSEnvironment "con las variables de entorno que desee.

~ / .MacOSX / environment.plist ya no es compatible ".

Así que Info.plistedité directamente la aplicación (haga clic derecho en "AppName.app" (en este caso SourceTree) y luego " Show package contents").

Y agregué un nuevo par clave / dict llamado:

<key>LSEnvironment</key>
<dict>
     <key>PATH</key>
     <string>/Users/flori/.rvm/gems/ruby-1.9.3-p362/bin:/Users/flori/.rvm/gems/ruby-1.9.3-p362@global/bin:/Users/flori/.rvm/rubies/ruby-1.9.3-p326/bin:/Users/flori/.rvm/bin:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin:</string>
</dict>

(ver: LaunchServicesKeys Documentation en Apple )

Ahora la aplicación (en mi caso Sourcetree) usa la ruta dada y funciona con Git 1.9.3 :-)

PD: Por supuesto, debe ajustar la entrada de ruta a sus necesidades de ruta específicas.

Si bien las respuestas aquí no son "incorrectas", agregaré otra: nunca realice cambios en las variables de entorno en OS X que afecten a "todos los procesos", o incluso, fuera del shell, para todos los procesos ejecutados interactivamente por un usuario determinado.

En mi experiencia, los cambios globales en las variables de entorno como PATH para todos los procesos son aún más propensos a romper cosas en OS X que en Windows. La razón es que muchas aplicaciones de OS X y otro software (incluidos, quizás especialmente, componentes del sistema operativo en sí) dependen de las herramientas de línea de comandos de UNIX bajo el capó, y asumen el comportamiento de las versiones de estas herramientas proporcionadas con el sistema, y no necesariamente use rutas absolutas al hacerlo (comentarios similares se aplican a bibliotecas cargadas dinámicamente y variables de entorno DYLD_ *). Considere, por ejemplo, que las respuestas mejor calificadas a varias preguntas de Stack Overflow sobre el reemplazo de versiones de intérpretes suministradas por OS X como Python y Ruby generalmente dicen "no haga esto".

OS X no es realmente diferente de otros sistemas operativos similares a UNIX (por ejemplo, Linux, FreeBSD y Solaris) a este respecto; La razón más probable por la que Apple no proporciona una manera fácil de hacer esto es porque rompe las cosas . En la medida en que Windows no es tan propenso a estos problemas, se debe a dos cosas: (1) el software de Windows no tiende a depender de herramientas de línea de comandos en la medida en que lo hace el software UNIX, y (2) Microsoft ha tenido Un historial tan extenso tanto de "infierno de DLL" como de problemas de seguridad causados ​​por cambios que afectan a todos los procesos que han cambiado el comportamiento de la carga dinámica en las versiones más recientes de Windows para limitar el impacto de las opciones de configuración "globales" como PATH.

"Cojo" o no, tendrá un sistema mucho más estable si restringe dichos cambios a ámbitos más pequeños.

A veces, todas las respuestas anteriores simplemente no funcionan. Si desea tener acceso a una variable del sistema (como M2_HOME) en Eclipse o en IntelliJ IDEA, lo único que me funciona en este caso es:

Primero (paso 1) edite /etc/launchd.confpara contener una línea como esta: "setenv VAR value" y luego (paso 2) reinicie.

Simplemente modificar .bash_profile no funcionará porque en OS X las aplicaciones no se inician como en otros Unix; no heredan las variables de shell del padre. Todas las otras modificaciones no funcionarán por una razón que desconozco. Quizás alguien más pueda aclarar sobre esto.

Después de perseguir el panel de preferencias de Variables de entorno y descubrir que el enlace está roto y una búsqueda en el sitio de Apple parece indicar que lo han olvidado ... Empecé de nuevo en el rastro del difícil proceso de lanzamiento.

En mi sistema (Mac OS X 10.6.8) parece que las variables definidas en environment.plist se exportan de manera confiable a las aplicaciones iniciadas desde Spotlight (a través de launchd). Mi problema es que esos vars no se exportan a nuevas sesiones de bash en Terminal. Es decir, tengo el problema opuesto como se describe aquí.

NOTA: environment.plist se parece a JSON, no a XML, como se describió anteriormente

Pude obtener aplicaciones de Spotlight para ver los vars editando ~ / MacOSX / environment.plist y pude forzar los mismos vars a una nueva sesión de Terminal al agregar lo siguiente a mi archivo .profile:

eval $(launchctl export)

Cualquiera de los archivos de la puesta en marcha del golpe - ~/.bashrc, ~/.bash_profile, ~/.profile. También hay algún tipo de archivo extraño llamado ~/.MacOSX/environment.plistpara variables de entorno en aplicaciones GUI.

Al igual que la respuesta que dio Matt Curtis, configuro variables de entorno a través de launchctl, pero lo envuelvo en una función llamada exportar, de modo que cada vez que exporto una variable como normal en mi .bash_profile, también se establece mediante launchctl. Esto es lo que hago:

1. Mi .bash_profile consta únicamente de una línea, (Esto es solo una preferencia personal).

   source .bashrc

2. Mi .bashrc tiene esto:

   function export()
   {
       builtin export "$@"
       if [[ ${#@} -eq 1 && "${@//[^=]/}" ]]
       then
           launchctl setenv "${@%%=*}" "${@#*=}"
       elif [[ ! "${@//[^ ]/}" ]]
       then
           launchctl setenv "${@}" "${!@}"
       fi
   }
   
   export -f export

3. Lo anterior sobrecargará la "exportación" incorporada de Bash y exportará todo normalmente (¡notará que exporto "exportar" con él), luego los configurará correctamente para entornos de aplicaciones OS X a través de launchctl, ya sea que use alguno de los siguientes:

   export LC_CTYPE=en_US.UTF-8
   # ~$ launchctl getenv LC_CTYPE
   # en_US.UTF-8
   PATH="/usr/local/bin:${PATH}"
   PATH="/usr/local/opt/coreutils/libexec/gnubin:${PATH}"
   export PATH
   # ~$ launchctl getenv PATH
   # /usr/local/opt/coreutils/libexec/gnubin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin
   export CXX_FLAGS="-mmacosx-version-min=10.9"
   # ~$ launchctl getenv CXX_FLAGS
   # -mmacosx-version-min=10.9

4. De esta manera, no tengo que enviar todas las variables a launchctl cada vez, y simplemente puedo configurar mi .bash_profile / .bashrc de la forma que quiero. Abra una ventana de terminal, revise las variables de entorno que le interesan launchctl getenv myVar, cambie algo en su .bash_profile / .bashrc, cierre la ventana de terminal y vuelva a abrirla, verifique la variable nuevamente con launchctl, y listo, está cambiado.

5. Nuevamente, al igual que las otras soluciones para el mundo posterior a Mountain Lion, para que las nuevas variables de entorno estén disponibles para las aplicaciones, debe iniciarlas o reiniciarlas después del cambio.

Aquí hay una manera muy simple de hacer lo que quieres. En mi caso, estaba haciendo que Gradle funcionara (para Android Studio).

• Abre la Terminal.

• Ejecute el siguiente comando:

  sudo nano /etc/paths o sudo vim /etc/paths

• Introduzca su contraseña cuando se le solicite.

• Vaya al final del archivo e ingrese la ruta que desea agregar.
• Presiona Control+ Xpara salir.
• Ingrese 'Y' para guardar el búfer modificado.

• Abra una nueva ventana de terminal y luego escriba:

  echo $PATH

Debería ver la nueva ruta adjunta al final de la RUTA.

Obtuve estos detalles de esta publicación:

Agregar a la RUTA en Mac OS X 10.8 Mountain Lion y hasta

Creo que el OP está buscando una solución simple, similar a Windows.

Aqui tienes:

http://www.apple.com/downloads/macosx/system_disk_utilities/environmentvariablepreferencepane.html

Para ser conciso y claro sobre para qué está destinado cada archivo

• ~/.profile se obtiene cada vez que se lanza Terminal.app
• ~/.bashrc es donde "tradicionalmente" se establecen todas las declaraciones de exportación para el entorno Bash
• /etc/paths es el archivo principal en Mac OS que contiene la lista de rutas predeterminadas para construir la variable de entorno PATH para todos los usuarios
• /etc/paths.d/ contiene archivos que contienen rutas de búsqueda adicionales

¡Los programas no terminales no heredan las variables PATH y MANPATH de todo el sistema que sí hace su terminal! Para establecer el entorno para todos los procesos iniciados por un usuario específico, haciendo que las variables de entorno estén disponibles para las aplicaciones GUI de Mac OS X, esas variables deben definirse en su ~/.MacOSX/environment.plist(Preguntas y respuestas técnicas de Apple QA1067)

Use la siguiente línea de comando para sincronizar su environment.plistcon /etc/paths:

defaults write $HOME/.MacOSX/environment PATH "$(tr '\n' ':' </etc/paths)"

/etc/launchd.conf no se usa en OS X v10.10 (Yosemite), OS X v10.11 (El Capitan), macOS v10.12 (Sierra) o macOS v10.13 (High Sierra).

Desde la launchctlpágina del manual:

/etc/launchd.conf file is no longer consulted for subcommands to run during early boot time;
this functionality was removed for security considerations.

El método descrito en esta respuesta Preguntar diferente funciona para mí (después de un reinicio): las aplicaciones iniciadas desde el Dock o desde Spotlight heredan las variables de entorno que configuré ~/Library/LaunchAgents/my.startup.plist. (En mi caso, necesitaba configurar LANG, para en_US.UTF-8, un complemento de Sublime Text).

La $PATHvariable también está sujeta a path_helper, que a su vez hace uso del /etc/pathsarchivo y los archivos en /etc/paths.d.

Se puede encontrar una descripción más completa en PATH y otros problemas del entorno en Leopard (2008-11)

Es simple:

Edite ~ / .profile y coloque sus variables de la siguiente manera

$ vim ~ / .profile

En archivo puesto:

MY_ENV_VAR = valor

1. Guardar (: wq)

2. Reinicie el terminal (salga y ábralo de nuevo)

3. Asegúrese de que todo esté bien:

$ echo $ MY_ENV_VAR

valor de $

Para una modificación de un solo usuario, use ~/.profilelas que enumeró. El siguiente enlace explica cuándo Bash lee los diferentes archivos.

http://telin.ugent.be/~slippens/drupal/bashrc_and_others

Si desea establecer la variable de entorno para aplicaciones GUI, necesita el archivo ~ / .MacOSX / environment.plist

Bueno, no estoy seguro acerca de los archivos /etc/pathsy ~/.MacOSX/environment.plist. Esos son nuevos.

Pero con Bash, debe saber que .bashrcse ejecuta con cada nueva invocación de shell y .bash_profilesolo se ejecuta una vez al inicio.

No sé con qué frecuencia es esto con Mac OS X. Creo que la distinción se ha roto con el sistema de ventanas que inicia todo.

Personalmente, elimino la confusión creando un .bashrcarchivo con todo lo que necesito y luego hago:

ln -s .bashrc .bash_profile

Una cosa a tener en cuenta además de los enfoques sugeridos es que, al menos en OS X 10.5 (Leopard), las variables establecidas launchd.confse fusionarán con las configuraciones realizadas .profile. Supongo que es probable que esto también sea válido para la configuración ~/.MacOSX/environment.plist, pero no lo he verificado.

Configure su variable de entorno PATH en Mac OS

Abra el programa Terminal (está en su carpeta de Aplicaciones / Utilidades por defecto). Ejecute el siguiente comando

touch ~/.bash_profile; open ~/.bash_profile

Esto abrirá el archivo en su editor de texto predeterminado.

Para Android SDK como ejemplo:

Debe agregar la ruta al directorio de herramientas y herramientas de la plataforma del SDK de Android. En mi ejemplo, usaré "/ Development / android-sdk-macosx" como el directorio en el que está instalado el SDK. Agregue la siguiente línea:

export PATH=${PATH}:/Development/android-sdk-macosx/platform-tools:/Development/android-sdk-macosx/tools

Guarde el archivo y salga del editor de texto. Ejecute su .bash_profile para actualizar su RUTA:

source ~/.bash_profile

Ahora, cada vez que abra el programa Terminal, su RUTA incluirá el SDK de Android.

Acabo de hacer esto realmente fácil y rápido. Primero cree un ~ / .bash_profile desde la terminal:

touch .bash_profile

entonces

open -a TextEdit.app .bash_profile

añadir

export TOMCAT_HOME=/Library/Tomcat/Home

guarde el documento y ya está.

Es bastante simple. Edite el archivo .profile(vi, nano , Sublime Text u otro editor de texto). Puede encontrarlo en el ~/directorio (directorio de usuarios) y configurarlo así:

export MY_VAR=[your value here]

Ejemplo con Java en casa:

export JAVA_HOME=/Library/Java/JavaVirtualMachines/current

Guárdelo y regrese a la terminal.

Puedes recargarlo con:

source .profile

O cierre y abra la ventana de su terminal.

Hay dos tipos de proyectiles en juego aquí.

• Sin inicio de sesión: .bashrc se vuelve a cargar cada vez que inicia una nueva copia de Bash
• Inicio de sesión: el .profile se carga solo cuando inicia sesión o le dice explícitamente a Bash que lo cargue y lo use como un shell de inicio de sesión.

Es importante entender aquí que con Bash, el archivo .bashrces de sólo lectura por una concha que a la vez interactiva y no inicio de sesión, y usted encontrará que la gente a menudo se cargan .bashrcen .bash_profilesuperar esta limitación.

Ahora que tiene la comprensión básica, pasemos a cómo le aconsejaría que lo configure.

• .profile: crearlo no existente. Ponga su configuración de RUTA allí.
• .bashrc: crear si no existe. Ponga todos sus alias y métodos personalizados allí.
• .bash_profile: crear si no existe. Pon lo siguiente allí.

.bash_file:

#!/bin/bash
source ~/.profile # Get the PATH settings
source ~/.bashrc  # Get Aliases and Functions
#

Conchas de inicio de sesión

/etc/profile

El shell primero ejecuta los comandos en el archivo /etc/profile. Un usuario que trabaja con privilegios de root puede configurar este archivo para establecer las características predeterminadas de todo el sistema para los usuarios que ejecutan Bash.

.bash_profile
.bash_login
.profile

A continuación, las miradas de concha para ~/.bash_profile, ~/.bash_loginy ~/.profile(~ / es taquigrafía para su directorio personal), en ese orden, la ejecución de los comandos en el primero de estos archivos que encuentre. Puede poner comandos en uno de estos archivos para anular los valores predeterminados establecidos /etc/profile. Un shell que se ejecuta en una terminal virtual no ejecuta comandos en estos archivos.

.bash_logout

Cuando cierra sesión, bash ejecuta comandos en el ~/.bash_logoutarchivo. Este archivo a menudo contiene comandos que se limpian después de una sesión, como los que eliminan archivos temporales.

Conchas interactivas sin inicio de sesión

/etc/bashrc

Aunque no se llama directamente por bash, muchos ~/.bashrcarchivos llaman /etc/bashrc. Esta configuración permite a un usuario que trabaja con privilegios de root establecer características predeterminadas de todo el sistema para shells bash que no inician sesión.

.bashrc

Un shell interactivo sin inicio de sesión ejecuta comandos en el ~/.bashrcarchivo. Normalmente, un archivo de inicio para un shell de inicio de sesión, como por ejemplo .bash_profile, ejecuta este archivo, por lo que tanto los shells de inicio de sesión como los que no lo hacen ejecutan los comandos .bashrc.

Debido a que los comandos .bashrcpueden ejecutarse muchas veces y a que las subcapas heredan las variables exportadas, es una buena idea poner comandos en el .bash_profilearchivo que se agreguen a las variables existentes .

Toda la magia en iOS solo va con el uso sourcecon el archivo, donde exporta sus variables de entorno.

Por ejemplo:

Puede crear un archivo como este:

export bim=fooo
export bom=bar

Guarde este archivo como bimbom.envy haga source ./bimbom.ev. Voilá, tienes tus variables de entorno.

Compruébalos con:

echo $bim

Para Bash, intente agregar sus variables de entorno al archivo /etc/profilepara que estén disponibles para todos los usuarios. No es necesario reiniciar, simplemente inicie una nueva sesión de Terminal.