J'ai un script shell qui est utilisé à la fois sur Windows / Cygwin et Mac et Linux. Il a besoin de variables légèrement différentes pour chaque version.

Comment un script shell / bash peut-il détecter s'il s'exécute dans Cygwin, sur un Mac ou sous Linux?

Habituellement, unameavec ses différentes options vous dira dans quel environnement vous exécutez:

pax> uname -a
CYGWIN_NT-5.1 IBM-L3F3936 1.5.25(0.156/4/2) 2008-06-12 19:34 i686 Cygwin

pax> uname -s
CYGWIN_NT-5.1

Et, selon le très utile schot(dans les commentaires), uname -sdonne Darwinpour OSX et Linuxpour Linux, tandis que mon Cygwin donne CYGWIN_NT-5.1. Mais vous devrez peut-être expérimenter toutes sortes de versions différentes.

Le bashcode pour effectuer une telle vérification serait donc le suivant:

unameOut="$(uname -s)"
case "${unameOut}" in
    Linux*)     machine=Linux;;
    Darwin*)    machine=Mac;;
    CYGWIN*)    machine=Cygwin;;
    MINGW*)     machine=MinGw;;
    *)          machine="UNKNOWN:${unameOut}"
esac
echo ${machine}

Notez que je suppose ici que vous exécutez réellement dans CygWin (le bashshell de celui-ci) donc les chemins doivent déjà être correctement configurés. Comme le note un commentateur, vous pouvez exécuter le bashprogramme, en passant le script, à partir de cmdlui-même et cela peut entraîner que les chemins ne soient pas configurés comme requis.

Si vous êtes en train de faire cela, il est de votre responsabilité d'assurer les executables correctes (c. -à- celles Cygwin) sont appelés, éventuellement en modifiant le chemin au préalable ou en spécifiant bien les lieux exécutables (par exemple /c/cygwin/bin/uname).

Voici le script bash que j'ai utilisé pour détecter trois types d'OS différents (GNU / Linux, Mac OS X, Windows NT)

Faites attention

• Dans votre script bash, utilisez #!/usr/bin/env bashau lieu de #!/bin/shpour éviter le problème causé par un /bin/shshell différent par défaut sur différentes plates-formes, ou il y aura une erreur comme un opérateur inattendu , c'est ce qui s'est produit sur mon ordinateur (Ubuntu 64 bits 12.04).
• Mac OS X 10.6.8 (Snow Leopard) n'a pas de exprprogramme à moins que vous ne l'installiez, donc je viens de l'utiliser uname.

Conception

1. Utilisez unamepour obtenir les informations système ( -sparamètre).
2. Utilisez expret substrpour gérer la chaîne.
3. Utilisez if elif fipour faire le travail correspondant.
4. Vous pouvez ajouter plus de support système si vous le souhaitez, suivez simplement les uname -sspécifications.

la mise en oeuvre

#!/usr/bin/env bash

if [ "$(uname)" == "Darwin" ]; then
    # Do something under Mac OS X platform        
elif [ "$(expr substr $(uname -s) 1 5)" == "Linux" ]; then
    # Do something under GNU/Linux platform
elif [ "$(expr substr $(uname -s) 1 10)" == "MINGW32_NT" ]; then
    # Do something under 32 bits Windows NT platform
elif [ "$(expr substr $(uname -s) 1 10)" == "MINGW64_NT" ]; then
    # Do something under 64 bits Windows NT platform
fi

Essai

• Linux (Ubuntu 12.04 LTS, Kernel 3.2.0) testé OK.
• OS X (10.6.8 Snow Leopard) testé OK.
• Windows (Windows 7 64 bits) testé OK.

Ce que j'ai appris

1. Vérifiez les guillemets d'ouverture et de fermeture.
2. Recherchez les parenthèses et les accolades manquants {}

Références

• [1] uname - wikipedia
• [2] Erreur de syntaxe du script shell: fin de fichier inattendue
• [3] Détecter le système d'exploitation à partir d'un script Bash
• [4] BASH Programming Introduction HOW-TO

Utilisez uname -s( --kernel-name) car uname -o( --operating-system) n'est pas pris en charge sur certains systèmes d'exploitation tels que Mac OS et Solaris . Vous pouvez également utiliser juste unamesans aucun argument puisque l'argument par défaut est -s( --kernel-name).

