blocks|key|1657469|text|基本上没有。我一直认为这是解析器的副作用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1657470|Eran+Galperin错误地认为这些函数是私有的。在outer()运行之前，它们是未声明的。它们也不是私人范围的；它们确实污染了全球范围，尽管延迟了。作为回调，外部回调仍然只能调用一次。我仍然看不出将它应用于数组有什么帮助，数组很可能会多次调用别名。|offset|length|style|CODE|1657471|我能找到的唯一“现实世界”的例子是this，它只能运行一次，而且可以重写得更干净。|1657472|我能想到的唯一用途是让模块调用[name]_include方法，该方法在全局空间中设置几个嵌套方法，并结合|1657473|if+(!function_exists+('somefunc'))+{
++function+somefunc()+{+}
}|code-block|syntax|javascript|1657474|检查。|1657475|PHP的OOP显然是一个更好的选择:)|1657476|entityMap|0|LINK|mutability|MUTABLE|url|http://www.java2s.com/Code/Php/Functions/Nestedfunction.htm^0|0|S|7|0|H|4|0|0|F|E|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|@$D|14|E|15|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|16|8|@]|9|@$D|17|E|18|1|19]]|A|$]]|$1|J|3|K|5|6|7|1A|8|@$D|1B|E|1C|F|G]]|9|@]|A|$]]|$1|L|3|M|5|N|7|1D|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|1E|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1F|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]]]

There is none basically. I've always treated this as a side effect of the parser.
Eran Galperin is mistaken in thinking that these functions are somehow private. They are simply undeclared until <code>outer()</code> is run. They are also not privately scoped; they do pollute the global scope, albeit delayed. And as a callback, the outer callback could still only be called once. I still don't see how it's helpful to apply it on an array, which very likely calls the alias more than once.
The only 'real world' example I could dig up is <a href="http://www.java2s.com/Code/Php/Functions/Nestedfunction.htm" rel="nofollow noreferrer">this</a>, which can only run once, and could be rewritten cleaner, IMO.
The only use I can think of, is for modules to call a <code>[name]_include</code> method, which sets several nested methods in the global space, combined with
<pre><code>if (!function_exists ('somefunc')) {
 function somefunc() { }
}
</code></pre>
checks.
PHP's OOP would obviously be a better choice :)

blocks|key|1442844|text|在函数中定义的函数我看不出有多大用处，但有条件地定义的函数我可以。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1442845|if+($language+==+'en')+{
++function+cmp($a,+$b)+{+/*+sort+by+English+word+order+*/+}
}+else+if+($language+==+'de')+{
++function+cmp($a,+$b)+{+/*+sort+by+German+word+order;+yes+it's+different+*/+}
}+//+etc|code-block|syntax|javascript|1442846|然后你的代码需要做的就是在像usort()调用这样的事情中使用'cmp‘函数，这样你就不会把语言检查弄得到处都是。现在我还没有做到这一点，但我可以看到这样做的理由。|1442847|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|$]]

Functions defined within functions I can't see much use for but conditionally defined functions I can. For example:

<pre><code>if ($language == 'en') {
 function cmp($a, $b) { /* sort by English word order */ }
} else if ($language == 'de') {
 function cmp($a, $b) { /* sort by German word order; yes it's different */ }
} // etc
</code></pre>

And then all your code needs to do is use the 'cmp' function in things like usort() calls so you don't litter language checks all over your code. Now I haven't done this but I can see arguments for doing it.

blocks|key|1657609|text|如果你使用的是PHP+5.3，你可以通过一个匿名函数获得更多类似JavaScript的行为：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1657610|<?php
function+outer()+{
++++$inner=function()+{
++++++++echo+"test\n";
++++};

++++$inner();
}

outer();
outer();

inner();+//PHP+Fatal+error:++Call+to+undefined+function+inner()
$inner();+//PHP+Fatal+error:++Function+name+must+be+a+string
?>|code-block|syntax|javascript|1657611|输出：|1657612|test
test|1657613|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If you are using PHP 5.3 you can get more JavaScript-like behaviour with an anonymous function:
<pre><code>&lt;?php
function outer() {
 $inner=function() {
 echo &quot;test\n&quot;;
 };

 $inner();
}

outer();
outer();

inner(); //PHP Fatal error: Call to undefined function inner()
$inner(); //PHP Fatal error: Function name must be a string
?&gt;
</code></pre>
Output:
<pre><code>test
test
</code></pre>

blocks|key|1442964|text|嵌套函数在Memoization中很有用(缓存函数结果以提高性能)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1442965|<?php
function+foo($arg1,+$arg2)+{
++++$cacheKey+=+"foo($arg1,+$arg2)";
++++if+(!+getCachedValue($cacheKey))+{
++++++++function+_foo($arg1,+$arg2)+{
++++++++++++//+whatever
++++++++++++return+$result;
++++++++}
++++++++$result+=+_foo($arg1,+$arg2);
++++++++setCachedValue($cacheKey,+$result);
++++}
++++return+getCachedValue($cacheKey);
}
?>|code-block|syntax|javascript|1442966|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Nested functions are useful in Memoization (caching function results to improve performance).

