Bruno est sur la bonne voie. J'ai fait des recherches approfondies et si vous voulez définir des variables qui sont disponibles dans toutes les applications GUI, votre seule option est /etc/launchd.conf .

veuillez noter que environnement.plist ne fonctionne pas pour les applications lancées via Spotlight. Ceci est documenté par Steve Sexton ici .

1. ouvrir un prompt terminal

2. Type sudo vi /etc/launchd.conf (note: Ce fichier pourrait ne pas encore exister)

3. mettez du contenu comme celui-ci dans le fichier

   # 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 /q/setting-environment-variables-on-os-x-70489/"-Xmx1024M -XX:MaxPermSize=512m"
   setenv M2_HOME /Applications/Dev/apache-maven
   
   setenv JMETER_HOME /Applications/Dev/jakarta-jmeter
   

4. Enregistrez vos modifications dans vi et redémarrez votre Mac. Ou utilisez le grep / xargs commande qui est montrée dans le commentaire de code ci-dessus.

5. prouver que vos variables travaillent en ouvrant une fenêtre de Terminal et en tapant export et vous devriez voir vos nouvelles variables. Ceux-ci seront également disponibles dans IntelliJ IDEA et d'autres applications GUI que vous lancez via Spotlight.

Comment définir l'environnement pour de nouveaux processus a commencé par Spotlight (sans avoir besoin de redémarrer)

vous pouvez définir l'environnement utilisé par launchd (et, par extension, Tout ce qui a commencé depuis Spotlight) avec launchctl setenv . Par exemple pour définir le chemin:

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

Ou si vous souhaitez configurer votre chemin dans .bashrc ou similaire, puis de miroir dans launchd:

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

il n'y a pas besoin de redémarrer bien que vous aurez besoin de redémarrer une application si vous le souhaitez pour ramasser l'environnement a changé.

y compris les réservoirs déjà sous Terminal.app, bien que si vous êtes là vous pouvez définir l'environnement plus directement, par exemple avec export PATH=/opt/local/bin:/opt/local/sbin:$PATH pour bash ou zsh.

comment conserver les changements après un redémarrage

À conserver les modifications après un redémarrage , vous pouvez régler la variables d'environnement de /etc/launchd.conf , comme ainsi:

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

launchd.conf est exécuté automatiquement lorsque vous redémarrez.

si vous voulez que ces changements entrent en vigueur maintenant, vous devriez utiliser cette commande pour retraiter launchctl.conf (merci @mklement pour le Conseil!)

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

vous pouvez en savoir plus sur launchctl et comment il charge launchd.conf avec la commande man launchctl .

Jusqu'à et y compris OS X v10.7 (Lion) vous pouvez les définir dans:

~/.MacOSX/environment.plist

voir:

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

pour le chemin dans le Terminal, vous devriez être en mesure de définir dans .bash_profile ou .profile (vous devrez probablement le créer cependant)

pour OS X v10.8 (Lion de montagne) et au-delà vous devez utiliser launchd et launchctl .

Solution pour la ligne de commande et les applications GUI à partir d'une seule source (fonctionne avec Yosemite & El Capitan)

supposons que vous ayez des définitions de variables d'environnement dans votre ~/.bash_profile comme dans l'extrait suivant:

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"

nous avons besoin d'un agent de lancement qui s'exécute à chaque connexion et à tout moment sur demande qui va charger ces variables à la session de l'utilisateur. Nous aurons aussi besoin d'un script shell pour analyser ces définitions et construisent les commandes nécessaires à être exécutées par l'agent.

créer un fichier avec le suffixe plist (p.ex. nommé osx-env-sync.plist ) dans le répertoire ~/Library/LaunchAgents/ avec le contenu suivant:

<?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>

-l paramètre est critique ici; il est nécessaire pour exécuter le script shell avec un shell de connexion de sorte que ~/.bash_profile est d'abord d'origine avant que ce script soit exécuté.

maintenant, le script shell. Créer à ~/.osx-env-sync.sh avec le contenu suivant:

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

assurez-vous que le script shell est exécutable:

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

maintenant, chargez l'agent de lancement pour la session en cours:

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

(Re)lancer une application GUI et vérifier qu'il peut lire les variables d'environnement.

la configuration est persistante. Il survivra redémarrages et relogines.

