Comment détecter le système d'exploitation à partir d'un script Bash?

526

Je souhaite conserver mes fichiers .bashrcet .bash_loginsous contrôle de version afin de pouvoir les utiliser entre tous les ordinateurs que j'utilise. Le problème est que j'ai des alias spécifiques au système d'exploitation, donc je cherchais un moyen de déterminer si le script s'exécute sur Mac OS X, Linux ou Cygwin .

Quelle est la bonne façon de détecter le système d'exploitation dans un script Bash ?

csexton
la source
1
Avez-vous déjà envisagé de partager vos configurations? Je cherchais à obtenir le même type de configuration :)
sorin
@sorin Je sais que c'est un vieux commentaire, mais si vous êtes toujours curieux, j'ai construit ProfileGem qui vous permet de configurer des environnements bash enfichables pour toutes vos machines.
dimo414
1
@ dimo414 profilegem semble avoir été déplacé ici bitbucket.org/dimo414/profilegem . En ce qui concerne le partage des configurations bash en général, essayez certains de ces projets dotfiles
mahemoff
1
@mahemoff merci pour le lien mis à jour, désolé je ne peux pas modifier mon commentaire. J'accueillerais vos commentaires ou bugs si vous expérimentez avec ProfileGem!
dimo414
Hélas, BitBucket refuse le support Mercurial, je dois donc mettre à jour mon lien à nouveau :( github.com/dimo414/ProfileGem est la nouvelle maison.
dimo414

Réponses:

523

Je pense que ce qui suit devrait fonctionner. Je ne suis pas sûr win32cependant.

if [[ "$OSTYPE" == "linux-gnu"* ]]; then
        # ...
elif [[ "$OSTYPE" == "darwin"* ]]; then
        # Mac OSX
elif [[ "$OSTYPE" == "cygwin" ]]; then
        # POSIX compatibility layer and Linux environment emulation for Windows
elif [[ "$OSTYPE" == "msys" ]]; then
        # Lightweight shell and GNU utilities compiled for Windows (part of MinGW)
elif [[ "$OSTYPE" == "win32" ]]; then
        # I'm not sure this can happen.
elif [[ "$OSTYPE" == "freebsd"* ]]; then
        # ...
else
        # Unknown.
fi
Timmmm
la source
7
Sous Windows, vous obtiendrez msyspour Git Bash / msysGit et cygwinpour Cygwin
friederbluemle
1
Cette réponse, y compris comment détecter pour Windows, est bonne. J'utilise également Mingw32 et il apparaît commemsys
d48
2
Intéressant .. Mac OSX donnerait toujours 'darwin'.
jonathanbell
6
Quelque chose qui m'a fait trébucher lorsque vous remplacez le commentaire par une commande - assurez-vous de terminer avec ;.
Vadim Peretokin
1
Quand j'ajoute une commande comme source somefile ; , j'obtiens syntax error near unexpected token elif.
oarfish
292

Pour mon .bashrc, j'utilise le code suivant:

platform='unknown'
unamestr=`uname`
if [[ "$unamestr" == 'Linux' ]]; then
   platform='linux'
elif [[ "$unamestr" == 'FreeBSD' ]]; then
   platform='freebsd'
fi

Ensuite, je fais des choses comme:

if [[ $platform == 'linux' ]]; then
   alias ls='ls --color=auto'
elif [[ $platform == 'freebsd' ]]; then
   alias ls='ls -G'
fi

C'est moche, mais ça marche. Vous pouvez utiliser caseau lieu de ifsi vous préférez.

Nicolas Martyanoff
la source
6
Pourquoi définissez-vous la plate-forme à partir d'unamestr, au lieu d'utiliser simplement unamestr?
csexton
80
N'utilisez pas de backticks, utilisez la nouvelle syntaxe plus claire: "unamestr = $ (uname)".
détendre le
15
D'un coup d'œil, les contre-coups pourraient ressembler à une chaîne.
Harrison Powers
29
@ david-winiecki Parce que si vous avez besoin d'imbriquer des commandes, par exemple $ (command-1 $ (command-2))
Michael Barton
4
Ne serait-il pas préférable de le faire: platform="$(uname | tr '[:upper:]' '[:lower:]')"puis de le gérer définitivement dans une affaire? Il semble juste bizarre de coder en dur une dépendance à une sortie très spécifique.
Brandon Buck du
274

La page de manuel bash indique que la variable OSTYPE stocke le nom du système d'exploitation:

OSTYPEDéfini automatiquement sur une chaîne qui décrit le système d'exploitation sur lequel bash s'exécute. La valeur par défaut dépend du système.

C'est réglé linux-gnuici.

Johannes Schaub - litb
la source
5
De plus, $ OSTYPE est 'darwin9.0' sur mon mac (Leopard) et 'cygwin' sous Cygwin.
dF.
5
$ OSTYPE est darwin10.0 sur SnowLeopard. WTF avec la version ajoutée? Signifie qu'une simple déclaration de cas ne fonctionnera pas.
mxcl
16
Ce n'est pas si grave de le supprimer:os=${OSTYPE//[0-9.]/}
ABach
86
case $OSTYPE in darwin*) echo I am a Mac ;; esac
tripleee
36
@tripleee ou pour les personnes plus à l'aise avec la syntaxe "if":if [[ $OSTYPE == darwin* ]]; then echo I am a Mac;fi
Rican7
159