<pre><code>&lt;?php
function foo($arg1, $arg2) {
 $cacheKey = "foo($arg1, $arg2)";
 if (! getCachedValue($cacheKey)) {
 function _foo($arg1, $arg2) {
 // whatever
 return $result;
 }
 $result = _foo($arg1, $arg2);
 setCachedValue($cacheKey, $result);
 }
 return getCachedValue($cacheKey);
}
?&gt;
</code></pre>

blocks|key|1443010|text|我所有的php都是面向对象的，但是我确实看到了嵌套函数的用处，特别是当你的函数是递归的并且不一定是对象的时候。也就是说，它不会在它所嵌套的函数之外被调用，但它是递归的，因此需要成为一个函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1443011|创建一个新方法来明确使用单个其他方法几乎没有什么意义。对我来说，这是笨拙的代码和排序--这不是面向对象的要点。如果你永远不会在其他地方调用这个函数，那就嵌套它。|1443012|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|$]]

All of my php is OO, but I do see a use for nested functions, particularly when your function is recursive and not necessarily an object. That is to say, it does not get called outside of the function it is nested in, but is recursive and subsequently needs to be a function.

There's little point in making a new method for the express use of a single other method. To me that's clumsy code and sort-of not the point of OO. If you're never going to call that function anywhere else, nest it.

blocks|key|1443100|text|在webservice调用中，我们发现它的开销(内存和速度)要低得多，动态地包括以嵌套的方式，单个函数超过了充满上千个函数的库。典型的调用堆栈可能在5-10个调用深度之间，只需要动态链接12个1-2kb的文件要比包含兆字节要好。这是通过创建一个小的util函数来完成的。所包含的函数将嵌套在调用堆栈上方的函数中。考虑一下这一点，这与充满100个函数的类形成了对比，这些函数并不是每个webservice调用时都需要的，但也可以使用php内置的延迟加载功能。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1443101|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

In webservice calling we found it a much lower overhead (memory and speed) dynamically including in a nested fashion, individual functions over libraries full of 1000s of functions. The typical call stack might be between 5-10 calls deep only requiring linking a dozen 1-2kb files dynamically was better than including megabytes. This was done just by creating a small util function wrapping requires. The included functions become nested within the functions above the call stack. Consider it in contrast to classes full of 100s of functions that weren't required upon every webservice call but could also have used the inbuilt lazy loading features of php.

blocks|key|1657787|text|如果希望嵌套函数使用在父函数中声明的变量，则嵌套函数非常有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1657788|<?php
ParentFunc();
function+ParentFunc()
{
++$var+=+5;
++function+NestedFunc()
++{
++++global+$var;
++++$var+=+$var+%2B+5;
++++return+$var;
++};
++echo+NestedFunc()." ";
++echo+NestedFunc()." ";
++echo+NestedFunc()." ";
}
?>|code-block|syntax|javascript|1657789|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Nested functions are useful if you want the nested function to utilize a variable that was declared within the parent function.

<pre><code>&lt;?php
ParentFunc();
function ParentFunc()
{
 $var = 5;
 function NestedFunc()
 {
 global $var;
 $var = $var + 5;
 return $var;
 };
 echo NestedFunc()."&lt;br&gt;";
 echo NestedFunc()."&lt;br&gt;";
 echo NestedFunc()."&lt;br&gt;";
}
?&gt;
</code></pre>

blocks|key|1443222|text|我知道这是一个古老的帖子，但是当我只在本地需要功能时，我使用嵌套函数来给递归调用提供一种整洁的方法-例如，用于构建分层对象等(显然你需要注意父函数只被调用一次)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1443223|function+main()+{
++++//+Some+code

++++function+addChildren+($parentVar)+{
++++++++//+Do+something
++++++++if+($needsGrandChildren)+addChildren+($childVar);
++++}
++++addChildren+($mainVar);+//+This+call+must+be+below+nested+func

++++//+Some+more+code
}|code-block|syntax|javascript|1443224|例如，与JS相比，php中需要注意的一点是，对嵌套函数的调用需要在函数声明之后(即在下面)进行(与JS相比，其中函数调用可以在父函数内的任何位置|1443225|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|$]]

I know this is an old post but fwiw I use nested functions to give a neat and tidy approach to a recursive call when I only need the functionality locally - e.g. for building hierarchical objects etc (obviously you need to be careful the parent function is only called once):

<pre><code>function main() {
 // Some code

 function addChildren ($parentVar) {
 // Do something
 if ($needsGrandChildren) addChildren ($childVar);
 }
 addChildren ($mainVar); // This call must be below nested func

 // Some more code
}
</code></pre>

