Jak wykryć system operacyjny ze skryptu Bash?

524

Chciałbym zachować kontrolę nad plikami .bashrci .bash_loginplikami, aby móc ich używać między wszystkimi komputerami, których używam. Problem polega na tym, że mam pewne aliasy specyficzne dla systemu operacyjnego, więc szukałem sposobu, aby ustalić, czy skrypt działa w systemie Mac OS X, Linux lub Cygwin .

Jaki jest właściwy sposób na wykrycie systemu operacyjnego w skrypcie Bash ?

Csexton
źródło
1
Czy zastanawiałeś się kiedyś nad udostępnieniem swoich konfiguracji? Chciałem uzyskać taką samą konfigurację :)
sorin
@sorin Wiem, że to stary komentarz, ale jeśli nadal jesteś ciekawy, buduję ProfileGem, który pozwala konfigurować wtykowe środowiska bash dla wszystkich twoich maszyn.
dimo414
1
@ dimo414 profilegem wydaje się być tutaj przeniesiony bitbucket.org/dimo414/profilegem . Jeśli chodzi o dzielenie się konfiguracjami bash w ogóle, wypróbuj niektóre z tych projektów dotfiles
mahemoff
1
@mahemoff dziękuję za zaktualizowany link, przepraszam, że nie mogę edytować komentarza. Czekam na opinie lub błędy, jeśli eksperymentujesz z ProfileGem!
dimo414,
Niestety BitBucket odrzuca obsługę Mercurial, więc muszę ponownie zaktualizować mój link :( github.com/dimo414/ProfileGem jest nowym domem.
dimo414

Odpowiedzi:

521

Myślę, że następujące powinny działać. Nie jestem jednak pewien win32.

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
źródło
7
W systemie Windows dostaniesz msysdla Git Bash / msysGit, a cygwindla Cygwin
friederbluemle
1
Ta odpowiedź, w tym sposób wykrywania w systemie Windows, jest dobra. Używam również Mingw32 i pojawia się jakomsys
d48
2
Ciekawe .. Mac OSX nadal dawałby „darwin”.
jonathanbell
6
Coś, co mnie potknęło, kiedy zastępujesz komentarz poleceniem - pamiętaj o tym, aby zakończyć na ;.
Vadim Peretokin
1
Gdy dodam polecenie typu source somefile ; , otrzymuję syntax error near unexpected token elif.
wiosłowa
291

W moim .bashrc używam następującego kodu:

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

Potem robię coś takiego:

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

Jest brzydka, ale działa. Możesz użyć casezamiast, ifjeśli wolisz.

Nicolas Martyanoff
źródło
6
Dlaczego ustawiasz platformę z unamestr, zamiast po prostu używać unamestr?
csexton
80
Nie używaj odwrotnych znaków, użyj nowszej, bardziej przejrzystej składni: „unamestr = $ (uname)”.
zrelaksuj się
14
W skrócie rzutki mogą przypominać sznurek.
Harrison Powers
29
@ david-winiecki Ponieważ jeśli potrzebujesz zagnieżdżać polecenia np. $ (polecenie-1 $ (polecenie-2))
Michael Barton
3
Czy nie byłoby o wiele lepiej: platform="$(uname | tr '[:upper:]' '[:lower:]')"a następnie zdecydowanie poradzić sobie w sprawie? Po prostu dziwne wydaje się kodowanie zależności od bardzo specyficznych danych wyjściowych.
Brandon Buck,
274

Strona podręcznika bash mówi, że zmienna OSTYPE przechowuje nazwę systemu operacyjnego:

OSTYPEAutomatycznie ustawiany na ciąg opisujący system operacyjny, w którym wykonywana jest bash. Wartość domyślna zależy od systemu.

Jest ustawiony linux-gnututaj.

Johannes Schaub - litb
źródło
5
$ OSTYPE to także „darwin9.0” na moim komputerze Mac (Leopard) i „cygwin” pod Cygwin.
dF.
5
$ OSTYPE to darwin10.0 na SnowLeopard. WTF z dołączoną wersją? Oznacza, że ​​proste zestawienie przypadków nie będzie działać.
mxcl
16
Usunięcie go nie jest wielkim problemem:os=${OSTYPE//[0-9.]/}
ABach
86
case $OSTYPE in darwin*) echo I am a Mac ;; esac
tripleee
36
@tripleee lub dla osób, które są bardziej wygodne ze składnią „if”:if [[ $OSTYPE == darwin* ]]; then echo I am a Mac;fi
Rican7
157

$OSTYPE

Możesz po prostu użyć wstępnie zdefiniowanej $OSTYPEzmiennej, np .:

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

Jednak nie jest rozpoznawany przez starsze powłoki (takie jak powłoka Bourne'a ).


uname

Inną metodą jest wykrywanie platformy na podstawie unamepolecenia.

Zobacz następujący skrypt (gotowy do włączenia w .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

Możesz znaleźć praktyczny przykład w moim.bashrc .


Oto podobna wersja używana w 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
źródło
1
W kontroli $ OSTYPE brakuje gałęzi dla cygwin, co wskazywałoby na maszynę z systemem Windows. Kontrola uname też nie działałaby poprawnie, na cygwin uname zwraca „CYGWIN_NT-10.0”, a na MinGW uname zwraca „MINGW64_NT-10.0”.
Matt Pennington,
1
alias ls = '/ bin / ls -G' jest w rzeczywistości bezpieczną opcją, w kontekście pedałów opartych na systemie operacyjnym patrz superuser.com/a/1299969/84662
Andrei Neculau
Sugeruję użycie uname, Oracle przełożyło konwencję i umieściło w niej ciąg darmowej wersji OSTYPE ==> solaris2.11. unamejest trochę czystszy i mniej pracy.
będzie
37

Wykrywanie systemu operacyjnego i typu procesora nie jest tak łatwe do przenoszenia . Mam shskrypt około 100 linii, który działa na bardzo szerokiej gamie platform Unix: każdy system, z którego korzystam od 1988 roku.

Kluczowymi elementami są

  • uname -pjest typem procesora, ale zwykle znajduje się unknownna nowoczesnych platformach Unix.

  • uname -m poda „nazwę sprzętu” na niektórych systemach uniksowych.

  • /bin/arch, jeśli istnieje, zwykle podaje typ procesora.

  • uname bez argumentów nazwa systemu operacyjnego.

W końcu będziesz musiał pomyśleć o różnicach między platformami i o tym, jak dobrze chcesz je tworzyć. Na przykład, żeby zachować rzeczy proste, traktuję i386przez i686każde „ Pentium*” i każdy „ AMD*Athlon*” wszystko jako x86.

Mój ~/.profileuruchamia skrypt podczas uruchamiania, który ustawia jedną zmienną na ciąg wskazujący kombinację procesora i systemu operacyjnego. Mam od platformy bin, man, lib, i includekatalogi, które uzyskać utworzone na podstawie tego. Następnie ustawiam zestaw zmiennych środowiskowych. Na przykład skrypt powłoki w celu przeformatowania poczty może wywoływać np. $LIB/mailfmtSpecyficzny dla platformy plik binarny wykonywalny.

Jeśli chcesz skracać rogi , uname -ma zwykły unamepoinformuje Cię, co chcesz wiedzieć na wielu platformach. Dodaj inne rzeczy, kiedy ich potrzebujesz. (I użyj case, nie zagnieżdżony if!)

Norman Ramsey
źródło
2
Według polecenia uname polecenie uname bez parametru jest równoznaczne z użyciem parametru „-s”: „-s Wyświetla nazwę systemu. Ta flaga jest domyślnie włączona.”. Mówiąc wprost, można użyć „uname -s” zamiast „uname”. (Opracowano nieco w odpowiedzi na „Pomoc wyjściową powłoki” )
Peter Mortensen,
Czy masz link do gitub git lub pastebin dzięki temu 100 skryptowi do niezawodnego wykrywania architektury systemu operacyjnego i procesora?
Andrew De Andrade,
4
@AndrewDeAndrade Wstydzę się ujawnić ten kod publicznie. pastebin.com/J66Lj6wf
Norman Ramsey
co powiesz na uname -s?
Alexander Mills,
35

Polecam użyć tego pełnego kodu bash

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

więcej przykładów tutaj: https://github.com/coto/server-easy-install/blob/master/lib/core.sh

Coto
źródło
1
Pominąłeś funkcję małych liter, zaktualizowałem dla ciebie twoją odpowiedź.
Robin Clowers
1
Kiedy wiesz, że jest to Linux, jeśli po prostu grzebiesz (nie próbujesz zautomatyzować dowiadywania się), wydaje się, że najłatwiejszym ruchem jest po prostu ls /etcposzukiwanie „bla-release” - cokolwiek to jest, to Linux OS - CentOS, Ubuntu itp.
Chris Moschini,
Edytowałem, ponieważ niektóre odniesienia do zmiennej OS zostały zapisane jako „{$ OS}”. Zmieniłem je na „$ {OS}”, to jest właściwy sposób, przetestowałem to
bazz
czy możesz dodać „echo $ {OS}” na samym końcu skryptu?
Oleg Kokorin
10

W bashu używaj $OSTYPEi $HOSTTYPE, jak udokumentowano; to jest to, co robie. Jeśli to nie wystarczy, a nawet unamelub uname -a(lub inne odpowiednie opcje) nie dają wystarczających informacji, zawsze jest skrypt config.guess z projektu GNU, stworzony specjalnie do tego celu.

Miś
źródło
10

Sugerowałbym unikanie niektórych z tych odpowiedzi. Nie zapominaj, że możesz wybrać inne formy porównywania ciągów, które wyczyściłyby większość wariantów lub oferował brzydki kod.

Jednym z takich rozwiązań byłoby proste sprawdzenie, takie jak:

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

Co ma tę dodatkową zaletę, że pasuje do dowolnej wersji Darwina, pomimo sufiksu wersji. Działa to również w przypadku każdej odmiany, Linuxjakiej można się spodziewać.

Możesz zobaczyć dodatkowe przykłady w moich plikach dot tutaj

Akiva
źródło
9

Spróbuj użyć „uname”. Na przykład w systemie Linux: „uname -a”.

Według strony podręcznika, uname jest zgodny z SVr4 i POSIX, więc powinien być dostępny również w Mac OS X i Cygwin , ale nie mogę tego potwierdzić.

BTW: $ OSTYPE jest również ustawione linux-gnututaj :)

Joao da Silva
źródło
Bez parametrów uname drukuje „Darwin” na Mac OS X (lampart). Z opcją -a wyświetla całą masę dodatkowych informacji (wersja jądra, architektura i coś innego, czego nie mogę odszyfrować). Nie mogę testować na cygwinie
David Rodríguez - dribeas,
8

Te cukry napisałem w moim .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" ]];
}

Więc mogę robić takie rzeczy jak:

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
źródło
BTW, te 9 linii działa na każdym Bashie działającym na większości czegokolwiek. Bez ostrzałów i działa z prawie każdym stylem osobistego .bashrc (duże zagnieżdżone drzewa if / case lub wiele losowych aliasów). IMO bije spodnie od każdej odpowiedzi powyżej.
kfix
Do tej pory najbliższy do ukończenia, obejmujący Cygwin i inne BSD (w zasadzie kompilacja popularnego * NIX)
HidekiAI
Wypełnij dla obszarów użytkowników, które są aktualne dzisiaj i działają w Bash. Użytkownicy AIX / HP-UX / IRIX / OpenVMS mogą się włączyć. Nowy podsystem Windows dla Linuxa uruchamia standardową instalację Ubuntu na amd64, więc powinien zwrócić wartość true zarówno dla if_nix gnu& if_os linux.
kfix
1
@kfix tak, zgadza się, podsystem win 10 bash generuje „linux-gnu” dla echo $OSTYPE. Aby wykryć konkretnie podsystem Win 10 Bash, jedynym rozwiązaniem, jakie znalazłem, było sprawdzenie „Microsoft” w/proc/sys/kernel/osrelease
Jpnh
7
uname

lub

uname -a

jeśli chcesz więcej informacji

Federico A. Ramponi
źródło
7

Napisałem osobistą bibliotekę Bash i platformę skryptową, która wykorzystuje GNU shtool do dość dokładnego wykrywania platformy.

GNU shtool to bardzo przenośny zestaw skryptów, który zawiera między innymi przydatne polecenie „platforma shtool”. Oto wynik:

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

na kilku różnych maszynach:

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)

