blocks|key|714219|text|eval可能是实现这一目标的唯一方法。唯一真正的缺点是它的安全性方面，因为你需要确保没有恶意的东西被传入，并且只会调用你想要调用的函数(同时检查它是否也有像';‘这样的讨厌字符)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|714220|因此，如果你是调用代码的人，那么eval可能是唯一的方法。请注意，还有其他形式的eval也可能使用子命令($()和)，但它们不安全，而且成本更高。|714221|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

eval is likely the only way to accomplish it. The only real downside is the security aspect of it, as you need to make sure that nothing malicious gets passed in and only functions you want to get called will be called (along with checking that it doesn't have nasty characters like ';' in it as well).

So if you're the one calling the code, then eval is likely the only way to do it. Note that there are other forms of eval that would likely work too involving subcommands ($() and ``), but they're not safer and are more expensive.

blocks|key|714245|text|你应该有一些类似的东西：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|714246|function+around()
{
++echo+'before';
++echo+`$1`;
++echo+'after';
}|code-block|syntax|javascript|714247|然后，您可以调用around+x|offset|length|style|CODE|714248|entityMap^0|0|0|8|8|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You should have something along the lines of:

<pre><code>function around()
{
 echo 'before';
 echo `$1`;
 echo 'after';
}
</code></pre>

You can then call <code>around x</code>

blocks|key|714286|text|更好的方法是在函数中使用局部变量。然后，问题变成了如何将结果传递给调用者。一种机制是使用命令替换：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|714287|function+myfunc()
{
++++local++myresult='some+value'
++++echo+"$myresult"
}

result=$(myfunc)+++#+or+result=`myfunc`
echo+$result|code-block|syntax|javascript|714288|在这里，结果被输出到stdout，调用者使用命令替换来捕获变量中的值。然后，可以根据需要使用该变量。|714289|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

A better approach is to use local variables in your functions. The problem then becomes how do you get the result to the caller. One mechanism is to use command substitution:

<pre><code>function myfunc()
{
 local myresult='some value'
 echo "$myresult"
}

result=$(myfunc) # or result=`myfunc`
echo $result
</code></pre>

Here the result is output to the stdout and the caller uses command substitution to capture the value in a variable. The variable can then be used as needed.

blocks|key|930199|text|不需要使用eval|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|930200|function+x()+{
++echo+"Hello+world"
}

function+around()+{
++echo+"before"
++var=$($1)
++echo+"after+$var"
}

around+x|code-block|syntax|javascript|930201|entityMap^0|5|4|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

there's no need to use <code>eval</code>

<pre><code>function x() {
 echo "Hello world"
}

function around() {
 echo "before"
 var=$($1)
 echo "after $var"
}

around x
</code></pre>

blocks|key|930264|text|如果您不需要任何花哨的东西，比如延迟函数名或它的参数的计算，那么就不需要eval|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|930265|function+x()++++++{+echo+"Hello+world";++++++++++}
function+around()+{+echo+before;+$1;+echo+after;+}

around+x|code-block|syntax|javascript|930266|做你想做的。你甚至可以这样传递函数和它的参数：|930267|function+x()++++++{+echo+"x():+Passed+$1+and+$2";++}
function+around()+{+echo+before;+"$@";+echo+after;+}

around+x+1st+2nd|930268|打印|930269|before
x():+Passed+1st+and+2nd
after|930270|entityMap^0|10|4|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|10|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|T|$]]

If you don't need anything fancy like delaying the evaluation of the function name or its arguments, you don't need <code>eval</code>:

<pre><code>function x() { echo "Hello world"; }
function around() { echo before; $1; echo after; }

around x
</code></pre>

does what you want. You can even pass the function and its arguments this way:

<pre><code>function x() { echo "x(): Passed $1 and $2"; }
function around() { echo before; "$@"; echo after; }

around x 1st 2nd
</code></pre>

prints

<pre><code>before
x(): Passed 1st and 2nd
after
</code></pre>