après la configuration initiale (que vous venez de faire), si vous voulez refléter des changements dans votre ~/.bash_profile à votre environnement entier à nouveau, la rediffusion de la commande launchctl load ... ne fonctionnera pas ce que vous voulez; au lieu de cela, vous recevrez un avertissement comme le suivant:

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

afin de recharger vos variables d'environnement sans passer par le processus de déconnexion

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

Enfin assurez-vous que vous relancez vos applications déjà en cours d'exécution (y compris le Terminal.app) pour les sensibiliser aux changements.

j'ai aussi poussé le code et les explications ici à un projet GitHub: osx-env-sync .

j'espère que ce sera la solution ultime, au moins pour les dernières versions D'OS X (Yosemite & El Capitan).

1.

vim ~/.bash_profile

Le fichier n'existe pas (si pas, vous pouvez le créer).

2.tapez ceci et sauvegardez le fichier:

export PATH=$PATH:YOUR_PATH_HERE

3.run

source ~/.bash_profile

il y a essentiellement deux problèmes à résoudre variables d'environnement dans OS X. La première est lors de l'invocation de programmes de Spotlight (l'icône de la loupe sur le côté droit du Mac menu / barre d'état) et la seconde lorsque vous invoquez des programmes depuis le quai. Invoquer des programmes à partir d'une application/utilitaire de Terminal est trivial car il lit l'environnement du shell standard emplacements ( ~/.profile , ~/.bash_profile , ~/.bashrc , etc.)

Lorsque vous invoquez des programmes à partir du Quai, utilisez ~/.MacOSX/environment.plist lorsque l'élément <dict> contient une séquence de <key>KEY</key><string>theValue</string> éléments.

lorsque vous invoquez des programmes de Spotlight, assurez-vous que launchd a été setup avec tous les paramètres de clé / valeur dont vous avez besoin.

pour résoudre les deux problèmes simultanément, j'utilise un élément de connexion (défini par le Outil de préférences de système) sur mon compte D'utilisateur. L'élément login est un script bash qui invoque une fonction lisp D'Emacs même si on peut bien sûr utiliser leurs favori outil de script pour accomplir la même chose. Cette approche a l'avantage supplémentaire qu'il fonctionne à tout moment et ne nécessite pas redémarrer, c'est-à-dire qu'on peut éditer ~/.profile , exécuter l'élément de connexion dans un shell et avoir les changements visibles pour les programmes nouvellement invoqués, soit à partir du Dock ou de Spotlight.

détails:

Login: ~/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"

Emacs lisp de la fonction: ~/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)))

NOTE: Cette solution est un amalgame de ceux qui sont venus avant que j'ai ajouté le mien, en particulier celui offert par Matt Curtis, mais j'ai délibérément essayé de garder mon ~/.bash_profile plate-forme de contenu indépendant et mettre le réglage de l'environnement launchd (une installation Mac seulement) dans un script séparé.

un Autre, gratuit, opensource, Mac OSX Mountain Lion (10.8) dans les Préférences/environnement.la solution plist est EnvPane .

EnvPane code source disponible sur Github . EnvPane semble avoir des fonctionnalités comparables à Rcenvironnement , cependant, il semble qu'il peut mettre à jour ses variables stockées instantanément, i.e. sans la nécessité d'un redémarrage ou de connexion, qui est la bienvenue.

comme indiqué par le développeur:

EnvPane est un panneau de préférence Pour Mac OS X 10.8 (Lion de montagne) que vous permet de définir des variables d'environnement pour tous les programmes dans les deux graphiques et des séances terminales. Non seulement il rétablir le soutien pour ~ / .MacOSX / environment.plist dans Mountain Lion, il publie aussi votre les changements de l'environnement immédiatement, sans avoir besoin de se déconnecter et à l'arrière.

< SNIP>

EnvPane inclut (et installe automatiquement) un launchd agent qui s'exécute 1) tôt après la connexion et 2) chaque fois que le ~ / .MacOSX / environment.plist changements. L'agent de lit ~ / .MacOSX / environment.plist et des exportations, les variables d'environnement de ce fichier vers l'instance launchd de l'utilisateur courant via la même API que est utilisé par launchctl setenv et launchctl unsetenv.

Avertissement: je ne suis en aucune manière lié au promoteur ou à son projet.

P. S. j'aime le nom de la (des sons comme "Fin de la Douleur").