$OSTYPE

Vous pouvez simplement utiliser une $OSTYPEvariable prédéfinie , par exemple:

case "$OSTYPE" in
  solaris*) echo "SOLARIS" ;;
  darwin*)  echo "OSX" ;; 
  linux*)   echo "LINUX" ;;
  bsd*)     echo "BSD" ;;
  msys*)    echo "WINDOWS" ;;
  *)        echo "unknown: $OSTYPE" ;;
esac

Cependant, il n'est pas reconnu par les coquilles plus anciennes (comme la coquille Bourne ).


uname

Une autre méthode consiste à détecter la plateforme sur la base d'une unamecommande.

Voir le script suivant (prêt à être inclus dans .bashrc):

# Detect the platform (similar to $OSTYPE)
OS="`uname`"
case $OS in
  'Linux')
    OS='Linux'
    alias ls='ls --color=auto'
    ;;
  'FreeBSD')
    OS='FreeBSD'
    alias ls='ls -G'
    ;;
  'WindowsNT')
    OS='Windows'
    ;;
  'Darwin') 
    OS='Mac'
    ;;
  'SunOS')
    OS='Solaris'
    ;;
  'AIX') ;;
  *) ;;
esac

Vous pouvez trouver un exemple pratique dans mon.bashrc .


Voici une version similaire utilisée sur Travis CI :

case $(uname | tr '[:upper:]' '[:lower:]') in
  linux*)
    export TRAVIS_OS_NAME=linux
    ;;
  darwin*)
    export TRAVIS_OS_NAME=osx
    ;;
  msys*)
    export TRAVIS_OS_NAME=windows
    ;;
  *)
    export TRAVIS_OS_NAME=notset
    ;;
esac
kenorb
la source
1
Il manque dans la vérification $ OSTYPE une branche pour cygwin, ce qui indiquerait une machine Windows. La vérification uname ne fonctionnerait pas non plus correctement, sur cygwin uname renvoie "CYGWIN_NT-10.0" et sur MinGW uname renvoie "MINGW64_NT-10.0".
Matt Pennington
1
alias ls = '/ bin / ls -G' est en fait l'option sûre, dans le contexte des fags basés sur OS voir superuser.com/a/1299969/84662
Andrei Neculau
Je suggère d'utiliser uname, Oracle a glissé la convention et a mis une chaîne de version gratuite avec leur OSTYPE ==> solaris2.11. unameest un peu plus propre et moins de travail à faire.
sera
37

Détecter le système d'exploitation et le type de CPU n'est pas si facile à faire de manière portable . J'ai un shscript d'environ 100 lignes qui fonctionne sur une très grande variété de plates-formes Unix: tout système que j'utilise depuis 1988.