Jak widać, daje to całkiem zadowalające wyniki. GNU shtool jest trochę wolny, więc właściwie przechowuję i aktualizuję identyfikację platformy w pliku w systemie, który wywołują moje skrypty. To moja platforma, więc działa dla mnie, ale twój przebieg może się różnić.

Teraz musisz znaleźć sposób na spakowanie shtoola za pomocą swoich skryptów, ale nie jest to trudne zadanie. Zawsze możesz również polegać na wyjściu uname.

EDYTOWAĆ:

Brakowało mi posta Teddy'ego o config.guess(jakoś). Są to bardzo podobne skrypty, ale nie takie same. Osobiście używam shtoola również do innych celów i działa całkiem dobrze dla mnie.

pistolety
źródło
7

Możesz użyć następujących opcji:

OS=$(uname -s)

wtedy możesz użyć zmiennej OS w swoim skrypcie.

Chetan kapoor
źródło
czy możesz wyjaśnić, czym uname -ssię różni uname?
Alexander Mills,
@AlexanderMills -s, --kernel-name wydrukuj nazwę jądra
Chetan kapoor
6

Poniżej znajduje się podejście do wykrywania systemu operacyjnego Linux opartego na Debian i RedHat przy użyciu / etc / lsb-release i / etc / os-release (w zależności od używanego smaku Linuksa) i podjęcie na jego podstawie prostej akcji.