sur Mountain Lion tous les /etc/paths et /etc/launchd.conf édition ne prend pas tout effet!

forums de développeur D'Apple disent:

"Modifier les informations.plist de l' .application elle - même pour contenir un "environnement"" dictionnaire avec les variables d'environnement que vous souhaitez.

~/.MacOSX / environment.plist n'est plus supporté."

donc j'ai directement édité les applications Info.plist (clic droit sur " AppName.app "(dans ce cas SourceTree) et puis " Show package contents ")

et a ajouté une nouvelle paire clé/dict appelée:

<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>

(voir: LaunchServicesKeys de la Documentation d'Apple )

maintenant L'application (dans mon cas SourceTree) utilise le chemin donné et fonctionne avec git 1.9.3: -)

PS: bien sûr, vous devez ajuster l'entrée du chemin à vos besoins spécifiques.

alors que les réponses ici ne sont pas" fausses", j'en ajouterai une autre: ne jamais faire de changements de variables d'environnement dans OS X qui affectent" tous les processus", ou même, en dehors de l'interpréteur de commandes, pour tous les processus exécutés interactivement par un utilisateur donné.

d'après mon expérience, les changements globaux aux variables d'environnement comme PATH pour tous les processus sont encore plus susceptibles de casser des choses sur OS X que sur Windows. La raison étant, beaucoup D'applications OS X et d'autres logiciels (y compris, peut-être en particulier, les composants de L'OS lui-même) s'appuient sur les outils de ligne de commande UNIX sous le capot, et assument le comportement des versions de ces outils fournis avec le système, et n'utilisent pas nécessairement des chemins absolus lorsqu'ils le font (des commentaires similaires s'appliquent aux bibliothèques chargées dynamiquement et aux variables d'environnement DYLD_*). Considérons, par exemple, que les réponses les mieux notées aux différentes questions sur le remplacement des versions fournies par OS X d'interprètes comme Python et Ruby disent généralement "ne faites pas ce."

OS X n'est pas vraiment différent des autres systèmes D'exploitation de type UNIX (par exemple Linux, FreeBSD, et Solaris) à cet égard; la raison la plus probable pour laquelle Apple ne fournit pas un moyen facile de le faire est parce qu'il casse les choses . Dans la mesure où Windows N'est pas aussi enclin à ces problèmes, c'est dû à deux choses: (1) Windows software n'a pas tendance à compter sur les outils de ligne de commande dans la mesure où UNIX software fait, et (2) Microsoft a eu un tel une longue histoire de "L'enfer de la DLL" et des problèmes de sécurité causés par des changements qui affectent tous les processus qu'ils ont changé le comportement de chargement dynamique dans les nouvelles versions de Windows pour limiter l'impact des options de configuration "globale" comme le chemin.

"boiteux" ou non, vous aurez un système beaucoup plus stable si vous limitez ces changements à des portées plus petites.

parfois, toutes les réponses précédentes ne fonctionnent tout simplement pas. Si vous voulez avoir accès à une variable système (comme M2_HOME ) dans Eclipse ou dans IntelliJ idée la seule chose qui fonctionne pour moi dans ce cas est:

tout d'abord (étape 1) éditer /etc/launchd.conf pour contenir une ligne comme ceci:" valeur var de setenv " puis (Étape 2) redémarrer.

modification simple .bash_profile ne fonctionnera pas car dans OS X les applications ne sont pas lancées comme dans les autres Unix'es; ils n'héritent pas des variables shell du parent. Toutes les autres modifications ne fonctionne pas pour une raison qui m'est inconnue. Peut-être que quelqu'un d'autre peut clarifier à ce sujet.

après avoir chassé le Variables d'environnement de préférence pane et découvrir que le lien est cassé et une recherche sur le site D'Apple semble indiquer qu'ils ont oublié à ce sujet... J'ai repris la piste de l'insaisissable processus de launchd.

sur mon système (Mac OS X 10.6.8) il apparaît que les variables définies dans l'environnement.plist sont être exportés de manière fiable à des applications lancées à partir de Spotlight (via launchd). Mon le problème est que ces vars ne sont pas exportés vers de nouvelles sessions bash dans le Terminal. C'est-à-dire: J'ai le problème opposé tel qu'il est décrit ici.

NOTE: environnement.plist ressemble à JSON, pas XML, comme décrit précédemment

j'ai pu obtenir des applications de Spotlight pour voir les vars par édition ~/MacOSX/environnement.plist et " J'ai pu forcer le même vars dans une nouvelle session de Terminal en ajoutant le suivant à mon .fichier de profil:

eval $(launchctl export)

mise à jour (2017-08-04)

à partir de (au moins) macOS 10.12.6 (Sierra) cette méthode semble avoir cessé de fonctionner pour Apache httpd (pour L'option system et user de launchctl config ). Les autres programmes ne semblent pas être touchés. Il est concevable qu'il s'agisse d'un bug dans httpd.

réponse originale

cela concerne OS X 10.10+ (10.11+ spécifiquement en raison du mode sans route où /usr/bin n'est pas plus accessible en écriture).

j'ai lu à plusieurs endroits que l'utilisation de launchctl setenv PATH <new path> pour définir la variable PATH ne fonctionne pas en raison d'un bug dans OS X (ce qui semble vrai d'après l'expérience personnelle). J'ai trouvé qu'il y a une autre façon de définir PATH pour applications non lancées à partir du shell :

sudo launchctl config user path <new path>

cette option est documentée dans la page de manuel de launchctl:

config système | utilisateur valeur de paramètre

définit les informations de configuration persistantes pour les domaines launchd(8). Seuls le domaine système et le domaine utilisateur peuvent être configurés. L'emplacement du stockage persistant est un les détails de la mise en œuvre et les modifications à ce stockage ne devraient être effectués que par le biais de cette sous-commande. Un redémarrage est nécessaire pour que les changements apportés par cette sous-commande prennent effet.

[...]

chemin

définit la variable D'environnement PATH pour tous les services dans le domaine cible à la valeur de chaîne. La valeur de la chaîne doit être conforme au format décrit pour Variable PATH environment dans environ (7). Notez que si un service spécifie son propre chemin, la variable d'environnement propre au service aura priorité.

NOTE: Ce facilité ne peut pas être utilisé pour définir des variables d'environnement générales pour tous les services dans le domaine. Il est intentionnellement scopé à l'environnement PATH vari- pouvoir et rien d'autre pour des raisons de sécurité.

j'ai confirmé ceci pour travailler avec une application GUI à partir de Finder (qui utilise getenv pour obtenir le chemin). Notez que vous n'avez qu'à le faire une fois et le changement sera persistante grâce à un redémarrage.

L'un des fichiers de démarrage de Bash-- ~/.bashrc , ~/.bash_profile , ~/.profile . Il y a aussi une sorte de fichier bizarre appelé ~/.MacOSX/environment.plist pour les variables d'environnement dans les applications GUI.

un peu comme la réponse de Matt Curtis, j'ai défini des variables d'environnement via launchctl, mais je l'enroule dans une fonction appelée export, de sorte que chaque fois que j'exporte une variable comme normal dans my .bash_profile, il est aussi défini par launchctl. Voici ce que je fais:

1. Mon .bash_profile se compose uniquement d'une ligne, (C'est juste une préférence personnelle.)

   source .bashrc
   

2. My .bashrc a ceci:

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

3. ci-dessus entraîne une surcharge du Bash builtin "exportation" et exportation de tout ce qui est normalement (vous remarquerez que je l'exportation "exporter"!), puis les configurer correctement pour les environnements D'application OS X via launchctl, que vous utilisiez l'un des éléments suivants:

   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 cette façon, je n'ai pas à envoyer toutes les variables à launchctl à chaque fois, et je peux juste avoir mon .bash_profile/.bashrc configuré de la façon que je veux. Ouvrir une fenêtre de terminal, vérifiez vos variables d'environnement qui vous intéressent avec launchctl getenv myVar , changez quelque chose dans votre .bash_profile/.bashrc, fermez la fenêtre du terminal et ré-ouvrez-la, vérifiez la variable à nouveau avec launchctl, et voilà, c'est changé.

5. encore une fois, comme les autres solutions pour le monde post-montagne Lion, pour toute nouvelle variable d'environnement pour être disponible pour les applications, vous devez les lancer ou les relancer après le changement.

Voici une façon très simple de faire ce que vous voulez. Dans mon cas, il obtenait gradle pour travailler (pour Android Studio )

• Ouvrez Terminal.

• exécuter la commande suivante:

  sudo nano /etc/paths ou sudo vim /etc/paths

• entrez votre mot de passe, lorsqu'on vous le demande.

• aller au bas du fichier, et entrer le chemin que vous souhaitez ajouter.
• appuie sur Contrôle-x pour arrêter.
• entrez " Y " pour enregistrer le buffer modifié.

• ouvrez une nouvelle fenêtre de terminal, puis tapez:

  echo $PATH

vous devriez voir le nouveau chemin annexé à la fin du chemin

j'ai obtenu ces détails de ce post:

http://architectryan.com/2012/10/02/add-to-the-path-on-mac-os-x-mountain-lion/#.UkED3rxPp3Q

j'espère que peut aider quelqu'un d'autre

je pense que L'OP est à la recherche d'une solution simple, semblable à Windows.

Ici, vous allez:

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

pour être concis et clair sur ce que chaque fichier est destiné à

• ~/.profile est fourni chaque fois Terminal.lancement de l'application
• ~/.bashrc est où "traditionnellement" toutes les déclarations d'exportation pour L'environnement Bash sont fixées
• /etc/paths est le fichier principal dans Mac OS qui contient la liste des chemins par défaut pour la construction de la variable D'environnement PATH pour tous les utilisateurs
• /etc/paths.d/ contient des fichiers qui contiennent des chemins de recherche supplémentaires

les programmes Non-terminaux n'héritent pas des variables de chemin et de MANPATH que votre terminal fait! Pour configurer l'environnement pour tous les processus lancés par un utilisateur spécifique, rendant ainsi les variables d'environnement disponibles pour les applications GUI Mac OS X, ces variables doivent être définies dans votre ~/.MacOSX/environment.plist (Q&A technique Apple QA1067)

utilisez la ligne de commande suivante pour synchronisez votre environment.plist avec /etc/paths :

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

la variable $PATH est également sujette à path_helper , qui à son tour utilise le fichier /etc/paths et les fichiers dans /etc/paths.d .

une description plus détaillée peut être trouvée ici: http://hea-www.harvard.edu/~fine/OSX/path_helper.html

configurer votre variable D'environnement PATH sur Mac OS

ouvrez le programme du Terminal (c'est dans votre dossier Applications/Utilites par défaut). Exécutez la commande suivante toucher./~ bash_profile; ouvrir ~/.bash_profile Ceci ouvrira le fichier dans l'éditeur de texte par défaut.

pour ANDROID SDK comme exemple:

vous devez ajouter le chemin d'accès à votre plateforme SDK Android-répertoire d'outils et d'outils. Dans mon exemple j'utiliserai "/ Development / android-sdk-macosx" comme répertoire dans lequel le SDK est installé. Ajouter la ligne suivante:

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

Enregistrez le fichier et quittez l'éditeur de texte. Exécuter votre .bash_profile pour mettre à jour votre chemin.

source ~/.bash_profile

maintenant chaque fois que vous ouvrez le programme de Terminal Vous chemin sera inclus le SDK Android.

c'est simple:

Edit ~/.profil et mettez vos variables comme suit

$ vim ~/.profil

dans file put:

MY_ENV_VAR=value

1. Enregistrer ( :wq )

2. redémarrer le terminal (arrêter et l'ouvrir à nouveau)

3. assurez-vous que tout soit parfait:

$ echo $MY_ENV_VAR

$ valeur

pour une modification d'utilisateur unique, utilisez ~/.profile de ceux que vous avez énumérés. Le lien suivant explique quand les différents fichiers sont lus par Bash.

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

si vous voulez définir la variable d'environnement pour les applications gui vous avez besoin du ~/.MacOSX / environment.fichier plist

il y a deux types de coquillages en jeu ici.

• Non-Login: .bashrc est rechargé chaque fois que vous commencez une nouvelle copie de bash
• Login: The .profile est chargé uniquement lorsque vous vous connectez, ou dites explicitement à bash de le charger et de l'utiliser comme shell de connexion.

il est important de comprendre ici qu'avec bash .bashrc est seulement lu par un shell qui est à la fois interactif et non-login, et vous trouverez que les gens chargent souvent .bashrc .bash_profile pour surmonter cette limitation.

maintenant que vous avez la compréhension de base, passons à la façon dont je vous conseillerais de la mettre en place.

• .profil: créer de la non-existant. Mettez votre CHEMIN d'installation.
• .bashrc: créer de la non-existant. Mettez tous vos Alias et méthode Personnalisée.
• .bash_profile: créer s'il n'existe pas. Mettez ce qui suit dans y.

.bash_file:

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

Shells De Login

/etc/profile

le shell exécute d'abord les commandes dans /etc/profile. Un utilisateur travaillant avec les privilèges root peut configurer ce fichier pour établir les caractéristiques par défaut du système pour les utilisateurs qui exécutent bash.

.bash_profile 
.bash_login 
.profile

ensuite, le shell cherche~/.bash_profile,~/.bash_login, et ~/.profil (~/est un raccourci pour votre répertoire personnel), dans cet ordre, exécutant les commandes dans le premier de ces les fichiers qu'il trouve. Vous pouvez placer des commandes dans l'un de ces fichiers pour outrepasser les valeurs par défaut définies dans /etc/profile. Un shell tournant sur un terminal virtuel n'exécute pas de commandes dans ces fichiers.

.bash_logout

Lorsque vous vous déconnectez, bash exécute les commandes dans le ~/.bash_logout fichier. Ce fichier contient souvent des commandes qui nettoient après une session, comme celles qui suppriment les fichiers temporaires.

Interactive Nonlogin Shells

/etc/bashrc

bien que non appelé directement par bash, beaucoup ~/.bashrc fichiers appel /etc/bashrc. Cette configuration permet à un utilisateur travaillant avec les privilèges root d'établir les caractéristiques par défaut du système pour les shells bash Non login.

.bashrc

un shell non-login interactif exécute des commandes dans le ~/.dossier bashrc. Typiquement un fichier de démarrage pour un shell de login, tel que .bash_profile, exécute ce fichier, donc les shells login et non-login exécutent les commandes .bashrc.

parce que les commandes sont .bashrc peut être exécuté plusieurs fois, et parce que les subshells héritent des variables exportées, c'est une bonne idée de mettre des commandes qui ajoutent aux variables existantes dans le .bash_profile fichier.

/etc / launchd.conf n'est pas utilisé dans Yosemite, El Capitain, ou (High) Sierra

De la launchctl l'homme page:

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

la méthode décrite dans ce Demander une réponse différente fonctionne pour moi (après un redémarrage): les applications lancées à partir du quai ou de Spotlight héritent des variables d'environnement que j'ai mis dans ~/Library/LaunchAgents/my.startup.plist . (Dans mon cas, je devais mettre LANG , à en_US.UTF-8 , pour un texte Sublime plugin.)

Je ne suis pas sûr des fichiers /etc/paths et ~/.MacOSX/environment.plist . Ceux-ci sont nouveaux.

mais avec Bash, vous devez savoir que .bashrc est exécuté avec chaque nouvelle invocation de shell et .bash_profile n'est exécuté qu'une fois au démarrage.

Je ne sais pas combien de fois C'est avec Mac OS X. Je pense que la distinction s'est effondrée avec le système de fenêtres de lancement de tout.

personnellement, j'élimine la confusion par créer un fichier .bashrc avec tout ce dont j'ai besoin et ensuite faire:

ln -s .bashrc .bash_profile

une chose à noter en plus des approches suggérées est que, dans OS X 10.5 (Leopard) au moins, les variables définies dans launchd.conf seront fusionnées avec les paramètres établis dans .profile . Je suppose que cela est probablement valable pour les paramètres de ~/.MacOSX/environment.plist aussi, mais je n'ai pas vérifié.

pour Bash, essayez d'ajouter vos variables d'environnement au fichier /etc/profile pour les rendre disponibles pour tous les utilisateurs. Pas besoin de redémarrer, il suffit de démarrer une nouvelle session de Terminal.

c'est assez simple, edit .profil (vi, nano, sublimeText ou autre éditeur de texte) fichier, vous pouvez le trouver à ~ / directory (user directory) et mis comme ceci:

export MY_VAR=[your value here]

exemple avec java home:

export JAVA_HOME=/Library/Java/JavaVirtualMachines/current

enregistrez - le et retournez au terminal.

vous pouvez le recharger avec:

source .profile ou fermez / ouvrez la fenêtre de votre terminal.

vient de faire ça très facilement et rapidement. Créez d'abord un ~/.bash_profile dans le terminal:

touch .bash_profile

puis

open -a TextEdit.app .bash_profile

ajouter

export TOMCAT_HOME=/Library/Tomcat/Home

enregistrer documement et vous avez terminé.