A point of note in php compared with JS for instance is that the call to the nested function needs to be made after, i.e. below, the function declaration (compared with JS where the function call can be anywhere within the parent function

blocks|key|1443283|text|只有在主要的、更明确的函数中执行一个小的递归函数很有用时，我才真正使用过这个特性，但我不想将它移到不同的文件中，因为它是主进程行为的基础。我意识到还有其他的“最佳实践”可以做到这一点，但我想确保我的开发人员每次查看我的解析器时都能看到这个函数，这可能是他们无论如何都应该修改的……|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1443284|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I have only really used this characteristic when it was useful to execute a small recursive function inside a primary, more categorical function, but didn't want to move it to a different file because it was fundamental to the behavior of a primary process. I realize there are other "best practice" ways of doing this, but I want to make sure my devs see that function every time they look at my parser, it's likely what they should modify anyway...

blocks|key|1443360|text|对于那些认为嵌套函数没有实际用法的人。是的，它们有用武之地，这是一个例子。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1443361|假设我有一个名为my_file.php的文件，该文件用于从获取ajax结果。但是，如果有时您不希望通过ajax获得结果，但又希望在同一页面中包含两次而没有冲突，该怎么办呢？|1443362|假设ajax文件为my_file.php：|1443363|<?php
//+my_file.php+used+for+ajax

$ajax_json_in+=+10;+

function+calculations($a,+$b)
{+++$result+=+$a+%2B+$b;
++++return+$result;
}

$new_result+=+$ajax_json_in+*+calculations(1,+2);

$ajax_json_out+=++$new_result;+
+++
?>|code-block|syntax|javascript|1443364|下面的示例包含上面的文件两次，没有冲突。您可能不希望ajax调用它，因为在某些情况下，您需要将它直接包含在HTML中。|1443365|<?php
//+include+the+above+file+my_file.php+instead+of+ajaxing+it

function+result1+
{
++++$ajax_json_in+=+20;+
++++include("my_file.php");
++++return+$ajax_json_out;+
}


function+result2+
{
++++$ajax_json_in+=+20;+
++++include("my_file.php");
++++return+$ajax_json_out;
}

?>|1443366|包含该文件将使该文件的函数嵌套。该文件同时用于ajax调用和内联包含！|1443367|因此，嵌套函数在现实生活中是有用处的。|1443368|祝您今天愉快。|1443369|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|11|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

For those that suggest that there is no practical use of nested functions. Yes they have use and this is an example.
Imagine that I have a file called my_file.php which is used to get an ajax result out of. But what if there are times that you don't want to get the result through ajax but you want to include it twice in the same page without conflicts?
Lets say ajax file my_file.php :
<pre><code>&lt;?php
// my_file.php used for ajax

$ajax_json_in = 10; 

function calculations($a, $b)
{ $result = $a + $b;
 return $result;
}

$new_result = $ajax_json_in * calculations(1, 2);

$ajax_json_out = $new_result; 
 
?&gt;
</code></pre>
Below example includes the above file twice without conflict. You may not want to ajax call it, because there are cases that you need to include it straight in the HTML.
<pre><code>&lt;?php
// include the above file my_file.php instead of ajaxing it

function result1 
{
 $ajax_json_in = 20; 
 include(&quot;my_file.php&quot;);
 return $ajax_json_out; 
}


function result2 
{
 $ajax_json_in = 20; 
 include(&quot;my_file.php&quot;);
 return $ajax_json_out;
}

?&gt;
</code></pre>
Including the file makes the file's functions nested. The file is used both for ajax calls and inline includes !!!
So there is use in real life of nested functions.
Have a nice day.

In JavaScript nested functions are very useful: closures, private methods and what have you..

What are nested PHP functions for? Does anyone use them and what for?

Here's a small investigation I did

<pre><code>&lt;?php
function outer( $msg ) {
 function inner( $msg ) {
 echo 'inner: '.$msg.' ';
 }
 echo 'outer: '.$msg.' ';
 inner( $msg );
}

inner( 'test1' ); // Fatal error: Call to undefined function inner()
outer( 'test2' ); // outer: test2 inner: test2
inner( 'test3' ); // inner: test3
outer( 'test4' ); // Fatal error: Cannot redeclare inner()
</code></pre>

What are PHP nested functions for?

在JavaScript中，嵌套函数非常有用:闭包、私有方法等等。嵌套的PHP函数是用来做什么的？有没有人在用它们?有什么用？这是我做的一个小调查<?phpfunction outer( $msg ) { function inner( $msg ) { echo 'inner: '.$msg.' '...

问PHP嵌套函数是做什么用的？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问PHP嵌套函数是做什么用的？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问PHP嵌套函数是做什么用的？
EN