Les éléments clés sont

  • uname -pest de type processeur, mais se trouve généralement unknownsur les plateformes Unix modernes.

  • uname -m donnera le "nom du matériel de la machine" sur certains systèmes Unix.

  • /bin/arch, s'il existe, donnera généralement le type de processeur.

  • uname sans argument nommera le système d'exploitation.

Finalement, vous devrez penser aux distinctions entre les plates-formes et à quel point vous voulez les faire. Par exemple, juste pour garder les choses simples de, je traite à i386travers i686, tout « Pentium*» et tout « AMD*Athlon*» tout comme x86.

My ~/.profileexécute un script au démarrage qui définit une variable sur une chaîne indiquant la combinaison du processeur et du système d'exploitation. Je plate-forme spécifique bin, man, libet les includerépertoires qui se mettent en place sur cette base. Ensuite, j'ai défini une cargaison de variables d'environnement. Ainsi, par exemple, un script shell pour reformater le courrier peut appeler, par exemple, $LIB/mailfmtqui est un binaire exécutable spécifique à la plate-forme.

Si vous voulez couper les coins ronds , uname -mplain unamevous dira ce que vous voulez savoir sur de nombreuses plateformes. Ajoutez d'autres éléments lorsque vous en avez besoin. (Et utilisez case, pas imbriqué if!)

Norman Ramsey
la source
2
Selon la commande uname , uname sans paramètre équivaut à utiliser le paramètre "-s": "-s Affiche le nom du système. Cet indicateur est activé par défaut.". Pour être explicite, on pourrait utiliser "uname -s" au lieu de "uname". (Élaboré quelque peu dans une réponse à «Aide à la sortie du shell» )
Peter Mortensen
Avez-vous un lien vers un github git ou pastebin avec ce script 100 pour détecter de manière fiable l'architecture du système d'exploitation et du processeur?
Andrew De Andrade
4
@AndrewDeAndrade J'ai honte d'exposer ce code au public. pastebin.com/J66Lj6wf
Norman Ramsey
alors qu'en est-il uname -s?
Alexander Mills
35

Je recommande d'utiliser ce code bash complet

lowercase(){
    echo "$1" | sed "y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/"
}

OS=`lowercase \`uname\``
KERNEL=`uname -r`
MACH=`uname -m`

if [ "{$OS}" == "windowsnt" ]; then
    OS=windows
elif [ "{$OS}" == "darwin" ]; then
    OS=mac
else
    OS=`uname`
    if [ "${OS}" = "SunOS" ] ; then
        OS=Solaris
        ARCH=`uname -p`
        OSSTR="${OS} ${REV}(${ARCH} `uname -v`)"
    elif [ "${OS}" = "AIX" ] ; then
        OSSTR="${OS} `oslevel` (`oslevel -r`)"
    elif [ "${OS}" = "Linux" ] ; then
        if [ -f /etc/redhat-release ] ; then
            DistroBasedOn='RedHat'
            DIST=`cat /etc/redhat-release |sed s/\ release.*//`
            PSUEDONAME=`cat /etc/redhat-release | sed s/.*\(// | sed s/\)//`
            REV=`cat /etc/redhat-release | sed s/.*release\ // | sed s/\ .*//`
        elif [ -f /etc/SuSE-release ] ; then
            DistroBasedOn='SuSe'
            PSUEDONAME=`cat /etc/SuSE-release | tr "\n" ' '| sed s/VERSION.*//`
            REV=`cat /etc/SuSE-release | tr "\n" ' ' | sed s/.*=\ //`
        elif [ -f /etc/mandrake-release ] ; then
            DistroBasedOn='Mandrake'
            PSUEDONAME=`cat /etc/mandrake-release | sed s/.*\(// | sed s/\)//`
            REV=`cat /etc/mandrake-release | sed s/.*release\ // | sed s/\ .*//`
        elif [ -f /etc/debian_version ] ; then
            DistroBasedOn='Debian'
            DIST=`cat /etc/lsb-release | grep '^DISTRIB_ID' | awk -F=  '{ print $2 }'`
            PSUEDONAME=`cat /etc/lsb-release | grep '^DISTRIB_CODENAME' | awk -F=  '{ print $2 }'`
            REV=`cat /etc/lsb-release | grep '^DISTRIB_RELEASE' | awk -F=  '{ print $2 }'`
        fi
        if [ -f /etc/UnitedLinux-release ] ; then
            DIST="${DIST}[`cat /etc/UnitedLinux-release | tr "\n" ' ' | sed s/VERSION.*//`]"
        fi
        OS=`lowercase $OS`
        DistroBasedOn=`lowercase $DistroBasedOn`
        readonly OS
        readonly DIST
        readonly DistroBasedOn
        readonly PSUEDONAME
        readonly REV
        readonly KERNEL
        readonly MACH
    fi

