Как узнать имя файла сценария в сценарии Bash?

me=`basename "$0"`

Для чтения символической ссылки ¹, что обычно не то, что вам нужно (обычно вы не хотите таким образом вводить пользователя в заблуждение), попробуйте:

me = "$(basename "$(test -L "$0" && readlink "$0" || echo "$0")")"

ИМО, это приведет к запутанному выводу. «Я запустил foo.sh, но он говорит, что у меня работает bar.sh !? Кроме того, одной из целей наличия символических ссылок с разными именами является обеспечение различных функций в зависимости от имени, которым они называются (например, gzip и gunzip на некоторых платформах).

¹ То есть, чтобы разрешить символические ссылки таким образом, чтобы, когда пользователь выполняет foo.sh, который фактически является символической ссылкой на bar.sh, вы хотите использовать разрешенное имя bar.sh, а не foo.sh.

echo "У вас $ 0"

Вы можете использовать $ 0 для определения имени вашего скрипта (с полным путем) - чтобы получить только имя скрипта, вы можете обрезать эту переменную с помощью

basename $0

Если в имени сценария есть пробелы, более надежным способом является использование "$0" или "$(basename "$0")" - или в MacOS: "$(basename \"$0\")". Это предотвращает искажение или интерпретацию имени каким-либо образом. В общем, рекомендуется всегда заключать имена переменных в двойные кавычки в оболочке.

Чтобы ответить Крис Конвей, в Linux (по крайней мере) вы должны сделать это:

echo $(basename $(readlink -nf $0))

readlink выводит значение символической ссылки. Если это не символическая ссылка, печатается имя файла. -n указывает ему не печатать новую строку. -f указывает ему полностью перейти по ссылке (если символическая ссылка была ссылкой на другую ссылку, она также разрешит эту ссылку).

Если вы хотите его без пути, вы должны использовать ${0##*/}

Эти ответы верны для заявленных случаев, но проблема по-прежнему сохраняется, если вы запускаете сценарий из другого сценария с ключевым словом 'source' (чтобы он выполнялся в той же оболочке). В этом случае вы получите $ 0 вызывающего скрипта. И в этом случае я не думаю, что возможно получить название самого скрипта.

Это крайний случай, и его не следует воспринимать СЛИШКОМ серьезно. Если вы запустите сценарий напрямую из другого сценария (без «источника»), использование $ 0 будет работать.

С bash> = 3 работает следующее:

$ ./s
0 is: ./s
BASH_SOURCE is: ./s
$ . ./s
0 is: bash
BASH_SOURCE is: ./s

$ cat s
#!/bin/bash

printf '$0 is: %s\n$BASH_SOURCE is: %s\n' "$0" "$BASH_SOURCE"

# ------------- SCRIPT ------------- #

#!/bin/bash

echo
echo "# arguments called with ---->  ${@}     "
echo "# \$1 ---------------------->  $1       "
echo "# \$2 ---------------------->  $2       "
echo "# path to me --------------->  ${0}     "
echo "# parent path -------------->  ${0%/*}  "
echo "# my name ------------------>  ${0##*/} "
echo
exit

# ------------- CALLED ------------- #

# Notice on the next line, the first argument is called within double, 
# and single quotes, since it contains two words

$  /misc/shell_scripts/check_root/show_parms.sh "'hello there'" "'william'"

# ------------- RESULTS ------------- #

# arguments called with --->  'hello there' 'william'
# $1 ---------------------->  'hello there'
# $2 ---------------------->  'william'
# path to me -------------->  /misc/shell_scripts/check_root/show_parms.sh
# parent path ------------->  /misc/shell_scripts/check_root
# my name ----------------->  show_parms.sh

# ------------- END ------------- #

Re: (принятый) ответ Tanktalus выше, немного более чистый способ - использовать:

me=$(readlink --canonicalize --no-newline $0)

Если ваш сценарий был получен из другого сценария bash, вы можете использовать:

me=$(readlink --canonicalize --no-newline $BASH_SOURCE)

Я согласен с тем, что разыменование символических ссылок могло бы сбить с толку, если ваша цель - предоставить обратную связь пользователю, но бывают случаи, когда вам действительно нужно получить каноническое имя для скрипта или другого файла, и это лучший способ, imo.

DIRECTORY=$(cd `dirname $0` && pwd)

Я получил это из другого вопроса Stack Overflow, Может ли сценарий Bash сказать, в каком каталоге он хранится?, но я думаю, что это полезно и для этой темы.

$BASH_SOURCE дает правильный ответ при поиске скрипта.

Однако это включает в себя путь, поэтому, чтобы получить только имя файла сценария, используйте:

$(basename $BASH_SOURCE) 

this = "$(dirname "$(realpath "$BASH_SOURCE")")"

Это разрешает символические ссылки (это делает realpath), обрабатывает пробелы (это делают двойные кавычки) и находит текущее имя сценария, даже если оно получено (./myscript) или вызвано другими сценариями ($ BASH_SOURCE обрабатывает это). После всего этого хорошо сохранить это в переменной среды для повторного использования или для простого копирования в другом месте (this =) ...

Я обнаружил, что эта строка работает всегда, независимо от того, был ли файл получен или запущен как сценарий.

echo "${BASH_SOURCE[${#BASH_SOURCE[@]} - 1]}"

Если вы хотите следовать символическим ссылкам, используйте readlink на указанном выше пути, рекурсивно или нерекурсивно.

Причина, по которой однострочный режим работает, объясняется использованием переменной среды BASH_SOURCE и связанного с ней FUNCNAME.

BASH_SOURCE

An array variable whose members are the source filenames where the corresponding shell function names in the FUNCNAME array variable are defined. The shell function ${FUNCNAME[$i]} is defined in the file ${BASH_SOURCE[$i]} and called from ${BASH_SOURCE[$i+1]}.

FUNCNAME

An array variable containing the names of all shell functions currently in the execution call stack. The element with index 0 is the name of any currently-executing shell function. The bottom-most element (the one with the highest index) is "main". This variable exists only when a shell function is executing. Assignments to FUNCNAME have no effect and return an error status. If FUNCNAME is unset, it loses its special properties, even if it is subsequently reset.

This variable can be used with BASH_LINENO and BASH_SOURCE. Each element of FUNCNAME has corresponding elements in BASH_LINENO and BASH_SOURCE to describe the call stack. For instance, ${FUNCNAME[$i]} was called from the file ${BASH_SOURCE[$i+1]} at line number ${BASH_LINENO[$i]}. The caller builtin displays the current call stack using this information.

[Источник: руководство Bash]

Информация благодаря Биллу Эрнандесу. Я добавил некоторые настройки, которые принимаю.

#!/bin/bash
function Usage(){
    echo " Usage: show_parameters [ arg1 ][ arg2 ]"
}
[[ ${#2} -eq 0 ]] && Usage || {
    echo
    echo "# arguments called with ---->  ${@}     "
    echo "# \$1 ----------------------->  $1       "
    echo "# \$2 ----------------------->  $2       "
    echo "# path to me --------------->  ${0}     " | sed "s/$USER/\$USER/g"
    echo "# parent path -------------->  ${0%/*}  " | sed "s/$USER/\$USER/g"
    echo "# my name ------------------>  ${0##*/} "
    echo
}

Ваше здоровье

что-то вроде этого?

export LC_ALL=en_US.UTF-8
#!/bin/bash
#!/bin/sh

#----------------------------------------------------------------------
start_trash(){
ver = "htrash.sh v0.0.4"
$TRASH_DIR  # url to trash $MY_USER
$TRASH_SIZE # Show Trash Folder Size

echo "Would you like to empty Trash  [y/n]?"
read ans
if [ $ans = y -o $ans = Y -o $ans = yes -o $ans = Yes -o $ans = YES ]
then
echo "'yes'"
cd $TRASH_DIR && $EMPTY_TRASH
fi
if [ $ans = n -o $ans = N -o $ans = no -o $ans = No -o $ans = NO ]
then
echo "'no'"
fi
 return $TRUE
} 
#-----------------------------------------------------------------------

start_help(){
echo "HELP COMMANDS-----------------------------"
echo "htest www                 open a homepage "
echo "htest trash               empty trash     "
 return $TRUE
} #end Help
#-----------------------------------------------#

homepage = ""

return $TRUE
} #end cpdebtemp

# -Case start
# if no command line arg given
# set val to Unknown
if [ -z  ]
then
  val = "*** Unknown  ***"
elif [ -n  ]
then
# otherwise make first arg as val
  val=
fi
# use case statement to make decision for rental
case $val in
   "trash") start_trash ;;
   "help") start_help ;;
   "www") firefox $homepage ;;
   *) echo "Sorry, I can not get a $val   for you!";;
