为何编译器与PC先执行内部函数再向外？嵌套函数调用顺序问询

Great question—this is one of those fundamental language design choices that makes total sense once you break down what's actually happening under the hood. Let's walk through it step by step.

The Core Reason: Functions Need Valid Arguments to Run #

At its heart, every function call requires fully evaluated arguments to do its job. Let's take your example:

return something1(something2(something3));

• something1 can't execute until it receives the value that something2 returns. It doesn't know what to operate on otherwise!
• something2 has the same problem: it needs the output of something3 as its input before it can run.
• That leaves something3 as the only function that doesn't depend on another call's result—it can run immediately, produce a value, and pass it up the chain.

Think of it like a real-world task: say you want to make a sandwich with toasted bread that's been buttered. You can't assemble the sandwich first (something1) if you don't have the toasted buttered bread. You can't toast the bread (something2) until you've buttered it. And you can't butter it (something3) until you have the bread. You have to start from the innermost step and work your way out.

What If We Did It The Other Way Around? #

If the language tried to run something1 first, it would be handed an unevaluated something2(something3) instead of a concrete value. Functions don't know how to process "another function call" as input—they need actual data (numbers, strings, objects, etc.). It's like trying to start a car before you've put gas in it: the action is meaningless without the required inputs.

A Quick Side Note: Lazy Evaluation Exceptions #

Most mainstream languages (C, Java, Python, JavaScript, etc.) use eager evaluation—meaning arguments are evaluated before the function runs. There are some functional languages (like Haskell) that use lazy evaluation, where arguments are only evaluated when the function actually needs them. But even in those cases, if something1 ends up needing the argument from something2, it will trigger something2 to evaluate its argument from something3—so the innermost call still runs first when required.

内容的提问来源于stack exchange，提问作者Tony.M