fi

plus d'exemples d'exemples ici: https://github.com/coto/server-easy-install/blob/master/lib/core.sh

coto
la source
1
Vous avez omis la fonction minuscule, j'ai mis à jour votre réponse pour vous.
Robin Clowers
1
Une fois que vous savez que c'est Linux, si vous ne faites que fouiner (n'essayez pas d'automatiser la découverte), il semble que le plus simple est de ls /etcrechercher et de "blah-release" - quel que soit blah, c'est le système d'exploitation Linux - CentOS, Ubuntu , etc
Chris Moschini
1
J'ai édité parce que certaines des références à la variable OS étaient écrites comme "{$ OS}" Je les ai changées en "$ {OS}" c'est la bonne façon, je l'ai testé
bazz
envisageriez-vous d'ajouter "echo $ {OS}" à la toute fin du script?
Oleg Kokorin
10

En bash, utilisez $OSTYPEet $HOSTTYPE, comme documenté; c'est ce que je fais. Si cela ne suffit pas et si even unameou uname -a(ou d'autres options appropriées) ne donnent pas suffisamment d'informations, il y a toujours le script config.guess du projet GNU, conçu exactement à cet effet.

Teddy
la source
10

Je suggérerais d'éviter certaines de ces réponses. N'oubliez pas que vous pouvez choisir d'autres formes de comparaison de chaînes, ce qui éliminerait la plupart des variations ou du code laid offert.

Une telle solution serait une simple vérification, telle que:

if [[ "$OSTYPE" =~ ^darwin ]]; then

Ce qui a l'avantage supplémentaire de correspondre à n'importe quelle version de Darwin, malgré son suffixe de version. Cela fonctionne également pour toutes les variations que l' Linuxon peut attendre.

Vous pouvez voir quelques exemples supplémentaires dans mes fichiers dot ici

Akiva
la source
9

Essayez d'utiliser "uname". Par exemple, sous Linux: "uname -a".

Selon la page de manuel, uname est conforme à SVr4 et POSIX, donc il devrait être disponible sur Mac OS X et Cygwin aussi, mais je ne peux pas le confirmer.

BTW: $ OSTYPE est également défini linux-gnuici :)

Joao da Silva
la source
Sans paramètres, uname imprime «Darwin» sur Mac OS X (léopard). Avec -a, il affiche beaucoup d'informations supplémentaires (version du noyau, architecture et autre chose que je ne peux pas déchiffrer). Je ne peux pas tester sur cygwin
David Rodríguez - dribeas
8

J'ai écrit ces sucres dans mon .bashrc:

if_os () { [[ $OSTYPE == *$1* ]]; }
if_nix () { 
    case "$OSTYPE" in
        *linux*|*hurd*|*msys*|*cygwin*|*sua*|*interix*) sys="gnu";;
        *bsd*|*darwin*) sys="bsd";;
        *sunos*|*solaris*|*indiana*|*illumos*|*smartos*) sys="sun";;
    esac
    [[ "${sys}" == "$1" ]];
}

Je peux donc faire des trucs comme:

if_nix gnu && alias ls='ls --color=auto' && export LS_COLORS="..."
if_nix bsd && export CLICOLORS=on && export LSCOLORS="..."
if_os linux && alias psg="ps -FA | grep" #alternative to pgrep
if_nix bsd && alias psg="ps -alwx | grep -i" #alternative to pgrep
if_os darwin && alias finder="open -R"
kfix
la source
BTW, ces 9 lignes fonctionnent sur n'importe quel Bash fonctionnant sur presque tout. Aucun shellout et fonctionne avec presque tous les styles de .bashrc personnel (grands arbres if / case imbriqués ou beaucoup d'alias aléatoires). OMI, bat le pantalon de chaque réponse au-dessus.
kfix
Jusqu'à présent, le plus proche de terminer pour inclure Cygwin et d'autres BSD (essentiellement la compilation des populaires * NIX)
HidekiAI
Complet pour les zones d'utilisateurs pertinentes aujourd'hui et exécutant Bash. Les utilisateurs AIX / HP-UX / IRIX / OpenVMS peuvent sonner. Le nouveau sous-système Windows pour Linux exécute une installation amd64 Ubuntu standard, il devrait donc être vrai pour les deux if_nix gnu& if_os linux.
kfix
1
@kfix oui c'est vrai, le sous-système win 10 bash produit "linux-gnu" pour echo $OSTYPE. Pour détecter spécifiquement le sous-système win 10 bash, la seule solution que j'ai trouvée était de rechercher «Microsoft» dans/proc/sys/kernel/osrelease
Jpnh
7
uname

ou

uname -a

si vous voulez plus d'informations

Federico A. Ramponi
la source
7

J'ai écrit une bibliothèque Bash personnelle et un framework de script qui utilise GNU shtool pour effectuer une détection de plateforme plutôt précise.

GNU shtool est un ensemble de scripts très portable qui contient, entre autres choses utiles, la commande 'shtool platform'. Voici la sortie de:

shtool platform -v -F "%sc (%ac) %st (%at) %sp (%ap)"

sur quelques machines différentes:

Mac OS X Leopard: 
    4.4BSD/Mach3.0 (iX86) Apple Darwin 9.6.0 (i386) Apple Mac OS X 10.5.6 (iX86)

Ubuntu Jaunty server:
    LSB (iX86) GNU/Linux 2.9/2.6 (i686) Ubuntu 9.04 (iX86)

Debian Lenny:
    LSB (iX86) GNU/Linux 2.7/2.6 (i686) Debian GNU/Linux 5.0 (iX86)

Cela produit des résultats assez satisfaisants, comme vous pouvez le voir. GNU shtool est un peu lent, donc je stocke et mets à jour l'identification de la plateforme dans un fichier sur le système que mes scripts appellent. C'est mon cadre, donc cela fonctionne pour moi, mais votre kilométrage peut varier.

Maintenant, vous devrez trouver un moyen d'empaqueter shtool avec vos scripts, mais ce n'est pas un exercice difficile. Vous pouvez toujours vous rabattre sur la sortie sans nom.

ÉDITER:

J'ai raté le message de Teddy sur config.guess(en quelque sorte). Ce sont des scripts très similaires, mais pas les mêmes. Personnellement, j'utilise également shtool pour d'autres utilisations, et cela a très bien fonctionné pour moi.

pistolets
la source
7

Vous pouvez utiliser les éléments suivants:

OS=$(uname -s)

alors vous pouvez utiliser la variable OS dans votre script.

Chetan kapoor
la source
pouvez-vous expliquer en quoi uname -sest différent de uname?
Alexander Mills
@AlexanderMills -s, --kernel-name affiche le nom du noyau
Chetan kapoor
6

Ci-dessous, vous trouverez une approche pour détecter le système d'exploitation Linux basé sur Debian et RedHat en utilisant la version / etc / lsb et / etc / os-release (selon la version Linux que vous utilisez) et prendre une action simple en fonction de celle-ci.

#!/bin/bash
set -e

