Réponses:
Habituellement, uname
avec 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 -s
donne Darwin
pour OSX et Linux
pour Linux, tandis que mon Cygwin donne CYGWIN_NT-5.1
. Mais vous devrez peut-être expérimenter toutes sortes de versions différentes.
Le bash
code 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 bash
shell de celui-ci) donc les chemins doivent déjà être correctement configurés. Comme le note un commentateur, vous pouvez exécuter le bash
programme, en passant le script, à partir de cmd
lui-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
).
MINGW32_NT-6.1
. De plus, il n'y a pas de /cygdrive
préfixe, juste /c
pour C:
.
How can a shell/bash script detect ...
et que l'autre le fait.
uname -s
finit par appeler tout ce qui uname
est le premier dans votre chemin actuel, qui sur mon système s'avère être la version installée avec geda
laquelle retourne le texte WindowsNT
. Il pourrait également s'agir de la version MinGW comme décrit ci-dessus. Une détection fiable de cygwin ne doit pas reposer sur le chemin défini de manière appropriée, l'OMI. Par conséquent, $(uname -s)
doit être modifié $(/bin/uname -s)
pour détecter cygwin.
#!/usr/bin/env bash
au lieu de #!/bin/sh
pour éviter le problème causé par un /bin/sh
shell 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).expr
programme à moins que vous ne l'installiez, donc je viens de l'utiliser uname
.uname
pour obtenir les informations système ( -s
paramètre).expr
et substr
pour gérer la chaîne.if
elif
fi
pour faire le travail correspondant.uname -s
spécifications.#!/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
[ "$(expr substr $(uname -s) 1 10)" == "MINGW32_NT" ]
.
"$(expr substr $(uname -s) 1 5)"
est un peu bizarre. Il y a des façons plus jolies de le faire, par exemple: if [ `uname -s` == CYGWIN* ]; then
. Lisez-le: si uname -s
commence avec CYGWIN alors ...
if [[ $(uname -s) == CYGWIN* ]]; then
uname -s
qui produiront autre chose que "Linux"?
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 uname
sans 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 Makefile
est 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 -s
etMakefile
.
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
~/.profile
(pour définir des variables d'environnement comme $PATH
- commenter pour fournir des mots clés de recherche pour la postérité).
uname -sr
et de comparer Linux*Microsoft)
avant Linux*)
.
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 uname
au 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-gnu
cygwin
msys
(Veuillez ajouter votre valeur si elle diffère des entrées existantes)
env | grep OSTYPE
, mais vous le verrez sousset | grep OSTYPE
OSTYPE
variable de Bash (conftypes.h) est configurée au moment de la construction en utilisant la copie exacte de la OS
variable d' automake (Makefile.in) . On peut consulter le fichier lib / config.sub d'automake pour tous les types disponibles.
Pour tirer parti de la réponse d'Albert, j'aime utiliser $COMSPEC
pour 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 $OS
et d'analyser les variantes de uname
MINGW, 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é
if [ `uname -s` == CYGWIN* ]; then
semble mieux et fonctionne de la même manière.
[[ $(uname -s) == CYGWIN* ]]
. Notez également que les expressions régulières étendues sont plus précises dans notre cas: [[ $(uname -s) =~ ^CYGWIN* ]]
.
expr substr $(uname -s) 1 6
donne une erreur ( expr: syntax error
) sur macOS.
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 -s
pour interroger le nom du système.
Darwin
CYGWIN_...
LINUX
pour la plupartLe 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"