L'extrait ci-dessous ne nécessite pas frapper(c.-à-d. ne nécessite pas #!/bin/bash)

#!/bin/sh

case "$(uname -s)" in

   Darwin)
     echo 'Mac OS X'
     ;;

   Linux)
     echo 'Linux'
     ;;

   CYGWIN*|MINGW32*|MSYS*|MINGW*)
     echo 'MS Windows'
     ;;

   # Add here more strings to compare
   # See correspondence table at the bottom of this answer

   *)
     echo 'Other OS' 
     ;;
esac

Ce qui suit Makefileest inspiré du projet Git ( config.mak.uname) .

ifdef MSVC     # Avoid the MingW/Cygwin sections
    uname_S := Windows
else                          # If uname not available => 'not' 
    uname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not')
endif

# Avoid nesting "if .. else if .. else .. endif endif"
# because maintenance of matching if/else/endif is a pain

ifeq ($(uname_S),Windows)
    CC := cl 
endif
ifeq ($(uname_S),OSF1)
    CFLAGS += -D_OSF_SOURCE
endif
ifeq ($(uname_S),Linux)
    CFLAGS += -DNDEBUG
endif
ifeq ($(uname_S),GNU/kFreeBSD)
    CFLAGS += -D_BSD_ALLOC
endif
ifeq ($(uname_S),UnixWare)
    CFLAGS += -Wextra
endif
...

Voir aussi cette réponse complète sur uname -setMakefile .

Le tableau de correspondance au bas de cette réponse provient d'un articleuname de Wikipédia sur . Merci de contribuer à le maintenir à jour (modifiez la réponse ou postez un commentaire). Vous pouvez également mettre à jour l'article Wikipedia et poster un commentaire pour m'informer de votre contribution ;-)

Operating System uname -s
Mac OS X Darwin
Cygwin 32-bit (Win-XP) CYGWIN_NT-5.1
Cygwin 32-bit (Win-7 32-bit)CYGWIN_NT-6.1
Cygwin 32-bit (Win-7 64-bit)CYGWIN_NT-6.1-WOW64
Cygwin 64-bit (Win-7 64-bit)CYGWIN_NT-6.1
MinGW (Windows 7 32-bit) MINGW32_NT-6.1
MinGW (Windows 10 64-bit) MINGW64_NT-10.0
Interix (Services for UNIX) Interix
MSYS MSYS_NT-6.1
MSYS2 MSYS_NT-10.0-17763
Windows Subsystem for Linux Linux
Android Linux
coreutils Linux
CentOS Linux
Fedora Linux
Gentoo Linux
Red Hat Linux Linux
Linux Mint Linux
openSUSE Linux
Ubuntu Linux
Unity Linux Linux
Manjaro Linux Linux
OpenWRT r40420 Linux
Debian (Linux) Linux
Debian (GNU Hurd) GNU
Debian (kFreeBSD) GNU/kFreeBSD
FreeBSD FreeBSD
NetBSD NetBSD
DragonFlyBSD DragonFly
Haiku Haiku
NonStop NONSTOP_KERNEL
QNX QNX
ReliantUNIX ReliantUNIX-Y
SINIX SINIX-Y
Tru64 OSF1
Ultrix ULTRIX
IRIX 32 bits IRIX
IRIX 64 bits IRIX64
MINIX Minix
Solaris SunOS
UWIN (64-bit Windows 7) UWIN-W7
SYS$UNIX:SH on OpenVMS IS/WB
z/OS USS OS/390
Cray sn5176
(SCO) OpenServer SCO_SV
(SCO) System V SCO_SV
(SCO) UnixWare UnixWare
IBM AIX AIX
IBM i with QSH OS400
HP-UX HP-UX

Bash définit la variable shell OSTYPE. De man bash:

Défini automatiquement sur une chaîne qui décrit le système d'exploitation sur lequel bash s'exécute.

Cela a un petit avantage par rapport unameau fait qu'il ne nécessite pas de lancer un nouveau processus, il sera donc plus rapide à exécuter.

Cependant, je ne parviens pas à trouver une liste faisant autorité des valeurs attendues. Pour moi sur Ubuntu 14.04, il est réglé sur 'linux-gnu'. J'ai gratté le Web pour d'autres valeurs. Par conséquent:

