How to test what shell I am using in a terminal?

Question

How to check what shell I am using in a terminal? What is the shell I am using in MacOS?

Answer 1

Several ways, from most to least reliable (and most-to-least "heavy"):

1. ps -p$$ -ocmd=. (On Solaris, this may need to be fname instead of cmd. On OSX and on BSD should be command instead of cmd.)
2. Check for $BASH_VERSION, $ZSH_VERSION, and other shell-specific variables.
3. Check $SHELL; this is a last resort, as it specifies your default shell and not necessarily the current shell.

Answer 2

I've found that the following works in the four shells I have installed on my system (bash, dash, zsh, csh):

$ ps -p $$

The following works on zsh, bash, and dash, but not on csh:

$ echo $0

Answer 3

As the question asks for the shell used and does not talk about the potential arguments passed to it, here is a way that avoid showing them:

$ ps -o comm= -p $$
ksh93 

Answer 4

A note about some lighter implementations (Android phones, busybox, etc.): ps doesn't always have support for the -p switch, but you can accomplish the search with a command like ps | grep "^$$ ". (This grep regex will uniquely identify the PID, so there will not be any false positives.

Answer 5

A mix of all the other answers, compatible with Mac (comm), Solaris (fname) and Linux (cmd):

ps -p$$ -o cmd="",comm="",fname="" 2>/dev/null | sed 's/^-//' | grep -oE '\w+' | head -n1

Answer 6

The pid of the running shell is given by the var $$ (in most shells).

whichsh="`ps -o pid,args| awk '$1=='"$$"'{print $2}'`"
echo "$whichsh"

Using backticks to make jsh (Heirlomm shell) work.

In many shells the direct test of ps -o args= -p $$ works, but busybox ash fails on that (solved).

The check that $1 must be equal to $$ removes most false positives.

The last ;: are used to keep the shell running for ksh and zsh.

Tests on more systems will help, please make a comment if it doesn't work for you.

Does not work in csh type of shells.

Answer 7

There are two really simple ways:

• Using ps command:

  ps -o comm= $$
  

  or

  ps -h -o comm -p $$
  

  where:

  • -h or finishing all options with = for not showing any header.
  • -o comm for showing only the process basename (bash instead of /bin/bash).
  • -p <PID> list only process whith PID form list suplied.

• Using the /proc process information pseudo-file system:

  cat /proc/$$/comm
  

  This option behaves exactly as the ps command above.

  or

  readlink /proc/$$/exe
  

  This /proc/PID/exe links to the file being executed, what in this case would point to /bin/bash, /bin/ksh, etc.

  For getting only the name of the shell you can yust use

  basename $(readlink /proc/$$/exe)
  

  This is the only option that will always give the same result even if you are in an script, sourced code or terminal as links to the binary of the shell interpreter in use.

  Warning You must be aware that this will show the ultimate binary, so ksh may be linked to ksh93 or sh to bash.

The usage of /proc is really useful via the /proc/self which links to the PID of the current comand.

Answer 8

I set $MYSHELL for future tests in my shell-agnostic ~/.aliases:

unset MYSHELL
if [ -n "$ZSH_VERSION" ] && type zstyle >/dev/null 2>&1; then        # zsh
  MYSHELL=`command -v zsh`
elif [ -x "$BASH" ] && shopt -q >/dev/null 2>&1; then                # bash
  MYSHELL=`command -v bash`
elif [ -x "$shell" ] && which setenv |grep builtin >/dev/null; then  # tcsh
  echo "DANGER: this script is likely not compatible with C shells!"
  sleep 5
  setenv MYSHELL "$shell"
fi

# verify
if [ ! -x "$MYSHELL" ]; then
  MYSHELL=`command -v "$(ps $$ |awk 'NR == 2 { print $NF }')"`
  [ -x "$MYSHELL" ] || MYSHELL="${SHELL:-/bin/sh}"  # default if verify fails
fi

The tcsh section is likely unwise to roll into a POSIX-style script since it's so radically different (thus the warning and five second pause). (For one, csh-style shells can't do 2>/dev/null or >&2, as noted in the famous Csh Programming Considered Harmful rant.)

Answer 9

You can simply use echo $0 command to check which shell you are using and <name_of_the_shell> --version to check the version of the shell. (eg. bash --version).

Answer 10

ps -p $$ | tail -n 1 | awk -F '\-' '{print $2}'

Answer 11

This works too:

env | grep SHELL