blocks|key|930312|text|除了字符串之外，不能将任何内容传递给函数。进程替换可以在某种程度上伪造它。Bash倾向于保持打开FIFO，直到其扩展到完成的命令。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|930313|这里有一个简单而愚蠢的例子|930314|foldl()+{
++++echo+$(($(</dev/stdin)$2))
}+<+<(tr+'\n'+"$1"+<$3)

#+Sum+20+random+ints+from+0-999
foldl+%2B+0+<(while+((n=RANDOM%25999,x%2B%2B<20));+do+echo+$n;+done)|code-block|syntax|javascript|930315|函数可以导出，但这并不像第一次看起来那么有趣。我发现它主要用于使脚本或其他运行脚本的程序可以访问调试功能。|930316|(
++++id()+{
++++++++"$@"
++++}

++++export+-f+id
++++exec+bash+-c+'echowrap()+{+echo+"$1";+};+id+echowrap+hi'
)|930317|id仍然只获取一个字符串，该字符串恰好是函数的名称(从环境中的序列化自动导入)及其参数。|offset|length|style|CODE|930318|Pumbaa80对另一个答案的评论也很好(eval+$(declare+-F+"$1"))，但它主要用于数组，而不是函数，因为它们总是全局的。如果你在一个函数中运行它，它所做的就是重新定义它，所以没有任何效果。它不能用于创建闭包、部分函数或依赖于当前作用域中绑定的内容的“函数实例”。这充其量可以用来将函数定义存储在字符串中，然后在其他地方重新定义--但是这些函数也只能被硬编码，当然，除非使用了eval|930319|基本上，Bash不能像这样使用。|930320|entityMap^0|0|0|0|0|0|0|2|0|L|N|5I|4|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|13|8|@$O|14|P|15|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|6|7|16|8|@$O|17|P|18|Q|R]|$O|19|P|1A|Q|R]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1B|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|X|$]]

You can't pass anything to a function other than strings. Process substitutions can sort of fake it. Bash tends to hold open the FIFO until a command its expanded to completes.

Here's a quick silly one

<pre><code>foldl() {
 echo $(($(&lt;/dev/stdin)$2))
} &lt; &lt;(tr '\n' "$1" &lt;$3)

# Sum 20 random ints from 0-999
foldl + 0 &lt;(while ((n=RANDOM%999,x++&lt;20)); do echo $n; done)
</code></pre>

Functions can be exported, but this isn't as interesting as it first appears. I find it's mainly useful for making debugging functions accessible to scripts or other programs that run scripts.

<pre><code>(
 id() {
 "$@"
 }

 export -f id
 exec bash -c 'echowrap() { echo "$1"; }; id echowrap hi'
)
</code></pre>

<code>id</code> still only gets a string that happens to be the name of a function (automatically imported from a serialization in the environment) and its args.

Pumbaa80's comment to another answer is also good (<code>eval $(declare -F "$1")</code>), but its mainly useful for arrays, not functions, since they're always global. If you were to run this within a function all it would do is redefine it, so there's no effect. It can't be used to create closures or partial functions or "function instances" dependent on whatever happens to be bound in the current scope. At best this can be used to store a function definition in a string which gets redefined elsewhere - but those functions also can only be hardcoded unless of course <code>eval</code> is used

Basically Bash can't be used like this.

blocks|key|930410|text|我认为没有人能完全回答这个问题。他没有问他是否可以按顺序回放弦乐。相反，问题的作者想知道他是否可以模拟函数指针行为。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|930411|有几个答案与我所做的非常相似，我想用另一个例子来扩展它。|930412|来自作者：|930413|function+x()+{
++echo+"Hello+world"
}

function+around()+{
++echo+"before"
++($1)+++++++++++++++++++<------+Only+change
++echo+"after"
}