esac
# Case stop

если вы вызываете сценарий оболочки, например

/home/mike/runme.sh

$ 0 - полное имя

 /home/mike/runme.sh

basename $ 0 получит базовое имя файла

 runme.sh

и вам нужно поместить это основное имя в переменную, например

filename=$(basename $0)

и добавьте свой дополнительный текст

echo "You are running $filename"

так что твои скрипты нравятся

/home/mike/runme.sh
#!/bin/bash 
filename=$(basename $0)
echo "You are running $filename"

echo "$(basename "`test -L ${BASH_SOURCE[0]} \
                   && readlink ${BASH_SOURCE[0]} \
                   || echo ${BASH_SOURCE[0]}`")"

В bash вы можете получить имя файла сценария, используя $0. Обычно $1, $2 и т. д. Предназначены для доступа к аргументам CLI. Аналогичным образом $0 обеспечивает доступ к имени, запускающему сценарий (имя файла сценария).

#!/bin/bash
echo "You are running $0"
...
...

Если вы вызываете скрипт с таким путем, как /path/to/script.sh, $0 также даст имя файла с путем. В этом случае необходимо использовать $(basename $0), чтобы получить только имя файла сценария.

Поскольку в некоторых комментариях спрашивалось об имени файла без расширения, вот пример того, как это сделать:

FileName=${0##*/}
FileNameWithoutExtension=${FileName%.*}

Наслаждаться!

Вот что я придумал, вдохновленный ответом Димитр Радулов(кстати, я проголосовал за).

script = "$BASH_SOURCE"
[ -z "$BASH_SOURCE" ] && script = "$0"

echo "Called $script with $# argument(s)"

независимо от того, как вы называете свой сценарий

. path/to/script.sh

или же

./path/to/script.sh

Коротко, ясно и просто, в my_script.sh

#!/bin/bash

running_file_name=$(basename "$0")

echo "You are running '$running_file_name' file."

Выход:

./my_script.sh
You are running 'my_script.sh' file.

Это отлично работает с ./self.sh, ~/self.sh, source self.sh, source ~/self.sh:

#!/usr/bin/env bash

self=$(readlink -f "${BASH_SOURCE[0]}")
basename=$(basename "$self")

echo "$self"
echo "$basename"

Кредиты: я объединил несколько ответов, чтобы получить этот.