YUM_PACKAGE_NAME="python python-devl python-pip openssl-devel"
DEB_PACKAGE_NAME="python2.7 python-dev python-pip libssl-dev"

 if cat /etc/*release | grep ^NAME | grep CentOS; then
    echo "==============================================="
    echo "Installing packages $YUM_PACKAGE_NAME on CentOS"
    echo "==============================================="
    yum install -y $YUM_PACKAGE_NAME
 elif cat /etc/*release | grep ^NAME | grep Red; then
    echo "==============================================="
    echo "Installing packages $YUM_PACKAGE_NAME on RedHat"
    echo "==============================================="
    yum install -y $YUM_PACKAGE_NAME
 elif cat /etc/*release | grep ^NAME | grep Fedora; then
    echo "================================================"
    echo "Installing packages $YUM_PACKAGE_NAME on Fedorea"
    echo "================================================"
    yum install -y $YUM_PACKAGE_NAME
 elif cat /etc/*release | grep ^NAME | grep Ubuntu; then
    echo "==============================================="
    echo "Installing packages $DEB_PACKAGE_NAME on Ubuntu"
    echo "==============================================="
    apt-get update
    apt-get install -y $DEB_PACKAGE_NAME
 elif cat /etc/*release | grep ^NAME | grep Debian ; then
    echo "==============================================="
    echo "Installing packages $DEB_PACKAGE_NAME on Debian"
    echo "==============================================="
    apt-get update
    apt-get install -y $DEB_PACKAGE_NAME
 elif cat /etc/*release | grep ^NAME | grep Mint ; then
    echo "============================================="
    echo "Installing packages $DEB_PACKAGE_NAME on Mint"
    echo "============================================="
    apt-get update
    apt-get install -y $DEB_PACKAGE_NAME
 elif cat /etc/*release | grep ^NAME | grep Knoppix ; then
    echo "================================================="
    echo "Installing packages $DEB_PACKAGE_NAME on Kanoppix"
    echo "================================================="
    apt-get update
    apt-get install -y $DEB_PACKAGE_NAME
 else
    echo "OS NOT DETECTED, couldn't install package $PACKAGE"
    exit 1;
 fi

exit 0

Exemple de sortie pour Ubuntu Linux:

delivery@delivery-E5450$ sudo sh detect_os.sh
[sudo] password for delivery: 
NAME="Ubuntu"
===============================================
Installing packages python2.7 python-dev python-pip libssl-dev on Ubuntu
===============================================
Ign http://dl.google.com stable InRelease
Get:1 http://dl.google.com stable Release.gpg [916 B]                          
Get:2 http://dl.google.com stable Release [1.189 B] 
...            
Exequiel Barrirero
la source
5

Cela devrait être sûr à utiliser sur toutes les distributions.

$ cat /etc/*release

Cela produit quelque chose comme ça.

     DISTRIB_ID=LinuxMint
     DISTRIB_RELEASE=17
     DISTRIB_CODENAME=qiana
     DISTRIB_DESCRIPTION="Linux Mint 17 Qiana"
     NAME="Ubuntu"
     VERSION="14.04.1 LTS, Trusty Tahr"
     ID=ubuntu
     ID_LIKE=debian
     PRETTY_NAME="Ubuntu 14.04.1 LTS"
     VERSION_ID="14.04"
     HOME_URL="http://www.ubuntu.com/"
     SUPPORT_URL="http://help.ubuntu.com/"
     BUG_REPORT_URL="http://bugs.launchpad.net/ubuntu/"

Extraire / assigner aux variables comme vous le souhaitez

Remarque: sur certaines configurations. Cela peut également vous donner des erreurs que vous pouvez ignorer.

     cat: /etc/upstream-release: Is a directory
RJ
la source
Remarque: sur CentOS, cela donne[user@host ~]$ cat /etc/*release CentOS release 6.4 (Final) CentOS release 6.4 (Final) CentOS release 6.4 (Final)
cfstras
Oui, la sortie que j'ai publiée était un exemple, de l'un de mes ordinateurs portables, pas du contenu statique que vous voyez partout.
RJ
Je viens d'ajouter que personne ne penserait que le résultat est toujours sous la même forme :)
cfstras
1
+1 J'utilise set -e au début du script (Ainsi, cette solution ne fonctionne pas doxer.org/linux-shell-centos-debian-ostype ). Et d'autres solutions ne sont pas spécifiquement CentOS. Mais j'ai trouvé cette référence qui a prouvé cette réponse unix.stackexchange.com/a/92212
gihanchanuka
4
ne fonctionne pas pour Mac:cat: /etc/*release: No such file or directory
eridal
3

essaye ça:

DISTRO=$(cat /etc/*-release | grep -w NAME | cut -d= -f2 | tr -d '"')
echo "Determined platform: $DISTRO"
Alexander Nekrasov
la source
Sur macOS, je reçoiscat: /etc/*-release: No such file or directory
csexton
@csexton vraiment, j'obtiens la même chose: zsh: no matches found: /etc/*release- cela ne fonctionnera que pour les systèmes linux, je suppose ...
Alexander Nekrasov
Cette réponse ne fonctionne que pour Linux, bien sûr. Mais d'autres réponses sont capables de détecter Linux uniquement par opposition à d'autres systèmes. Cette découverte de base n'aide pas du tout à découvrir une distribution Linux particulière est tout aussi essentielle que la distinction entre FreeBSD et Darwin.
Thomas Urban
3

Vous pouvez utiliser la clause if suivante et la développer si nécessaire:

if [ "${OSTYPE//[0-9.]/}" == "darwin" ]
then
    aminute_ago="-v-1M"
elif  [ "${OSTYPE//[0-9.]/}" == "linux-gnu" ]
then
    aminute_ago="-d \"1 minute ago\""
fi
Tahsin Turkoz
la source
2

J'ai essayé les messages ci-dessus sur quelques distributions Linux et j'ai trouvé que ce qui suit fonctionnait le mieux pour moi. C'est une réponse exacte et concise qui fonctionne également pour Bash sous Windows.

OS=$(cat /etc/*release | grep ^NAME | tr -d 'NAME="') #$ echo $OS # Ubuntu
intellilogic
la source
2
Bien que cet extrait de code soit le bienvenu et puisse fournir de l'aide, il serait grandement amélioré s'il incluait une explication sur la manière et la raison pour laquelle cela résout le problème. N'oubliez pas que vous répondrez à la question des lecteurs à l'avenir, pas seulement à la personne qui vous pose la question maintenant! Veuillez modifier votre réponse pour ajouter des explications et donner une indication des limitations et hypothèses applicables.
Toby Speight
1
Semble agréable et concis pour la plupart des systèmes Linux, mais malheureusement, cela entraînera une erreur sur macOS. Peut-être que c'est plus "détecter la saveur de distribution linux de Bash
csexton
1
@csexton OS=$( ([[ -f /etc/*release ]] && cat /etc/*release | grep ^NAME | tr -d 'NAME="') || echo "Unknown" )cela fonctionnera sans lancer d'erreurs.
Kuzeko
En fait, voici une bonne façonOS=$( $(compgen -G "/etc/*release" > /dev/null) && cat /etc/*release | grep ^NAME | tr -d 'NAME="') || $( echo "${OSTYPE//[0-9.]/}")
Kuzeko
@Kuzeko Malheureusement, je reçois toujours des erreurs en exécutant cela sur macOS.
csexton
1

J'ai tendance à conserver mes .bashrc et .bash_alias sur un partage de fichiers auquel toutes les plateformes peuvent accéder. Voici comment je vaincre le problème dans mon .bash_alias:

if [[ -f (name of share)/.bash_alias_$(uname) ]]; then
    . (name of share)/.bash_alias_$(uname)
fi

Et j'ai par exemple un .bash_alias_Linux avec:

alias ls='ls --color=auto'

De cette façon, je garde le code spécifique à la plate-forme et le code portable séparés, vous pouvez faire de même pour .bashrc

ericcurtin
la source
1

Cela vérifie un tas de knownfichiers pour identifier si la distribution linux est Debian ou Ubunu, puis elle est par défaut la $OSTYPEvariable.

os='Uknown'
unamestr="${OSTYPE//[0-9.]/}"
os=$( compgen -G "/etc/*release" > /dev/null  && cat /etc/*release | grep ^NAME | tr -d 'NAME="'  ||  echo "$unamestr")

echo "$os"
Kuzeko
la source
-1

Les opérations suivantes ont aidé à effectuer correctement la vérification d'ubuntu:

if [[ "$OSTYPE" =~ ^linux ]]; then
    sudo apt-get install <some-package>
fi
marchand de sable
la source
4
Qu'en est-il des autres systèmes Linux qui n'utilisent pas apt-get?
Wilf
ubuntu est une distribution, pas une classe de système d'exploitation.
gigue le