déterminer le shell dans le script lors de l'exécution

Selon ma connaissance, pour déterminer le shell actuel que nous utilisons echo $0dans le shell. Je veux plutôt que mon script vérifie dans quel shell il s'exécute. J'ai donc essayé d'imprimer $0dans le script et il renvoie le nom du script comme il se doit. Donc, ma question est de savoir comment trouver dans quel shell mon script s'exécute pendant l'exécution?

Sur Linux, vous pouvez utiliser /proc/PID/exe.

Exemple:

# readlink /proc/$$/exe
/bin/zsh

Peut-être pas ce que vous demandez, mais cela devrait fonctionner dans une certaine mesure pour identifier l'interprète qui l'interprète actuellement pour quelques-uns comme Thompson (osh), Bourne, Bourne-again (bash), Korn (ksh88, ksh93, pdksh, mksh ), zsh, Ordinaire conforme à la politique (chic), Yet Another (yash), rc, akanga, es shells, wish, tclsh, expect, perl, python, ruby, php, JavaScript (nodejs, SpiderMonkey shell and JSPL at least) , MS / Wine cmd.exe, command.com (MSDOS, FreeDOS ...).

'echo' +"'[{<?php echo chr(13)?>php <?php echo PHP_VERSION.chr(10);exit;?>}\
@GOTO DOS [exit[set 1 [[set 2 package] names];set 3 Tcl\ [info patchlevel];\
if {[lsearch -exact $1 Expect]>=0} {puts expect\ [$2 require Expect]\ ($3)} \
elseif {[lsearch -exact $1 Tk]>=0} {puts wish\ ($3,\ Tk\ [$2 require Tk])} \
else {puts $3}]]]' >/dev/null ' {\">/dev/null \
">"/dev/null" +"\'";q="#{",1//2,"}";a=+1;q='''=.q,';q=%{\"
'echo' /*>/dev/null
echo ">/dev/null;status=0;@ {status=1};*=(" '$' ");~ $status 1&&{e='"\
"';eval catch $2 ^'&version {eval ''echo <='^ $2 ^'&version''}';exit};e='"\
"';if (eval '{let ''a^~a''} >[2] /dev/null'){e='"\
"';exec echo akanga};eval exec echo rc $2 ^ version;\" > /dev/null
: #;echo possibly pre-Bourne UNIX V1-6 shell;exit
if (! $?version) set version=csh;exec echo $version
:DOS
@CLS
@IF NOT "%DOSEMU_VERSION%"=="" ECHO DOSEMU %DOSEMU_VERSION%
@ECHO %OS% %COMSPEC%
@VER
@GOTO FIN
", unless eval 'printf "perl %vd\n",$^V;exit;'> "/dev/null";eval ': "\'';
=S"';f=false e=exec\ echo n=/dev/null v=SH_VERSION;`(eval "f() { echo :
};f")2>$n` $f||$e Bourne-like shell without function
case `(: ${_z_?1}) 2>&1` in 1) $e ash/BSD sh;;esac;t(){
eval "\${$1$v+:} $f &&exec echo ${2}sh \$$1$v";};t BA ba;t Z z;t PO po;t YA ya
case `(typeset -Z2 b=0;$e $b)2>$n` in 00) (eval ':${.}')2>$n&&eval '
$e ksh93 ${.sh.version}';t K pdk;$e ksh88;;esac;case `(eval '$e ${f#*s}$($e 1
)$((1+1))')2>$n` in e12)$e POSIX shell;;esac;$e Bourne-like shell;: }
print "ruby ",RUBY_VERSION,"\n";exit;' ''';import sys
print("python "+sys.version);z='''*/;
s="";j="JavaScript";if(typeof process=="object"){p=console.log;p(process.title
,process.version)}else{p=print;p((f="function")==(t=typeof version)?"string"==
typeof(v=version())?v:(typeof build!=f?"":s= "SpiderMonkey ")+j+" "+v:(t==
"undefined"?j+"?":version)+"\n");if(s)build()}/*
:FIN } *///'''