case "$OSTYPE" in
  linux*)   echo "Linux / WSL" ;;
  darwin*)  echo "Mac OS" ;; 
  win*)     echo "Windows" ;;
  msys*)    echo "MSYS / MinGW / Git Bash" ;;
  cygwin*)  echo "Cygwin" ;;
  bsd*)     echo "BSD" ;;
  solaris*) echo "Solaris" ;;
  *)        echo "unknown: $OSTYPE" ;;
esac

Les astérisques sont importants dans certains cas - par exemple OSX ajoute un numéro de version du système d'exploitation après le «darwin». La valeur «win» est en fait «win32», me dit-on - peut-être y a-t-il un «win64»?

Peut-être pourrions-nous travailler ensemble pour remplir un tableau de valeurs vérifiées ici:

• Linux Ubuntu (y compris WSL ):linux-gnu
• Cygwin 64 bits: cygwin
• Msys / MINGW (Git Bash pour Windows): msys

(Veuillez ajouter votre valeur si elle diffère des entrées existantes)

Pour tirer parti de la réponse d'Albert, j'aime utiliser $COMSPECpour détecter Windows:

#!/bin/bash

if [ "$(uname)" == "Darwin" ]
then
 echo Do something under Mac OS X platform
elif [ "$(expr substr $(uname -s) 1 5)" == "Linux" ]
then
  echo Do something under Linux platform
elif [ -n "$COMSPEC" -a -x "$COMSPEC" ]
then 
  echo $0: this script does not support Windows \:\(
fi

Cela évite d'analyser les variantes des noms Windows $OSet d'analyser les variantes de unameMINGW, Cygwin, etc.

Contexte: %COMSPEC%est une variable d'environnement Windows spécifiant le chemin d'accès complet au processeur de commandes (alias le shell Windows). La valeur de cette variable est généralement %SystemRoot%\system32\cmd.exe, ce qui correspond généralement à C:\Windows\system32\cmd.exe.

# This script fragment emits Cygwin rulez under bash/cygwin
if [[ $(uname -s) == CYGWIN* ]];then
    echo Cygwin rulez
else 
    echo Unix is king
fi

Si les 6 premiers caractères de la commande uname -s sont "CYGWIN", un système cygwin est supposé

Ok, voici mon chemin.

osis()
{
    local n=0
    if [[ "$1" = "-n" ]]; then n=1;shift; fi

    # echo $OS|grep $1 -i >/dev/null
    uname -s |grep -i "$1" >/dev/null

    return $(( $n ^ $? ))
}

par exemple

osis Darwin &&
{
    log_debug Detect mac osx
}
osis Linux &&
{
    log_debug Detect linux
}
osis -n Cygwin &&
{
    log_debug Not Cygwin
}

J'utilise ceci dans mes fichiers dot

http://en.wikipedia.org/wiki/Uname

Toutes les informations dont vous aurez besoin. Google est ton ami.

Utilisez uname -spour interroger le nom du système.

• Mac: Darwin
• Cygwin: CYGWIN_...
• Linux: divers, LINUXpour la plupart

Le sous-système Windows pour Linux n'existait pas lorsque cette question a été posée. Il a donné ces résultats dans mon test:

uname -s -> Linux
uname -o -> GNU/Linux
uname -r -> 4.4.0-17763-Microsoft

Cela signifie que vous avez besoin d'uname -r pour le distinguer de Linux natif.

Je suppose que la réponse unique est imbattable, principalement en termes de propreté.

Bien que cela prenne un temps ridicule à exécuter, j'ai trouvé que le test de présence de fichiers spécifiques me donne également de bons et plus rapides résultats, car je n'invoque pas d'exécutable:

Alors,

[ -f /usr/bin/cygwin1.dll ] && echo Yep, Cygwin running

utilise simplement une vérification rapide de la présence du fichier Bash. Comme je suis sous Windows en ce moment, je ne peux pas vous dire de fichiers spécifiques pour Linux et Mac OS X de ma tête, mais je suis presque sûr qu'ils existent. :-)

Utiliser uniquement cela depuis la ligne de commande fonctionne très bien, grâce à Justin:

#!/bin/bash

################################################## #########
# Bash script to find which OS
################################################## #########

OS=`uname`
echo "$OS"

la source