around+x|code-block|syntax|javascript|930414|为了扩展它，我们将使用函数x+echo+"Hello+world:$1“来显示函数真正执行的时间。我们将传递一个字符串，它是函数“x”的名称：|930415|function+x()+{
++echo+"Hello+world:$1"
}

function+around()+{
++echo+"before"
++($1+HERE)+++++++++++++++++++<------+Only+change
++echo+"after"
}

around+x|930416|为了描述这一点，字符串"x“被传递给回显”之前“的函数()，调用函数x(通过变量$1，传递给周围的第一个参数)，传递参数"HERE"，最后回显之后。|930417|另外，这是将变量用作函数名的方法。变量实际保存的字符串是函数的名称和($variable+arg1+arg2+...)调用传递参数的函数。如下所示：|930418|function+x(){
++++echo+$3+$1+$2++++++<==+just+rearrange+the+order+of+passed+params
}

Z="x"++++++++#+or+just+Z=x

($Z++10+20+30)|930419|给出:+30+10+20，其中我们执行存储在变量Z中的名为"x“的函数，并传递参数10+20和30。|930420|在上面，我们通过将变量名赋给函数来引用函数，这样我们就可以使用变量来代替实际知道的函数名(这类似于在c中非常经典的函数指针情况下，用于泛化程序流，但预先选择将基于命令行参数进行的函数调用)。|930421|在bash中，这些不是函数指针，而是引用稍后使用的函数名称的变量。|930422|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|15|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|17|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|A|$]]|$1|S|3|T|5|H|7|1A|8|@]|9|@]|A|$I|J]]|$1|U|3|V|5|6|7|1B|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1D|8|@]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|11|$]]

I don't think anyone quite answered the question. He didn't ask if he could echo strings in order. Rather the author of the question wants to know if he can simulate function pointer behavior.

There are a couple of answers that are much like what I'd do, and I want to expand it with another example.

From the author:

<pre><code>function x() {
 echo "Hello world"
}

function around() {
 echo "before"
 ($1) &lt;------ Only change
 echo "after"
}

around x
</code></pre>

To expand this, we will have function x echo "Hello world:$1" to show when the function execution really occurs. We will pass a string that is the name of the function "x":

<pre><code>function x() {
 echo "Hello world:$1"
}

function around() {
 echo "before"
 ($1 HERE) &lt;------ Only change
 echo "after"
}

around x
</code></pre>

To describe this, the string "x" is passed to the function around() which echos "before", calls the function x (via the variable $1, the first parameter passed to around) passing the argument "HERE", finally echos after.

As another aside, this is the methodology to use variables as function names. The variables actually hold the string that is the name of the function and ($variable arg1 arg2 ...) calls the function passing the arguments. See below:

<pre><code>function x(){
 echo $3 $1 $2 &lt;== just rearrange the order of passed params
}

Z="x" # or just Z=x

($Z 10 20 30)
</code></pre>

gives: 30 10 20, where we executed the function named "x" stored in variable Z and passed parameters 10 20 and 30.

Above where we reference functions by assigning variable names to the functions so we can use the variable in place of actually knowing the function name (which is similar to what you might do in a very classic function pointer situation in c for generalizing program flow but pre-selecting the function calls you will be making based on command line arguments).

In bash these are not function pointers, but variables that refer to names of functions that you later use.

I need to pass a function as a parameter in Bash. For example, the following code:

<pre><code>function x() {
 echo "Hello world"
}

function around() {
 echo "before"
 eval $1
 echo "after"
}

around x
</code></pre>

Should output:

<pre><code>before
Hello world
after
</code></pre>

I know <code>eval</code> is not correct in that context but that's just an example :)

Any idea?

Bash: pass a function as parameter

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我需要在Bash中传递一个函数作为参数。例如，以下代码：function x() {  echo "Hello world"}function around() {  echo "before"  eval $1  echo "after"}around x应输出：beforeHello worldafter我知道ev...

问Bash:将函数作为参数传递
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Bash:将函数作为参数传递EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Bash:将函数作为参数传递
EN