J'ai posté la version initiale de ce script which_interpreter vers 2004 sur usenet. Sven Mascheck a un script (probablement plus utile pour vous) appelé Whatshell qui se concentre sur l'identification des obus de type Bourne. Vous pouvez également trouver une version fusionnée de nos deux scripts là .

C'est ce que j'utilise dans mon .profile pour vérifier les différents shells sur les systèmes sur lesquels je travaille. Il ne fait pas de fines distinctions entre ksh88 et ksh93, mais il ne m'a jamais fait défaut.

Notez qu'il ne nécessite pas une seule fourche ou tuyau.

# Determine what (Bourne compatible) shell we are running under. Put the result
# in $PROFILE_SHELL (not $SHELL) so further code can depend on the shell type.

if test -n "$ZSH_VERSION"; then
  PROFILE_SHELL=zsh
elif test -n "$BASH_VERSION"; then
  PROFILE_SHELL=bash
elif test -n "$KSH_VERSION"; then
  PROFILE_SHELL=ksh
elif test -n "$FCEDIT"; then
  PROFILE_SHELL=ksh
elif test -n "$PS3"; then
  PROFILE_SHELL=unknown
else
  PROFILE_SHELL=sh
fi

Tu pourrais essayer

ps -o args= -p "$$"

qui vous donnera le nom de la commande associée au pid du script.

Si la lsofcommande est disponible sur votre système, vous pouvez obtenir le chemin complet de l'exécutable du shell parent en obtenant le PID parent via pset en analysant la sortie de lsof -p $ppid(voir Comment déterminer le shell actuel sur lequel je travaille? ).

#!/bin/sh
ppid="`ps -p "$$" -o ppid=`"
lsof -nP -p "$ppid" | awk 'NR==3 {print $NF; exit}'

En dehors de la terre Linux ou n'ayant pas accès au système de fichiers / proc ou équivalent, vous pouvez utiliser pstree:

En supposant que vous ayez le pid de

Sur un Mac:

./test.sh 
16012
-+= 00001 root /sbin/launchd
 \-+= 00245 wingwong /sbin/launchd
   \-+= 04670 wingwong /Applications/Utilities/Terminal.app/Contents/MacOS/Terminal -psn_0_2052597
     \-+= 11816 root login -pf wingwong
       \-+= 11817 wingwong -bash
         \-+= 16012 wingwong ksh ./test.sh
           \-+- 16013 wingwong pstree -p 16012

Sur une box Linux:

./test.sh 
14981
bash(14981)---pstree(14982)

Le format et le style de la sortie de pstree diffèrent selon votre environnement, mais vous pouvez appliquer la sortie ASCII puis sed / tr / awk / etc. filtrez la sortie pour obtenir le shell qui exécute le script.

Donc, une version de sortie nettoyée (fonctionne pour les exécutions Mac ou Linux OS):

#!/usr/bin/env sh
pstree  -p $$  | tr ' ()' '\012\012\012' | grep -i "sh$" | grep -v "$0" | tail -1

Rendements à la volée:

./test.sh 
sh

Et lorsqu'il est exécuté avec un autre shell:

#!/usr/bin/env ksh
pstree  -p $$  | tr ' ()' '\012\012\012' | grep -i "sh$" | grep -v "$0" | tail -1

Rendements:

./test.sh 
ksh

Aucun système de fichiers racine ou spécial requis. Remarque, mon filtrage suppose que le nom binaire du shell se termine par sh et qu'il n'y a pas d'entrées intermédiaires se terminant par sh. Suppose également que vous n'avez pas nommé votre script "sh" ou un motif de grep malheureux qui effacera les informations. :) Il faudra une certaine personnalisation pour votre propre environnement afin d'assurer un degré plus élevé de résistance à toute épreuve.

Vous pouvez utiliser la commande:

$ echo $SHELL

pour découvrir le shell à partir du script.