我有一个脚本，我不希望它调用退出，如果它是来源。
我想检查是否$0 == bash，但这有问题，如果脚本是从另一个脚本，或者如果用户从不同的shell，如ksh源。
是否有一种可靠的方法来检测脚本是否被引用?
如果您的Bash版本知道BASH_SOURCE数组变量，请尝试如下操作:
# man bash | less -p BASH_SOURCE
#[[ ${BASH_VERSINFO[0]} -le 2 ]] && echo 'No BASH_SOURCE array variable' && exit 1
[[ "${BASH_SOURCE[0]}" != "${0}" ]] && echo "script ${BASH_SOURCE[0]} is being sourced ..."
这似乎在Bash和Korn之间是可移植的:
[[ $_ != $0 ]] && echo "Script is being sourced" || echo "Script is a subshell"
与此类似的行或赋值语句如pathname="$_"(带有稍后的测试和操作)必须位于脚本的第一行或shebang之后的行(如果使用了shebang，则应该用于ksh，以便它在大多数情况下工作)。
我想对丹尼斯非常有用的回答提出一个小小的更正，让它更容易携带，我希望:
[ "$_" != "$0" ] && echo "Script is being sourced" || echo "Script is a subshell"
因为[[不被Debian POSIX兼容外壳识别(有些保留的IMHO)， dash。同样，在shell中，可能需要使用引号来防止文件名中包含空格。
这在后面的脚本中起作用，不依赖于_变量:
## Check to make sure it is not sourced:
Prog=myscript.sh
if [ $(basename $0) = $Prog ]; then
exit 1 # not sourced
fi
or
[ $(basename $0) = $Prog ] && exit
$_是很脆弱的。你必须检查它作为你在脚本中做的第一件事。即使这样，它也不保证包含shell的名称(如果是源的)或脚本的名称(如果是执行的)。
例如，如果用户设置了BASH_ENV，那么在脚本的顶部，$_包含BASH_ENV脚本中执行的最后一个命令的名称。
我发现最好的方法是像这样使用0美元:
name="myscript.sh"
main()
{
echo "Script was executed, running main..."
}
case "$0" in *$name)
main "$@"
;;
esac
不幸的是，这种方式在zsh中并不能开箱使用，因为functionargzero选项的功能超出了它的名称，并且在默认情况下是打开的。
为了解决这个问题，我把unsetopt functionarg0放在我的.zshenv中。
我将给出一个特定于bash的答案。Korn shell，对不起。假设脚本名为include2.sh;然后在include2.sh中创建一个名为am_I_sourced的函数。下面是我的include2.sh的演示版本:
am_I_sourced()
{
if [ "${FUNCNAME[1]}" = source ]; then
if [ "$1" = -v ]; then
echo "I am being sourced, this filename is ${BASH_SOURCE[0]} and my caller script/shell name was $0"
fi
return 0
else
if [ "$1" = -v ]; then
echo "I am not being sourced, my script/shell name was $0"
fi
return 1
fi
}
if am_I_sourced -v; then
echo "Do something with sourced script"
else
echo "Do something with executed script"
fi
现在尝试以多种方式执行它:
~/toys/bash $ chmod a+x include2.sh
~/toys/bash $ ./include2.sh
I am not being sourced, my script/shell name was ./include2.sh
Do something with executed script
~/toys/bash $ bash ./include2.sh
I am not being sourced, my script/shell name was ./include2.sh
Do something with executed script
~/toys/bash $ . include2.sh
I am being sourced, this filename is include2.sh and my caller script/shell name was bash
Do something with sourced script
所以这是毫无例外的工作，它没有使用脆弱的$_东西。这个技巧使用了BASH的自省功能，即内置变量FUNCNAME和BASH_SOURCE;请参阅bash手册页中的文档。
只有两个警告:
1)对am_I_called的调用必须发生在源脚本中，而不是在任何函数中，以免${FUNCNAME[1]}返回其他东西。是的…您本可以检查${FUNCNAME[2]}，但这样做只会使您的工作更加困难。
2)函数am_I_called必须驻留在源脚本中，如果你想知道被包含的文件的名称。
BASH_SOURCE[]的答案(bash-3.0及更高版本)似乎最简单，尽管BASH_SOURCE[]并没有在函数体之外工作(它目前恰好可以工作，这与手册页不一致)。
Wirawan Purwanto建议的最健壮的方法是在函数中检查FUNCNAME[1]:
function mycheck() { declare -p FUNCNAME; }
mycheck
然后:
$ bash sourcetest.sh
declare -a FUNCNAME='([0]="mycheck" [1]="main")'
$ . sourcetest.sh
declare -a FUNCNAME='([0]="mycheck" [1]="source")'
This is the equivalent to checking the output of caller, the values main and source distinguish the caller's context. Using FUNCNAME[] saves you capturing and parsing caller output. You need to know or calculate your local call depth to be correct though. Cases like a script being sourced from within another function or script will cause the array (stack) to be deeper. (FUNCNAME is a special bash array variable, it should have contiguous indexes corresponding to the call stack, as long as it is never unset.)
function issourced() {
[[ ${FUNCNAME[@]: -1} == "source" ]]
}
(在bash-4.2及以后版本中，可以使用更简单的形式${FUNCNAME[-1]}来代替数组中的最后一项。感谢Dennis Williamson下面的评论，改进和简化了。)
然而，你的问题如所述是“我有一个脚本，我不希望它调用'退出'，如果它是来源”。这种情况下常见的bash习惯用法是:
return 2>/dev/null || exit
如果脚本是源脚本，则return将终止源脚本并返回给调用者。
如果脚本正在执行，那么return将返回一个错误(重定向)，exit将正常终止脚本。如果需要，return和exit都可以使用退出码。
遗憾的是，这在ksh中不起作用(至少在我这里的AT&T派生版本中不起作用)，如果在函数或点源脚本外部调用return，它将return视为等同于exit。
更新:在当前版本的ksh中，您可以检查特殊变量.sh。设置为函数调用深度的级别。对于一个被调用的脚本，它最初将被取消设置，对于一个点源脚本，它将被设置为1。
function issourced {
[[ ${.sh.level} -eq 2 ]]
}
issourced && echo this script is sourced
这并不像bash版本那样健壮，您必须在正在测试的文件的顶层或已知函数深度中调用issourced()。
(你可能也对github上的这段代码感兴趣，它使用了ksh纪律函数和一些调试陷阱技巧来模拟bash FUNCNAME数组。)
这里的标准答案是:http://mywiki.wooledge.org/BashFAQ/109还提供了$-作为shell状态的另一个指示器(尽管并不完善)。
注:
可以创建名为“main”和“source”的bash函数(覆盖内置)，这些名称可能出现在FUNCNAME[]中，但只要只测试该数组中的最后一项，就不会有歧义。 我对pdksh没有一个好的答案。我能找到的最接近的方法只适用于pdksh，其中脚本的每个源都打开一个新的文件描述符(原始脚本从10开始)。几乎肯定不是你想要依靠的东西……
看了@DennisWilliamson的回答后，有一些问题，如下所示:
因为这个问题代表ksh和bash，所以这个答案中还有一个关于ksh的部分…见下文。
简单的bash方式
[ "$0" = "$BASH_SOURCE" ]
让我们试试(在飞行中，因为bash可以;-):
source <(echo $'#!/bin/bash
[ "$0" = "$BASH_SOURCE" ] && v=own || v=sourced;
echo "process $$ is $v ($0, $BASH_SOURCE)" ')
process 29301 is sourced (bash, /dev/fd/63)
bash <(echo $'#!/bin/bash
[ "$0" = "$BASH_SOURCE" ] && v=own || v=sourced;
echo "process $$ is $v ($0, $BASH_SOURCE)" ')
process 16229 is own (/dev/fd/63, /dev/fd/63)
我用source代替off。对于可读性(如。是源的别名):
. <(echo $'#!/bin/bash
[ "$0" = "$BASH_SOURCE" ] && v=own || v=sourced;
echo "process $$ is $v ($0, $BASH_SOURCE)" ')
process 29301 is sourced (bash, /dev/fd/63)
注意，当进程保持源时，进程号不会改变:
echo $$
29301
为什么不使用$_ == $0比较
为了确保更多的情况，我开始编写一个真实的脚本:
#!/bin/bash
# As $_ could be used only once, uncomment one of two following lines
#printf '_="%s", 0="%s" and BASH_SOURCE="%s"\n' "$_" "$0" "$BASH_SOURCE"
[[ "$_" != "$0" ]] && DW_PURPOSE=sourced || DW_PURPOSE=subshell
[ "$0" = "$BASH_SOURCE" ] && BASH_KIND_ENV=own || BASH_KIND_ENV=sourced;
echo "proc: $$[ppid:$PPID] is $BASH_KIND_ENV (DW purpose: $DW_PURPOSE)"
复制到testscript文件:
cat >testscript
chmod +x testscript
现在我们可以测试:
./testscript
proc: 25758[ppid:24890] is own (DW purpose: subshell)
没关系。
. ./testscript
proc: 24890[ppid:24885] is sourced (DW purpose: sourced)
source ./testscript
proc: 24890[ppid:24885] is sourced (DW purpose: sourced)
没关系。
但是，在添加-x标志之前测试脚本:
bash ./testscript
proc: 25776[ppid:24890] is own (DW purpose: sourced)
或者使用预定义的变量:
env PATH=/tmp/bintemp:$PATH ./testscript
proc: 25948[ppid:24890] is own (DW purpose: sourced)
env SOMETHING=PREDEFINED ./testscript
proc: 25972[ppid:24890] is own (DW purpose: sourced)
这已经不管用了。
将注释从第5行移到第6行会给出更易读的答案:
./testscript
_="./testscript", 0="./testscript" and BASH_SOURCE="./testscript"
proc: 26256[ppid:24890] is own
. testscript
_="_filedir", 0="bash" and BASH_SOURCE="testscript"
proc: 24890[ppid:24885] is sourced
source testscript
_="_filedir", 0="bash" and BASH_SOURCE="testscript"
proc: 24890[ppid:24885] is sourced
bash testscript
_="/bin/bash", 0="testscript" and BASH_SOURCE="testscript"
proc: 26317[ppid:24890] is own
env FILE=/dev/null ./testscript
_="/usr/bin/env", 0="./testscript" and BASH_SOURCE="./testscript"
proc: 26336[ppid:24890] is own
更难:ksh现在…
由于我不经常使用ksh，在阅读了一些手册页后，有我的尝试:
#!/bin/ksh
set >/tmp/ksh-$$.log
复制到testfile.ksh:
cat >testfile.ksh
chmod +x testfile.ksh
而不是运行两次:
./testfile.ksh
. ./testfile.ksh
ls -l /tmp/ksh-*.log
-rw-r--r-- 1 user user 2183 avr 11 13:48 /tmp/ksh-9725.log
-rw-r--r-- 1 user user 2140 avr 11 13:48 /tmp/ksh-9781.log
echo $$
9725
看看:
diff /tmp/ksh-{9725,9781}.log | grep ^\> # OWN SUBSHELL:
> HISTCMD=0
> PPID=9725
> RANDOM=1626
> SECONDS=0.001
> lineno=0
> SHLVL=3
diff /tmp/ksh-{9725,9781}.log | grep ^\< # SOURCED:
< COLUMNS=152
< HISTCMD=117
< LINES=47
< PPID=9163
< PS1='$ '
< RANDOM=29667
< SECONDS=23.652
< level=1
< lineno=1
< SHLVL=2
在源运行中继承了一些变量，但没有什么真正相关的…
你甚至可以检查$SECONDS是否接近0.000，但这是为了确保只有手工来源的情况……
你甚至可以试着检查parent是什么:
把它放在你的testfile.ksh:
ps $PPID
比:
./testfile.ksh
PID TTY STAT TIME COMMAND
32320 pts/4 Ss 0:00 -ksh
. ./testfile.ksh
PID TTY STAT TIME COMMAND
32319 ? S 0:00 sshd: user@pts/4
或者ps ho cmd $PPID，但这只适用于一个级别的子会话…
对不起，我找不到一个可靠的方法来做，在ksh下。
我需要一个在[mac, linux]上使用bash的一行程序。版本>= 3，这些答案都不符合要求。
[[ ${BASH_SOURCE[0]} = $0 ]] && main "$@"
bash, ksh, zsh的健壮解决方案，包括一个跨shell解决方案，以及一个相当健壮的posix兼容解决方案:
给出的版本号是验证功能的版本号——很可能，这些解决方案也适用于更早的版本——欢迎反馈。 仅使用POSIX特性(例如在dash中，它在Ubuntu中充当/bin/sh)，没有可靠的方法来确定脚本是否被引用-请参阅下面的最佳近似方法。
重要的是:
The solutions determine whether the script is being sourced by its caller, which may be a shell itself or another script (which may or may not be sourced itself): Also detecting the latter case adds complexity; if you do not need to detect the case when your script is being sourced by another script, you can use the following, relatively simple POSIX-compliant solution: # Helper function is_sourced() { if [ -n "$ZSH_VERSION" ]; then case $ZSH_EVAL_CONTEXT in *:file:*) return 0;; esac else # Add additional POSIX-compatible shell names here, if needed. case ${0##*/} in dash|-dash|bash|-bash|ksh|-ksh|sh|-sh) return 0;; esac fi return 1 # NOT sourced. } # Sample call. is_sourced && sourced=1 || sourced=0 All solutions below must run in the top-level scope of your script, not inside functions.
下面是一行程序——解释如下;跨shell版本是复杂的，但它应该可以健壮地工作:
Bash(在3.57、4.4.19和5.1.16上验证)
(return 0 2>/dev/null) && sourced=1 || sourced=0
KSH(在93u+上验证)
[[ "$(cd -- "$(dirname -- "$0")" && pwd -P)/$(basename -- "$0")" != "$(cd -- "$(dirname -- "${.sh.file}")" && pwd -P)/$(basename -- "${.sh.file}")" ]] && sourced=1 || sourced=0
ZSH(5.0.5验证)
[[ $ZSH_EVAL_CONTEXT =~ :file$ ]] && sourced=1 || sourced=0
交叉shell (bash, ksh, zsh)
(
[[ -n $ZSH_VERSION && $ZSH_EVAL_CONTEXT =~ :file$ ]] ||
[[ -n $KSH_VERSION && "$(cd -- "$(dirname -- "$0")" && pwd -P)/$(basename -- "$0")" != "$(cd -- "$(dirname -- "${.sh.file}")" && pwd -P)/$(basename -- "${.sh.file}")" ]] ||
[[ -n $BASH_VERSION ]] && (return 0 2>/dev/null)
) && sourced=1 || sourced=0
posix兼容;由于技术原因，不是一行程序(单一管道)，并且不完全健壮(见底部):
sourced=0
if [ -n "$ZSH_VERSION" ]; then
case $ZSH_EVAL_CONTEXT in *:file) sourced=1;; esac
elif [ -n "$KSH_VERSION" ]; then
[ "$(cd -- "$(dirname -- "$0")" && pwd -P)/$(basename -- "$0")" != "$(cd -- "$(dirname -- "${.sh.file}")" && pwd -P)/$(basename -- "${.sh.file}")" ] && sourced=1
elif [ -n "$BASH_VERSION" ]; then
(return 0 2>/dev/null) && sourced=1
else # All other shells: examine $0 for known shell binary filenames.
# Detects `sh` and `dash`; add additional shell filenames as needed.
case ${0##*/} in sh|-sh|dash|-dash) sourced=1;; esac
fi
解释
bash
(return 0 2>/dev/null) && sourced=1 || sourced=0
注意:该技术改编自user5754163的答案，因为它比原来的解决方案更健壮，[[$0 != "$BASH_SOURCE"]] && sourced=1 || sourced=0[1]
Bash allows return statements only from functions and, in a script's top-level scope, only if the script is sourced. If return is used in the top-level scope of a non-sourced script, an error message is emitted, and the exit code is set to 1. (return 0 2>/dev/null) executes return in a subshell and suppresses the error message; afterwards the exit code indicates whether the script was sourced (0) or not (1), which is used with the && and || operators to set the sourced variable accordingly. Use of a subshell is necessary, because executing return in the top-level scope of a sourced script would exit the script. Tip of the hat to @Haozhun, who made the command more robust by explicitly using 0 as the return operand; he notes: per bash help of return [N]: "If N is omitted, the return status is that of the last command." As a result, the earlier version [which used just return, without an operand] produces incorrect result if the last command on the user's shell has a non-zero return value.
ksh
[[ "$(cd -- "$(dirname -- "$0")" && pwd -P)/$(basename -- "$0")" != "$(cd -- "$(dirname -- "${.sh.file}")" && pwd -P)/$(basename -- "${.sh.file}")" ]] && sourced=1 || sourced=0
特殊变量${.sh。file}有点类似于$BASH_SOURCE;注意${.sh。File}会在bash、zsh和dash中导致语法错误，所以一定要在多shell脚本中有条件地执行它。
与bash不同，$0和${.sh。file}不能保证是相同的-在不同的时候，一个可能是相对路径或仅仅是文件名，而另一个可能是完整的文件名;因此，$0和${.sh。File}在比较之前必须解析为全路径。如果完整路径不同，则隐含了源。
zsh
[[ $ZSH_EVAL_CONTEXT =~ :file$) ]] && sourced=1 || sourced=0
$ZSH_EVAL_CONTEXT包含关于计算上下文:子字符串文件的信息，用:分隔，只有在脚本被引用时才会出现。
在源脚本的顶级作用域中，$ZSH_EVAL_CONTEXT以:file结尾，这就是这个测试的限制。在函数内部，:shfunc被追加到:file;在命令替换中追加:cmdsubst。
仅使用POSIX特性
如果您愿意做出某些假设，那么您可以根据可能正在执行脚本的shell的二进制文件名，对脚本是否被引用做出合理但并非万无一错的猜测。 值得注意的是，这意味着当您的脚本被另一个脚本引用时，这种方法不会检测到这种情况。
本回答中的“如何处理源调用”一节只详细讨论了POSIX特性无法处理的边缘情况。
检查二进制文件名依赖于$0的标准行为，例如，zsh就没有这种行为。
因此，最安全的方法是将上述健壮的、特定于shell的方法(不依赖于$0)与所有剩余shell的基于$0的回退解决方案结合起来。
简而言之:解决方案如下:
在包含特定于shell的测试的shell中:稳定地工作。 在所有其他shell中:仅当脚本直接来自这样的shell(而不是来自另一个脚本)时才能正常工作。
向Stéphane Desneux和他的灵感答案致敬(将我的跨shell语句表达式转换为sh兼容的if语句，并为其他shell添加一个处理程序)。
sourced=0
if [ -n "$ZSH_VERSION" ]; then
case $ZSH_EVAL_CONTEXT in *:file) sourced=1;; esac
elif [ -n "$KSH_VERSION" ]; then
[ "$(cd -- "$(dirname -- "$0")" && pwd -P)/$(basename -- "$0")" != "$(cd -- "$(dirname -- "${.sh.file}")" && pwd -P)/$(basename -- "${.sh.file}")" ] && sourced=1
elif [ -n "$BASH_VERSION" ]; then
(return 0 2>/dev/null) && sourced=1
else # All other shells: examine $0 for known shell binary filenames.
# Detects `sh` and `dash`; add additional shell filenames as needed.
case ${0##*/} in sh|-sh|dash|-dash) sourced=1;; esac
fi
注意，为了健壮性，每个shell二进制文件名(例如sh)都表示了两次——一次是原样，第二次是，前缀是-。这是为了考虑诸如macOS这样的环境，其中交互式shell作为登录shell启动，其自定义值为$0，该值是前缀为-的(无路径)shell文件名。谢谢,t7e。 (虽然sh和dash可能不太可能用作交互式shell，但您可能需要将其他shell添加到列表中。)
[1] user1902689发现[[$0 != "$BASH_SOURCE"]]在通过将其文件名传递给bash二进制文件执行位于$PATH中的脚本时，会产生假阳性;例如，bash my-script，因为$0只是my-script，而$BASH_SOURCE是完整路径。虽然您通常不会使用这种技术来调用$PATH中的脚本—您只会直接调用它们(my-script)—当与-x结合使用时，它对调试很有帮助。
编者注:这个答案的解决方案工作稳健，但只有bash。它可以简化为 (返回2 > / dev / null)。
博士TL;
尝试执行return语句。如果脚本没有来源，则会引发错误。您可以捕获该错误并按照需要进行操作。
把它放在一个文件中，并调用它，比如test.sh:
#!/usr/bin/env sh
# Try to execute a `return` statement,
# but do it in a sub-shell and catch the results.
# If this script isn't sourced, that will raise an error.
$(return >/dev/null 2>&1)
# What exit code did that give?
if [ "$?" -eq "0" ]
then
echo "This script is sourced."
else
echo "This script is not sourced."
fi
直接执行:
shell-prompt> sh test.sh
output: This script is not sourced.
来源:
shell-prompt> source test.sh
output: This script is sourced.
对我来说，这可以在zsh和bash中工作。
解释
如果您试图在函数之外执行return语句，或者如果脚本不是源代码，则return语句将引发错误。在shell提示符中尝试以下操作:
shell-prompt> return
output: ...can only `return` from a function or sourced script
你不需要看到错误消息，所以你可以将输出重定向到dev/null:
shell-prompt> return >/dev/null 2>&1
现在检查逃生码。0表示OK(没有发生错误)，1表示发生错误:
shell-prompt> echo $?
output: 1
您还希望在子shell中执行return语句。当return语句运行它时…嗯……的回报。如果在子shell中执行它，它将从子shell返回，而不是从脚本返回。要在子shell中执行，请将其包装在$(…)中:
shell-prompt> $(return >/dev/null 2>$1)
现在，你可以看到子shell的退出代码，它应该是1，因为在子shell内部引发了一个错误:
shell-prompt> echo $?
output: 1
我遵循mklement0紧凑表达式。
这很整洁，但我注意到，当调用ksh时，它可能会失败:
/bin/ksh -c ./myscript.sh
(它认为它是源的，而不是因为它执行了一个子shell) 但是表达式可以检测到这一点:
/bin/ksh ./myscript.sh
此外，即使表达式是紧凑的，语法也不兼容所有shell。
因此，我以以下代码结束，它适用于bash,zsh,dash和ksh
SOURCED=0
if [ -n "$ZSH_EVAL_CONTEXT" ]; then
[[ $ZSH_EVAL_CONTEXT =~ :file$ ]] && SOURCED=1
elif [ -n "$KSH_VERSION" ]; then
[[ "$(cd $(dirname -- $0) && pwd -P)/$(basename -- $0)" != "$(cd $(dirname -- ${.sh.file}) && pwd -P)/$(basename -- ${.sh.file})" ]] && SOURCED=1
elif [ -n "$BASH_VERSION" ]; then
[[ $0 != "$BASH_SOURCE" ]] && SOURCED=1
elif grep -q dash /proc/$$/cmdline; then
case $0 in *dash*) SOURCED=1 ;; esac
fi
请随意添加异国情调的贝壳支持:)
直截了当:您必须计算变量“$0”是否等于Shell的名称。
是这样的:
#!/bin/bash
echo "First Parameter: $0"
echo
if [[ "$0" == "bash" ]] ; then
echo "The script was sourced."
else
echo "The script WAS NOT sourced."
fi
通过壳:
$ bash check_source.sh
First Parameter: check_source.sh
The script WAS NOT sourced.
通过来源:
$ source check_source.sh
First Parameter: bash
The script was sourced.
很难有一种100%可移植的方法来检测脚本是否来自源代码。
根据我的经验(使用Shellscripting 7年)，唯一安全的方法(不依赖具有pid等的环境变量，这是不安全的，因为它是变量)，你应该:
扩展你的“如果”的可能性 使用开关/箱子，如果你想。
这两个选项都不能自动缩放，但这是更安全的方式。
例如:
当您通过SSH会话源脚本时，变量“$0”(当使用source时)返回的值是-bash。
#!/bin/bash
echo "First Parameter: $0"
echo
if [[ "$0" == "bash" || "$0" == "-bash" ]] ; then
echo "The script was sourced."
else
echo "The script WAS NOT sourced."
fi
OR
#!/bin/bash
echo "First Parameter: $0"
echo
if [[ "$0" == "bash" ]] ; then
echo "The script was sourced."
elif [[ "$0" == "-bash" ]] ; then
echo "The script was sourced via SSH session."
else
echo "The script WAS NOT sourced."
fi
FWIW，在阅读了所有其他的答案后，我想出了以下解决方案:
更新:事实上，有人在另一个答案中发现了一个已经更正的错误，这也影响了我的答案。我认为这里的更新也是一个改进(如果你好奇，请参阅编辑)。
这适用于所有以#!开头的脚本。/bin/bash，但也可以由不同的shell来获取一些信息(如设置)，这些信息保存在主函数之外。
根据下面的评论，这里的答案显然不适用于所有bash变体。同样不适用于/bin/sh基于bash的系统。也就是说，它失败的bash v3。在MacOS上。(目前我不知道如何解决这个问题。)
#!/bin/bash
# Function definitions (API) and shell variables (constants) go here
# (This is what might be interesting for other shells, too.)
# this main() function is only meant to be meaningful for bash
main()
{
# The script's execution part goes here
}
BASH_SOURCE=".$0" # cannot be changed in bash
test ".$0" != ".$BASH_SOURCE" || main "$@"
你可以使用以下(在我看来可读性较差)代码来代替最后两行，在其他shell中不设置BASH_SOURCE，并允许set -e在main中工作:
if ( BASH_SOURCE=".$0" && exec test ".$0" != ".$BASH_SOURCE" ); then :; else main "$@"; fi
这个脚本配方有以下属性:
If executed by bash the normal way, main is called. Please note that this does not include a call like bash -x script (where script does not contain a path), see below. If sourced by bash, main is only called, if the calling script happens to have the same name. (For example, if it sources itself or via bash -c 'someotherscript "$@"' main-script args.. where main-script must be, what test sees as $BASH_SOURCE). If sourced/executed/read/evaled by a shell other than bash, main is not called (BASH_SOURCE is always different to $0). main is not called if bash reads the script from stdin, unless you set $0 to be the empty string like so: ( exec -a '' /bin/bash ) <script If evaluated by bash with eval (eval "`cat script`" all quotes are important!) from within some other script, this calls main. If eval is run from commandline directly, this is similar to previous case, where the script is read from stdin. (BASH_SOURCE is blank, while $0 usually is /bin/bash if not forced to something completely different.) If main is not called, it does return true ($?=0). This does not rely on unexpected behavior (previously I wrote undocumented, but I found no documentation that you cannot unset nor alter BASH_SOURCE either): BASH_SOURCE is a bash reserved array. But allowing BASH_SOURCE=".$0" to change it would open a very dangerous can of worms, so my expectation is, that this must have no effect (except, perhaps, some ugly warning shows up in some future version of bash). There is no documentation that BASH_SOURCE works outside functions. However the opposite (that it only works in functions) is neither documented. The observation is, that it works (tested with bash v4.3 and v4.4, unfortunately I have no bash v3.x anymore) and that quite too many scripts would break, if $BASH_SOURCE stops working as observed. Hence my expectation is, that BASH_SOURCE stays as is for future versions of bash, too. In contrast (nice find, BTW!) consider ( return 0 ), which gives 0 if sourced and 1 if not sourced. This comes a bit unexpected not only for me , and (according to the readings there) POSIX says, that return from subshell is undefined behavior (and the return here is clearly from a subshell). Perhaps this feature eventually gets enough widespread use such that it can no more be changed, but AFAICS there is a much higher chance that some future bash version accidental changes the return behavior in that case. Unfortunately bash -x script 1 2 3 does not run main. (Compare script 1 2 3 where script has no path). Following can be used as workaround: bash -x "`which script`" 1 2 3 bash -xc '. script' "`which script`" 1 2 3 That bash script 1 2 3 does not run main can be considered a feature. Note that ( exec -a none script ) calls main (bash does not pass it's $0 to the script, for this you need to use -c as shown in the last point).
因此，除了一些极端情况外，main只在脚本以通常的方式执行时才被调用。通常这就是你想要的，特别是因为它缺乏复杂的难以理解的代码。
注意，它与Python代码非常相似: 如果__name__ == '__main__': main() 这也阻止了main的调用，除了一些角落的情况，如 你可以导入/加载脚本并强制__name__='__main__'
为什么我认为这是一个解决挑战的好方法
如果您有一些可以由多个shell提供源代码的东西，那么它必须是兼容的。然而(请阅读其他答案)，由于没有(容易实现的)可移植的方法来检测来源，您应该更改规则。
通过强制脚本必须由/bin/bash执行，您可以做到这一点。
这解决了所有的情况，但在以下情况下，脚本不能直接运行:
/bin/bash未安装或无法运行(即在引导环境中) 如果你将它管道到一个shell，比如curl https://example.com/script | $ shell (注意:这只适用于最近的bash。据报道，这种配方对某些变体无效。所以一定要检查它是否适用于你的情况。)
然而，我想不出任何真正的原因，在哪里你需要它，以及能力来源完全相同的脚本并行!通常，您可以将其包装起来手动执行main。像这样:
$SHELL -c '。脚本&& main {curl https://example.com/script && echo && echo main;} | $ shell $SHELL -c“eval”“curl https://example.com/script”“&& main” echo 'eval ' ' curl https://example.com/script ' ' && main' | $SHELL
笔记
如果没有其他答案的帮助，这个答案是不可能的!甚至是错误的——最初促使我发表这篇文章的原因。 更新:由于在https://stackoverflow.com/a/28776166/490291中发现的新发现而编辑
我最终检查[[$_ == "$(type -p "$0")"]]
if [[ $_ == "$(type -p "$0")" ]]; then
echo I am invoked from a sub shell
else
echo I am invoked from a source command
fi
当使用curl时…| bash -s——ARGS运行远程脚本时，$0将只是bash而不是正常的/bin/bash运行实际的脚本文件，所以我使用-p“$0”来显示bash的完整路径。
测试:
curl -sSL https://github.com/jjqq2013/bash-scripts/raw/master/common/relpath | bash -s -- /a/b/c/d/e /a/b/CC/DD/EE
source <(curl -sSL https://github.com/jjqq2013/bash-scripts/raw/master/common/relpath)
relpath /a/b/c/d/e /a/b/CC/DD/EE
wget https://github.com/jjqq2013/bash-scripts/raw/master/common/relpath
chmod +x relpath
./relpath /a/b/c/d/e /a/b/CC/DD/EE
这是从其他一些关于“通用”跨壳支持的答案衍生出来的。不可否认，这与https://stackoverflow.com/a/2942183/3220983非常相似，尽管略有不同。这样做的缺点是，客户端脚本必须尊重如何使用它(即先导出一个变量)。它的优点是简单，而且可以在“任何地方”工作。这里有一个模板供你剪切和粘贴:
# NOTE: This script may be used as a standalone executable, or callable library.
# To source this script, add the following *prior* to including it:
# export ENTRY_POINT="$0"
main()
{
echo "Running in direct executable context!"
}
if [ -z "${ENTRY_POINT}" ]; then main "$@"; fi
注意:我使用export只是为了确保这个机制可以扩展到子进程。
解决这个问题的方法不是编写需要知道这些事情才能正确运行的代码。做到这一点的方法是将代码放入函数中，而不是放入需要源代码的脚本主线中。
函数内部的代码可以只返回0或1。这只终止了函数，因此控制返回到调用该函数的任何对象。
无论从源脚本的主线调用函数，还是从顶级脚本的主线调用函数，或者从另一个函数调用函数，都是如此。
使用sourcing来引入“库”脚本，这些脚本只定义函数和变量，但实际上不执行任何其他顶级命令:
. path/to/lib.sh # defines libfunction
libfunction arg
否则:
path/to/script.sh arg # call script as a child process
而不是:
. path/to/script.sh arg # shell programming anti-pattern
这并不完全是OP想要的，但我经常发现自己需要源代码脚本只是为了加载它的函数(即作为一个库)。例如，用于基准测试或测试目的。
下面是一个适用于所有shell(包括POSIX)的设计:
将所有顶级操作包装在run_main()函数中。 让您的源脚本检查不执行任何操作的初始-no-run参数;没有——no-run，它可以调用run_main。 使用以下方法获取脚本的源代码:
set -- --no-run "$@"
. script.sh
shift
问题是。或者来源是不可能将参数可移植地传递给脚本。POSIX shell忽略参数。并传递调用者的“$@”。
检测Bash脚本是否正在执行或导入的最漂亮方法
我真的认为这是最美丽的方式:
从我的eRCaGuy_hello_world repo中的if__name__==__main__ check_if_sourced_or_executed_best.sh文件:
#!/usr/bin/env bash
main() {
echo "Running main."
# Add your main function code here
}
if [ "${BASH_SOURCE[0]}" = "$0" ]; then
# This script is being run.
__name__="__main__"
else
# This script is being sourced.
__name__="__source__"
fi
# Only run `main` if this script is being **run**, NOT sourced (imported)
if [ "$__name__" = "__main__" ]; then
echo "This script is being run."
main
else
echo "This script is being sourced."
fi
引用:
关于上述技术的其他详细信息，请参见我在这里的另一个回答，包括显示运行输出:bash与Python的if __name__ == '__main__'等价于什么? 这个答案，我第一次了解到“${BASH_SOURCE[0]}”=“$0”
如果您愿意，还可以探索以下替代方案，但我更喜欢使用上面的代码块。
重要提示:使用“${FUNCNAME[-1]}”技术不能正确处理嵌套脚本，即一个脚本调用或来源另一个脚本，而if ["${BASH_SOURCE[0]}" = "$0"]技术可以。这是使用if ["${BASH_SOURCE[0]}" = "$0"]的另一个重要原因。
4种方法确定bash脚本是源脚本还是执行脚本
我已经阅读了关于这个问题和其他一些问题的一堆答案，并提出了4种我想要总结并放在一个地方的方法。
if __name__ == "__main__":
参见:如果__name__ == "__main__":会做什么?在Python中所做的事情。
You can see a full demonstration of all 4 techniques below in my check_if_sourced_or_executed.sh script in my eRCaGuy_hello_world repo. You can see one of the techniques in-use in my advanced bash program with help menu, argument parsing, main function, automatic execute vs source detection (akin to if __name__ == "__main__": in Python), etc, see my demo/template program in this list here. It is currently called argument_parsing__3_advanced__gen_prog_template.sh, but if that name changes in the future I'll update it in the list at the link just above
不管怎样，这里有4个Bash技术:
Technique 1 (can be placed anywhere; handles nested scripts): See: https://unix.stackexchange.com/questions/424492/how-to-define-a-shell-script-to-be-sourced-not-run/424495#424495 if [ "${BASH_SOURCE[0]}" -ef "$0" ]; then echo " This script is being EXECUTED." run="true" else echo " This script is being SOURCED." fi Technique 2 [My favorite technique] (can be placed anywhere; handles nestes scripts): See this type of technique in-use in my most-advanced bash demo script yet, here: argument_parsing__3_advanced__gen_prog_template.sh, near the bottom. Modified from: What is the bash equivalent to Python's `if __name__ == '__main__'`? if [ "${BASH_SOURCE[0]}" == "$0" ]; then echo " This script is being EXECUTED." run="true" else echo " This script is being SOURCED." fi Technique 3 (requires another line which MUST be outside all functions): Modified from: How to detect if a script is being sourced # A. Place this line OUTSIDE all functions: (return 0 2>/dev/null) && script_is_being_executed="false" || script_is_being_executed="true" # B. Place these lines anywhere if [ "$script_is_being_executed" == "true" ]; then echo " This script is being EXECUTED." run="true" else echo " This script is being SOURCED." fi Technique 4 [Limitation: does not handle nested scripts!] (MUST be inside a function): Modified from: How to detect if a script is being sourced and Unix & Linux: How to define a shell script to be sourced not run. if [ "${FUNCNAME[-1]}" == "main" ]; then echo " This script is being EXECUTED." run="true" elif [ "${FUNCNAME[-1]}" == "source" ]; then echo " This script is being SOURCED." else echo " ERROR: THIS TECHNIQUE IS BROKEN" fi This is where I first learned about the ${FUNCNAME[-1]} trick: @mr.spuratic: How to detect if a script is being sourced - he learned it from Dennis Williamson apparently.
参见:
[我的回答]bash相当于Python的if __name__ == '__main__'? [我的回答]Unix和Linux:如何定义一个shell脚本来获取而不是运行
@mklement0答案的一个小补充。这是我在脚本中使用的自定义函数，用于确定它是否被引用:
replace_shell(){
if [ -n "$ZSH_EVAL_CONTEXT" ]; then
case $ZSH_EVAL_CONTEXT in *:file*) echo "Zsh is sourced";; esac
else
case ${0##*/} in sh|dash|bash) echo "Bash is sourced";; esac
fi
}
在函数中，zsh的“$ZSH_EVAL_CONTEXT”的输出是toplevel:file:shfunc，而不仅仅是toplevel:file;因此，*:file*应该解决这个问题。
使用shebang行并检查它是否正在执行。
你的脚本应该有一行shebang #!/path/to/shell表示它应该在哪个shell中运行。否则，您还会遇到其他跨shell兼容性问题。
因此，您只需要通过尝试在源时不起作用的命令来检查它是否正在执行。
如。对于Bash脚本:
#!/usr/bin/env bash
if (return 0 2>/dev/null); then
echo "Script was sourced."
fi
这个方法也适用于zsh和sh只是改变shebang行。