#!/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

Przykład danych wyjściowych dla systemu 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
źródło
5

Powinno to być bezpieczne w użyciu na wszystkich dystrybucjach.

$ cat /etc/*release

To produkuje coś takiego.

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

Wyodrębnij / przypisz do zmiennych, jak chcesz

Uwaga: w niektórych konfiguracjach. Może to również powodować błędy, które możesz zignorować.

     cat: /etc/upstream-release: Is a directory
RJ
źródło
Uwaga: w CentOS daje to[user@host ~]$ cat /etc/*release CentOS release 6.4 (Final) CentOS release 6.4 (Final) CentOS release 6.4 (Final)
cfstras
Tak, dane wyjściowe, które opublikowałem, były przykładem z jednego z moich laptopów, a nie statycznych treści, które widać wszędzie.
RJ
Właśnie to dodałem, żeby nikt nie pomyślał, że wynik jest zawsze w tej samej formie :)
cfstras
1
+1 Korzystam z zestawu -e na początku skryptu ( dlatego to rozwiązanie nie działa doxer.org/linux-shell-centos-debian-ostype ). Inne rozwiązania nie są specjalnie CentOS. Ale znalazłem to odniesienie, które potwierdziło tę odpowiedź unix.stackexchange.com/a/92212
gihanchanuka
4
nie działa na komputerach Mac:cat: /etc/*release: No such file or directory
eridal
3

Spróbuj tego:

DISTRO=$(cat /etc/*-release | grep -w NAME | cut -d= -f2 | tr -d '"')
echo "Determined platform: $DISTRO"
Aleksander Niekrasow
źródło
Na MacOS dostajęcat: /etc/*-release: No such file or directory
csexton
@ csexton naprawdę, robię to samo: zsh: no matches found: /etc/*release- to będzie działać tylko w systemach Linux, jak sądzę ...
Alexander Nekrasov
Ta odpowiedź na pewno działa tylko w systemie Linux. Ale inne odpowiedzi potrafią wykryć Linuksa w przeciwieństwie do innych systemów. To podstawowe odkrycie wcale nie pomaga w odkryciu konkretnej dystrybucji Linuksa jest tak samo istotne jak rozróżnienie między FreeBSD a Darwinem.
Thomas Urban,
3

Możesz użyć następującej klauzuli if i rozwinąć ją w razie potrzeby:

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
źródło
2

Wypróbowałem powyższe komunikaty w kilku dystrybucjach Linuksa i znalazłem następujące, które działają najlepiej dla mnie. To krótka, zwięzła, dokładna odpowiedź na słowo, która działa również w Bash na Windowsie.

OS=$(cat /etc/*release | grep ^NAME | tr -d 'NAME="') #$ echo $OS # Ubuntu
inteligencja
źródło
2
Chociaż ten fragment kodu jest mile widziany i może stanowić pewną pomoc, zostałby znacznie ulepszony, gdyby zawierał wyjaśnienie, w jaki sposób i dlaczego rozwiązuje problem. Pamiętaj, że odpowiadasz na pytanie dla czytelników w przyszłości, nie tylko dla osoby zadającej teraz pytanie! Proszę edytować swoje odpowiedzi, aby dodać wyjaśnienie, i dać wskazówkę co zastosować ograniczenia i założenia.
Toby Speight
1
Wydaje się miły i zwięzły dla większości systemów Linux, ale niestety spowoduje to błąd w systemie macOS. Być może jest to bardziej „wykryj smak dystrybucji linuksa z Bash
csexton
1
@csexton OS=$( ([[ -f /etc/*release ]] && cat /etc/*release | grep ^NAME | tr -d 'NAME="') || echo "Unknown" )to zadziała bez zgłaszania błędów.
Kuzeko
Właściwie to jest właściwy sposóbOS=$( $(compgen -G "/etc/*release" > /dev/null) && cat /etc/*release | grep ^NAME | tr -d 'NAME="') || $( echo "${OSTYPE//[0-9.]/}")
Kuzeko
@ Kuuzeko Niestety, nadal mam błędy podczas uruchamiania tego w systemie macOS.
csexton
1

Staram się przechowywać pliki .bashrc i .bash_alias w udziale plików, do którego mają dostęp wszystkie platformy. Oto jak pokonałem problem w mojej .bash_alias:

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

I mam na przykład .bash_alias_Linux z:

alias ls='ls --color=auto'

W ten sposób oddzielam kod specyficzny dla platformy i przenośny, możesz zrobić to samo dla .bashrc

ericcurtin
źródło
1

Sprawdza to kilka knownplików w celu ustalenia, czy dystrybucją Linuksa jest Debian lub Ubunu, a następnie domyślnie jest to $OSTYPEzmienna.

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
źródło
-1

Wykonanie następujących czynności pomogło poprawnie wykonać sprawdzenie Ubuntu:

if [[ "$OSTYPE" =~ ^linux ]]; then
    sudo apt-get install <some-package>
fi
piaskowy człowiek
źródło
4
Co z innymi systemami Linux, które nie używają apt-get?
Wilf
ubuntu to dystrybucja, a nie klasa systemu operacyjnego.
fluktuacja