blocks|key|823762|text|表达式可以通过求值来获得值，而语句不返回值(它们的类型为void)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|823763|当然，函数调用表达式也可以被认为是语句，但是除非执行环境有一个特殊的内置变量来保存返回的值，否则就无法检索它。|823764|面向语句的语言要求所有的过程都是语句的列表.面向表达式的语言，可能都是函数式语言，是表达式的列表，或者在LISP的情况下，表示表达式列表的一个长的S-表达式。|823765|虽然这两种类型都可以组合，但只要类型匹配，大多数表达式都可以任意组合。每种类型的语句都有自己的方法来组成其他语句，如果它们能够做到这一点的话。Foreach和if语句要么需要一个状态，要么所有的从属语句一个接一个地放在一个语句块中，除非子语句允许它们自己的子语句。|823766|语句也可以包括表达式，其中表达式实际上并不包括任何语句。但是，一个例外是lambda表达式，它表示一个函数，因此它可以包含任何函数可以冻结的东西，除非语言只允许有限的lambda，比如Python的单表达式lambdas。|823767|在基于表达式的语言中，您所需要的只是函数的一个表达式，因为所有控件结构都返回一个值(其中很多返回零)。不需要返回语句，因为函数中的最后一个求值表达式是返回值。|823768|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Q|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

Expressions can be evaluated to get a value, whereas statements don't return a value (they're of type void).

Function call expressions can also be considered statements of course, but unless the execution environment has a special built-in variable to hold the returned value, there is no way to retrieve it.

Statement-oriented languages require all procedures to be a list of statements. Expression-oriented languages, which is probably all functional languages, are lists of expressions, or in tha case of LISP, one long S-expression that represents a list of expressions.

Although both types can be composed, most expressions can be composed arbitrarily as long as the types match up. Each type of statement has its own way of composing other statements, if they can do that all. Foreach and if statements require either a single statment or that all subordinate statements go in a statement block, one after another, unless the substatements allow for thier own substatements. 

Statements can also include expressions, where an expression doesn't really include any statements. One exception, though, would be a lambda expression, which represents a function, and so can include anything a function can iclude unless the language only allows for limited lambdas, like Python's single-expression lambdas. 

In an expression-based language, all you need is a single expression for a function since all control structures return a value (a lot of them return NIL). There's no need for a return statement since the last-evaluated expression in the function is the return value.

blocks|key|113779|text|表达式是返回值的东西，而语句不返回值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|113780|例如：|113781|1+%2B+2+*+4+*+foo.bar()+++++//Expression
foo.voidFunc(1);++++++++++//Statement|code-block|syntax|javascript|113782|两者之间的主要问题是，您可以将表达式链接在一起，而语句不能被链接。|113783|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

An expression is something that returns a value, whereas a statement does not.

For examples:

<pre><code>1 + 2 * 4 * foo.bar() //Expression
foo.voidFunc(1); //Statement
</code></pre>

The Big Deal between the two is that you can chain expressions together, whereas statements cannot be chained.

blocks|key|113817|text|简单地说:表达式的计算结果是值，而语句则不是。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|113818|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|$]]

Simply: an expression evaluates to a value, a statement doesn't.

blocks|key|819749|text|您可以在维基百科上找到这一点，但是表达式被求值为某些值，而语句没有计算值。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|819750|因此，表达式可以在语句中使用，但不能反过来使用。|819751|请注意，有些语言(如Lisp，我相信Ruby和其他许多语言)没有区分语句和表达式.在这种语言中，一切都是表达式，可以与其他表达式链接在一起。|819752|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Statement_%2528programming%2529^0|4|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

You can find this on <a href="http://en.wikipedia.org/wiki/Statement_%28programming%29" rel="noreferrer">wikipedia</a>, but expressions are evaluated to some value, while statements have no evaluated value.

Thus, expressions can be used in statements, but not the other way around.

Note that some languages (such as Lisp, and I believe Ruby, and many others) do not differentiate statement vs expression... in such languages, everything is an expression and can be chained with other expressions.

blocks|key|1113198|text|表达式:计算值为值的。示例:+1%2B2/x|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1113199|语句:执行某项任务的代码行。示例:+GOTO+100|1113200|在最早的通用编程语言(如FORTRAN+)中，区别是非常清楚的.在FORTRAN中，语句是一个执行单位，是您所做的事情。它没有被称为“行”的唯一原因是因为它有时跨越多行。一个表情本身不能做任何事情..。你必须把它赋值给一个变量。|1113201|1+%2B+2+/+X|code-block|syntax|javascript|1113202|是FORTRAN中的一个错误，因为它什么都不做。你必须用这句话做点什么：|1113203|X+=+1+%2B+2+/+X|1113204|FORTRAN没有我们今天所知道的语法--这个想法是和Backus+(BNF)一起发明的，作为Algol-60定义的一部分。在这一点上，语义上的区别(“有值”和“做某事”)被写入语法:一种短语是表达式，另一种是语句，解析器可以将它们区分开来。|1113205|后来语言的设计者模糊了两者之间的区别:他们允许句法表达式去做事情，他们允许有价值的句法语句。现存最早的流行语言例子是C。C的设计者意识到，如果允许对表达式进行评估并丢弃结果，就不会造成任何伤害。在C中，每一个句法表达式都可以通过在结尾加上分号来生成语句：|1113206|1+%2B+2+/+x;|1113207|这是一个完全合法的声明，尽管绝对不会发生任何事情。类似地，在C中，表达式可能有副作用--它可以改变一些东西。|1113208|1+%2B+2+/+callfunc(12);|1113209|因为callfunc可能只是做一些有用的事情。|CODE|1113210|一旦允许任何表达式成为语句，则最好允许表达式中的赋值运算符(=)。这就是为什么C允许你做这样的事情|1113211|callfunc(x+=+2);|1113212|这将计算表达式x=2(将值2赋值为x)，然后将该表达式(+2)传递给函数callfunc。|1113213|表达式和语句的模糊出现在所有C-派生类(C、C%2B%2B、C#和Java)中，它们仍然有一些语句(如while)，但允许几乎任何表达式作为语句使用(在C#专用赋值、调用、增量和递减表达式中，可以使用它们作为语句；参见斯科特·维斯涅夫斯基的回答)。|1113214|有两个“句法类别”(这是语句和表达式的类型的技术名称)可能会导致重复工作。例如，C有两种形式的条件，语句形式|1113215|if+(E)+S1;+else+S2;|1113216|以及表达形式|1113217|E+?+E1+:+E2|1113218|有时候，人们想要的是不存在的复制:例如，在标准C中，只有一条语句可以声明一个新的局部变量--但是这种能力非常有用，以至于GNU+C编译器提供了一个GNU扩展，它使表达式也能够声明局部变量。|1113219|其他语言的设计者不喜欢这种重复，他们很早就看到如果表达式有副作用和值，那么语句和表达式之间的句法区别就没有那么有用了，所以他们就把它去掉了。Haskell、Icon、Lisp和ML都是没有语法语句的语言--它们只有表达式。即使是类的结构化循环和条件形式也被认为是表达式，它们有值--但不是很有趣的值。|1113220|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/20771/8554766^0|0|A|0|0|D|0|0|0|0|0|0|0|0|0|0|2|8|0|0|0|10|8|0|1B|5|2X|D|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1X|8|@$9|1Y|A|1Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|20|8|@$9|21|A|22|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|23|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|24|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|25|8|@]|D|@]|E|$]]|$1|Q|3|R|5|L|7|26|8|@]|D|@]|E|$M|N]]|$1|S|3|T|5|6|7|27|8|@]|D|@]|E|$]]|$1|U|3|V|5|6|7|28|8|@]|D|@]|E|$]]|$1|W|3|X|5|L|7|29|8|@]|D|@]|E|$M|N]]|$1|Y|3|Z|5|6|7|2A|8|@]|D|@]|E|$]]|$1|10|3|11|5|L|7|2B|8|@]|D|@]|E|$M|N]]|$1|12|3|13|5|6|7|2C|8|@$9|2D|A|2E|B|14]]|D|@]|E|$]]|$1|15|3|16|5|6|7|2F|8|@]|D|@]|E|$]]|$1|17|3|18|5|L|7|2G|8|@]|D|@]|E|$M|N]]|$1|19|3|1A|5|6|7|2H|8|@$9|2I|A|2J|B|14]]|D|@]|E|$]]|$1|1B|3|1C|5|6|7|2K|8|@$9|2L|A|2M|B|14]]|D|@$9|2N|A|2O|1|2P]]|E|$]]|$1|1D|3|1E|5|6|7|2Q|8|@]|D|@]|E|$]]|$1|1F|3|1G|5|L|7|2R|8|@]|D|@]|E|$M|N]]|$1|1H|3|1I|5|6|7|2S|8|@]|D|@]|E|$]]|$1|1J|3|1K|5|L|7|2T|8|@]|D|@]|E|$M|N]]|$1|1L|3|1M|5|6|7|2U|8|@]|D|@]|E|$]]|$1|1N|3|1O|5|6|7|2V|8|@]|D|@]|E|$]]|$1|1P|3|-4|5|6|7|2W|8|@]|D|@]|E|$]]]|1Q|$1R|$5|1S|1T|1U|E|$1V|1W]]]]

Expression: Something which evaluates to a value. Example: 1+2/x 
Statement: A line of code which does something. Example: GOTO 100

In the earliest general-purpose programming languages, like FORTRAN, the distinction was crystal-clear. In FORTRAN, a statement was one unit of execution, a thing that you did. The only reason it wasn't called a "line" was because sometimes it spanned multiple lines. An expression on its own couldn't do anything... you had to assign it to a variable.

<pre><code>1 + 2 / X
</code></pre>

is an error in FORTRAN, because it doesn't do anything. You had to do something with that expression:

<pre><code>X = 1 + 2 / X
</code></pre>

FORTRAN didn't have a grammar as we know it today&mdash;that idea was invented, along with Backus-Naur Form (BNF), as part of the definition of Algol-60. At that point the semantic distinction ("have a value" versus "do something") was enshrined in syntax: one kind of phrase was an expression, and another was a statement, and the parser could tell them apart.

Designers of later languages blurred the distinction: they allowed syntactic expressions to do things, and they allowed syntactic statements that had values.
The earliest popular language example that still survives is C. The designers of C realized that no harm was done if you were allowed to evaluate an expression and throw away the result. In C, every syntactic expression can be a made into a statement just by tacking a semicolon along the end:

<pre><code>1 + 2 / x;
</code></pre>

is a totally legit statement even though absolutely nothing will happen. Similarly, in C, an expression can have side-effects&mdash;it can change something.

<pre><code>1 + 2 / callfunc(12);
</code></pre>

because <code>callfunc</code> might just do something useful.

Once you allow any expression to be a statement, you might as well allow the assignment operator (=) inside expressions. That's why C lets you do things like

<pre><code>callfunc(x = 2);
</code></pre>

This evaluates the expression x = 2 (assigning the value of 2 to x) and then passes that (the 2) to the function <code>callfunc</code>.

This blurring of expressions and statements occurs in all the C-derivatives (C, C++, C#, and Java), which still have some statements (like <code>while</code>) but which allow almost any expression to be used as a statement (in C# only assignment, call, increment, and decrement expressions may be used as statements; see <a href="https://stackoverflow.com/a/20771/8554766">Scott Wisniewski's answer</a>).

Having two "syntactic categories" (which is the technical name for the sort of thing statements and expressions are) can lead to duplication of effort. For example, C has two forms of conditional, the statement form

<pre><code>if (E) S1; else S2;
</code></pre>

and the expression form

<pre><code>E ? E1 : E2
</code></pre>

And sometimes people want duplication that isn't there: in standard C, for example, only a statement can declare a new local variable&mdash;but this ability is useful enough that the 
GNU C compiler provides a GNU extension that enables an expression to declare a local variable as well.

Designers of other languages didn't like this kind of duplication, and they saw early on that if expressions can have side effects as well as values, then the syntactic distinction between statements and expressions is not all that useful&mdash;so they got rid of it. Haskell, Icon, Lisp, and ML are all languages that don't have syntactic statements&mdash;they only have expressions. Even the class structured looping and conditional forms are considered expressions, and they have values&mdash;but not very interesting ones.

blocks|key|1113253|text|表达式是产生值的任何东西:2%2B2|type|unordered-list-item|depth|inlineStyleRanges|entityRanges|data|1113254|语句是程序执行的基本“块”之一。|1113255|注意，在C中，"=“实际上是一个操作符，它做两件事：|unstyled|1113256|返回右手子表达式的值。|1113257|将右手子表达式的值复制到左侧的变量中。|1113258|这是ANSI+C语法的摘录。你可以看到C没有很多不同的语句..。程序中的大多数语句都是表达式语句，即末尾带有分号的表达式。|1113259|statement
++++:+labeled_statement
++++%7C+compound_statement
++++%7C+expression_statement
++++%7C+selection_statement
++++%7C+iteration_statement
++++%7C+jump_statement
++++;

expression_statement
++++:+';'
++++%7C+expression+';'
++++;|code-block|syntax|javascript|1113260|http://www.lysator.liu.se/c/ANSI-C-grammar-y.html|offset|length|1113261|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|0|0|0|0|0|1D|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|F|7|14|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|15|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|16|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|17|8|@]|9|@]|A|$]]|$1|M|3|N|5|O|7|18|8|@]|9|@]|A|$P|Q]]|$1|R|3|S|5|F|7|19|8|@]|9|@$T|1A|U|1B|1|1C]]|A|$]]|$1|V|3|-4|5|F|7|1D|8|@]|9|@]|A|$]]]|W|$X|$5|Y|Z|10|A|$11|S]]]]

<ul>
<li>an expression is anything that yields a value: 2 + 2</li>
<li>a statement is one of the basic "blocks" of program execution.</li>
</ul>

Note that in C, "=" is actually an operator, which does two things:

<ul>
<li>returns the value of the right hand subexpression.</li>
<li>copies the value of the right hand subexpression into the variable on the left hand side.</li>
</ul>

Here's an extract from the ANSI C grammar. You can see that C doesn't have many different kinds of statements... the majority of statements in a program are expression statements, i.e. an expression with a semicolon at the end.

<pre><code>statement
 : labeled_statement
 | compound_statement
 | expression_statement
 | selection_statement
 | iteration_statement
 | jump_statement
 ;

expression_statement
 : ';'
 | expression ';'
 ;
</code></pre>

<a href="http://www.lysator.liu.se/c/ANSI-C-grammar-y.html" rel="noreferrer">http://www.lysator.liu.se/c/ANSI-C-grammar-y.html</a>

blocks|key|823893|text|关于基于表达式的语言的一些事情：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|823894|最重要的是:一切都会返回一个值。|823895|用于分隔代码块和表达式的花括号和大括号之间没有区别，因为所有东西都是表达式。但这并不妨碍词法范围的界定:例如，可以为包含其定义的表达式和包含在其中的所有语句定义局部变量。|823896|在基于表达式的语言中，一切都返回值。这在一开始可能有点奇怪--+(FOR+i+=+1+TO+10+DO+(print+i))返回什么？|offset|length|style|CODE|823897|一些简单的例子：|823898|(1)返回1|unordered-list-item|823899|(1+%2B+1)返回2|823900|(1+==+1)返回TRUE|823901|(1+==+2)返回FALSE|823902|(IF+1+==+1+THEN+10+ELSE+5)返回10|823903|(IF+1+==+2+THEN+10+ELSE+5)返回5|823904|还有几个更复杂的例子：|823905|有些东西，例如一些函数调用，实际上没有一个有意义的值返回(只产生副作用的东西？)。调用OpenADoor(),+FlushTheToilet()或TwiddleYourThumbs()将返回某种平凡的值，如OK、Done或Success。|823906|当在一个较大的表达式中计算多个未链接表达式时，在大表达式中计算的最后一件事的值将变成大表达式的值。以(FOR+i+=+1+TO+10+DO+(print+i))为例，for循环的值为"+10+"，它将使(print+i)表达式计算10次，每次将i作为字符串返回。最后一次通过返回10，我们的最终答案|823907|要充分利用一种基于表达式的语言，通常需要稍微改变思维方式，因为所有的东西都是表达式，这使得“内联”很多事情成为可能。|823908|作为一个简单的例子：|823909|如果MyString+==“你好，世界！”那麽其他10+)+DO+(+LotsOfCode+)|blockquote|823910|是非基于表达式的完全有效的替换。|823911|如果MyString+==“你好，世界！”然后TempVar+=+10，TempVar+=5，i=1，TO+TempVar+DO+(+LotsOfCode+)|823912|在某些情况下，基于表达式的代码所允许的布局对我来说更加自然。|823913|当然，这会导致疯狂。作为基于表达式的脚本语言(称为MaxScript+)的业余爱好项目的一部分，我成功地提出了这个怪物行。|823914|IF+FindSectionStart+"rigidifiers"+!=+0+THEN+FOR+i+=+1+TO+(local+rigidifier_array+=+(FOR+i+=+(local+NodeStart+=+FindsectionStart+"rigidifiers"+%2B+1)+TO+(FindSectionEnd(NodeStart)+-+1)+collect+full_array[i])).count+DO
(
++++LotsOfCode
)|code-block|syntax|javascript|823915|entityMap^0|0|0|0|W|U|0|0|0|3|5|1|0|0|7|9|1|0|0|8|A|4|0|0|8|A|5|0|0|Q|S|2|0|0|Q|S|1|0|0|17|T|21|J|0|1E|U|2T|9|3V|2|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1U|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1V|8|@$H|1W|I|1X|J|K]]|9|@]|A|$]]|$1|L|3|M|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|N|3|O|5|P|7|1Z|8|@$H|20|I|21|J|K]|$H|22|I|23|J|K]]|9|@]|A|$]]|$1|Q|3|R|5|P|7|24|8|@$H|25|I|26|J|K]|$H|27|I|28|J|K]]|9|@]|A|$]]|$1|S|3|T|5|P|7|29|8|@$H|2A|I|2B|J|K]|$H|2C|I|2D|J|K]]|9|@]|A|$]]|$1|U|3|V|5|P|7|2E|8|@$H|2F|I|2G|J|K]|$H|2H|I|2I|J|K]]|9|@]|A|$]]|$1|W|3|X|5|P|7|2J|8|@$H|2K|I|2L|J|K]|$H|2M|I|2N|J|K]]|9|@]|A|$]]|$1|Y|3|Z|5|P|7|2O|8|@$H|2P|I|2Q|J|K]|$H|2R|I|2S|J|K]]|9|@]|A|$]]|$1|10|3|11|5|6|7|2T|8|@]|9|@]|A|$]]|$1|12|3|13|5|P|7|2U|8|@$H|2V|I|2W|J|K]|$H|2X|I|2Y|J|K]]|9|@]|A|$]]|$1|14|3|15|5|P|7|2Z|8|@$H|30|I|31|J|K]|$H|32|I|33|J|K]|$H|34|I|35|J|K]]|9|@]|A|$]]|$1|16|3|17|5|6|7|36|8|@]|9|@]|A|$]]|$1|18|3|19|5|6|7|37|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|1C|7|38|8|@]|9|@]|A|$]]|$1|1D|3|1E|5|6|7|39|8|@]|9|@]|A|$]]|$1|1F|3|1G|5|1C|7|3A|8|@]|9|@]|A|$]]|$1|1H|3|1I|5|6|7|3B|8|@]|9|@]|A|$]]|$1|1J|3|1K|5|6|7|3C|8|@]|9|@]|A|$]]|$1|1L|3|1M|5|1N|7|3D|8|@]|9|@]|A|$1O|1P]]|$1|1Q|3|-4|5|6|7|3E|8|@]|9|@]|A|$]]]|1R|$]]

Some things about expression based languages:

<hr>

Most important: Everything returns an value

<hr>

There is no difference between curly brackets and braces for delimiting code blocks and expressions, since everything is an expression. This doesn't prevent lexical scoping though: A local variable could be defined for the expression in which its definition is contained and all statements contained within that, for example.

<hr>

In an expression based language, everything returns a value. This can be a bit strange at first -- What does <code>(FOR i = 1 TO 10 DO (print i))</code> return? 

Some simple examples:

<ul>
<li><code>(1)</code> returns <code>1</code></li>
<li><code>(1 + 1)</code> returns <code>2</code></li>
<li><code>(1 == 1)</code> returns <code>TRUE</code></li>
<li><code>(1 == 2)</code> returns <code>FALSE</code></li>
<li><code>(IF 1 == 1 THEN 10 ELSE 5)</code> returns <code>10</code></li>
<li><code>(IF 1 == 2 THEN 10 ELSE 5)</code> returns <code>5</code></li>
</ul>

A couple more complex examples:

<ul>
<li>Some things, such as some function calls, don't really have a meaningful value to return (Things that only produce side effects?). Calling <code>OpenADoor(), FlushTheToilet()</code> or <code>TwiddleYourThumbs()</code> will return some sort of mundane value, such as OK, Done, or Success.</li>
<li>When multiple unlinked expressions are evaluated within one larger expression, the value of the last thing evaluated in the large expression becomes the value of the large expression. To take the example of <code>(FOR i = 1 TO 10 DO (print i))</code>, the value of the for loop is "10", it causes the <code>(print i)</code> expression to be evaluated 10 times, each time returning i as a string. The final time through returns <code>10</code>, our final answer</li>
</ul>

<hr>

It often requires a slight change of mindset to get the most out of an expression based language, since the fact that everything is an expression makes it possible to 'inline' a lot of things

As a quick example:

<blockquote>
<pre><code> FOR i = 1 to (IF MyString == "Hello, World!" THEN 10 ELSE 5) DO
 (
 LotsOfCode
 )
</code></pre>
</blockquote>

is a perfectly valid replacement for the non expression-based

<blockquote>
<pre><code>IF MyString == "Hello, World!" THEN TempVar = 10 ELSE TempVar = 5 
FOR i = 1 TO TempVar DO
( 
 LotsOfCode 
)
</code></pre>
</blockquote>

In some cases, the layout that expression-based code permits feels much more natural to me

Of course, this can lead to madness. As part of a hobby project in an expression-based scripting language called MaxScript, I managed to come up with this monster line

<pre><code>IF FindSectionStart "rigidifiers" != 0 THEN FOR i = 1 TO (local rigidifier_array = (FOR i = (local NodeStart = FindsectionStart "rigidifiers" + 1) TO (FindSectionEnd(NodeStart) - 1) collect full_array[i])).count DO
(
 LotsOfCode
)
</code></pre>

blocks|key|1113354|text|语句是表达式的特例，它具有void类型。语言区别对待陈述的倾向往往会引起问题，如果适当地加以概括，情况会更好。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1113355|例如，在C#中，我们有非常有用的泛型委托Func<T1,+T2,+T3,+TResult>重载集。但是，我们也必须有一个相应的Action<T1,+T2,+T3>集，为了处理这个不幸的分岔，通用的高阶规划必须不断重复。|1113356|简单示例--在调用另一个函数之前检查引用是否为空的函数：|1113357|TResult+IfNotNull<TValue,+TResult>(TValue+value,+Func<TValue,+TResult>+func)
++++++++++++++++++where+TValue+:+class
{
++++return+(value+==+null)+?+default(TValue)+:+func(value);
}|code-block|syntax|javascript|1113358|编译器能处理TResult成为void的可能性吗？是。它所要做的就是要求返回后面跟着一个类型为void的表达式。default(void)的结果将是void类型，传入的函数需要形式为Func<TValue,+void>+(相当于Action<TValue>)。|1113359|许多其他的答案暗示你不能用表达式来链接语句，但是我不知道这个想法是从何而来的。我们可以将语句后出现的;看作二进制infix操作符，将void类型的两个表达式组合成void类型的单个表达式。|1113360|entityMap^0|D|4|0|K|P|1R|I|0|0|0|6|7|F|4|1B|4|1K|D|22|4|2J|I|36|E|0|1E|1|1U|4|29|4|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|12|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|13|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1J|8|@$9|1K|A|1L|B|C]|$9|1M|A|1N|B|C]|$9|1O|A|1P|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1Q|8|@]|D|@]|E|$]]]|T|$]]

A statement is a special case of an expression, one with <code>void</code> type. The tendency of languages to treat statements differently often causes problems, and it would be better if they were properly generalized.

For example, in C# we have the very useful <code>Func&lt;T1, T2, T3, TResult&gt;</code> overloaded set of generic delegates. But we also have to have a corresponding <code>Action&lt;T1, T2, T3&gt;</code> set as well, and general purpose higher-order programming constantly has to be duplicated to deal with this unfortunate bifurcation.

Trivial example - a function that checks whether a reference is null before calling onto another function:

<pre><code>TResult IfNotNull&lt;TValue, TResult&gt;(TValue value, Func&lt;TValue, TResult&gt; func)
 where TValue : class
{
 return (value == null) ? default(TValue) : func(value);
}
</code></pre>

Could the compiler deal with the possibility of <code>TResult</code> being <code>void</code>? Yes. All it has to do is require that return is followed by an expression that is of type <code>void</code>. The result of <code>default(void)</code> would be of type <code>void</code>, and the func being passed in would need to be of the form <code>Func&lt;TValue, void&gt;</code> (which would be equivalent to <code>Action&lt;TValue&gt;</code>).

A number of other answers imply that you can't chain statements like you can with expressions, but I'm not sure where this idea comes from. We can think of the <code>;</code> that appears after statements as a binary infix operator, taking two expressions of type <code>void</code> and combining them into a single expression of type <code>void</code>.

blocks|key|823940|text|要解释表达式与语句在可组合性(chainability)方面的重要差异，我最喜欢的参考是John的图灵奖论文http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.130.4539&rep=rep1&type=pdf。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|823941|命令语言(Fortran，C，Java，.)强调用于构造程序的语句，并将表达式作为一种事后思考.函数式语言强调表达。纯函数式语言有如此强大的表达方式，而语句却无法完全消除。|823942|entityMap|0|LINK|mutability|MUTABLE|url|http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.130.4539&rep=rep1&type=pdf^0|1I|2B|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

For an explanation of important differences in composability (chainability) of expressions vs statements, my favorite reference is John Backus's Turing award paper, <a href="http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.130.4539&amp;rep=rep1&amp;type=pdf" rel="noreferrer">Can programming be liberated from the von Neumann style?</a>.

Imperative languages (Fortran, C, Java, ...) emphasize statements for structuring programs, and have expressions as a sort of after-thought. Functional languages emphasize expressions. Purely functional languages have such powerful expressions than statements can be eliminated altogether.

blocks|key|823944|text|语句是语法上完整的句子。表情不是。例如|type|unstyled|depth|inlineStyleRanges|entityRanges|data|823945|x+=+5|code-block|syntax|javascript|823946|读为"x得到5“。这是一个完整的句子。密码|823947|(x+%2B+5)/9.0|823948|"x加5除以9.0。“这不是一个完整的句子。声明|823949|while+k+<+10:+
++++print+k
++++k+%2B=+1|823950|是一个完整的句子。注意，循环头不是；“that+k<+10”是一个从属子句。|823951|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Statements are grammatically complete sentences. Expressions are not. For example

<pre><code>x = 5
</code></pre>

reads as "x gets 5." This is a complete sentence. The code

<pre><code>(x + 5)/9.0
</code></pre>

reads, "x plus 5 all divided by 9.0." This is not a complete sentence. The statement

<pre><code>while k &lt; 10: 
 print k
 k += 1
</code></pre>

is a complete sentence. Notice that the loop header is not; "while k &lt; 10," is a subordinating clause.

blocks|key|114199|text|最准确地说，语句必须具有“副作用”(即命令式)，表达式必须具有值类型(即不是底部类型)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|114200|陈述的类型是单位类型，但由于停止定理，单位是虚构的，所以让我们说底式。|114201|Void并不完全是底层类型(它不是所有可能类型的子类型)。它存在于没有完全健全的类型系统语言中。这听起来像是一个势利的陈述，但完整性例如方差注释对于编写可扩展的软件至关重要。|CODE|114202|让我们看看维基百科在这件事上有什么要说的。|114203|科学)|114204|在计算机编程中，语句是命令式编程语言中最小的独立元素，该语言表示要执行的某些动作。
许多语言(例如C)区分语句和定义，语句只包含可执行代码，定义声明标识符，而表达式只计算为值。|blockquote|114205|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/602444/what-is-functional-declarative-and-imperative-programming/8357604#8357604|1|http://james-iry.blogspot.com/2009/08/getting-to-bottom-of-nothing-at-all.html|2|https://stackoverflow.com/a/8450076/615784|3|4|https://stackoverflow.com/a/8438947/615784|5|https://en.wikipedia.org/wiki/Statement_(computer_science)^0|C|5|V|1|J|3|0|0|0|5|1|W|2|2|0|0|4|X|B|3|1U|6|4|0|0|0|3|5|0|B|3|0^^$0|@$1|2|3|4|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]]|D|@$9|1D|A|1E|1|1F]]|E|$]]|$1|F|3|G|5|6|7|1G|8|@]|D|@$9|1H|A|1I|1|1J]|$9|1K|A|1L|1|1M]]|E|$]]|$1|H|3|I|5|6|7|1N|8|@$9|1O|A|1P|B|J]]|D|@$9|1Q|A|1R|1|1S]|$9|1T|A|1U|1|1V]]|E|$]]|$1|K|3|L|5|6|7|1W|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|1X|8|@]|D|@$9|1Y|A|1Z|1|20]]|E|$]]|$1|O|3|P|5|Q|7|21|8|@$9|22|A|23|B|C]]|D|@]|E|$]]|$1|R|3|-4|5|6|7|24|8|@]|D|@]|E|$]]]|S|$T|$5|U|V|W|E|$X|Y]]|Z|$5|U|V|W|E|$X|10]]|11|$5|U|V|W|E|$X|12]]|13|$5|U|V|W|E|$X|10]]|14|$5|U|V|W|E|$X|15]]|16|$5|U|V|W|E|$X|17]]]]

Most precisely, a statement must have a &quot;side-effect&quot; (i.e. <a href="https://stackoverflow.com/questions/602444/what-is-functional-declarative-and-imperative-programming/8357604#8357604">be imperative</a>) and an expression must have a value type (i.e. not the bottom type).
The <a href="http://james-iry.blogspot.com/2009/08/getting-to-bottom-of-nothing-at-all.html" rel="nofollow noreferrer">type of a statement</a> is the unit type, but due to Halting theorem unit is fiction so lets say the <a href="https://stackoverflow.com/a/8450076/615784">bottom type</a>.
<hr />
<code>Void</code> is not precisely the bottom type (it isn't the subtype of all possible types). It exists in languages that <a href="http://james-iry.blogspot.com/2009/08/getting-to-bottom-of-nothing-at-all.html" rel="nofollow noreferrer">don't have a completely sound type system</a>. That may sound like a snobbish statement, but completeness <a href="https://stackoverflow.com/a/8438947/615784">such as variance annotations</a> are critical to writing extensible software.
Let's see what Wikipedia has to say on this matter.
<a href="https://en.wikipedia.org/wiki/Statement_(computer_science)" rel="nofollow noreferrer">https://en.wikipedia.org/wiki/Statement_(computer_science)</a>
<blockquote>
In computer programming a statement is the smallest standalone element of an imperative programming language that expresses some action to be carried out.
Many languages (e.g. C) make a distinction between statements and definitions, with a statement only containing executable code and a definition declaring an identifier, while an expression evaluates to a value only.
</blockquote>

blocks|key|114239|text|语句->指令按顺序执行|type|unstyled|depth|inlineStyleRanges|entityRanges|data|114240|返回值的表达式->计算|114241|语句基本上类似于步骤，或算法中的指令，语句执行的结果是指令指针的实现(在汇编程序中称为)。|114242|表达式并不意味着一见钟情和执行顺序，它们的目的是计算和返回一个值。在命令式编程语言中，表达式的计算是有顺序的，但这仅仅是因为命令式模型，但它并不是它们的本质。|114243|发言实例：|114244|for
goto
return
if|code-block|syntax|javascript|114245|(所有这些都意味着执行的行(语句)前进到另一行)|114246|表达的例子：|114247|2%2B2|114248|(这并不意味着执行的想法，而是评价的意思)|114249|entityMap^0|0|0|0|0|0|0|0|0|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|6|7|10|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|13|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|14|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|15|8|@]|9|@]|A|$]]|$1|S|3|T|5|L|7|16|8|@]|9|@]|A|$M|N]]|$1|U|3|V|5|6|7|17|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

Statements -> Instructions to follow sequentially 
Expressions -> Evaluation that returns a value

Statements are basically like steps, or instructions in an algorithm, the result of the execution of a statement is the actualization of the instruction pointer (so-called in assembler)

Expressions do not imply and execution order at first sight, their purpose is to evaluate and return a value. In the imperative programming languages the evaluation of an expression has an order, but it is just because of the imperative model, but it is not their essence.

Examples of Statements:

<pre><code>for
goto
return
if
</code></pre>

(all of them imply the advance of the line (statement) of execution to another line)

Example of expressions:

<pre><code>2+2
</code></pre>

(it doesn't imply the idea of execution, but of the evaluation)

blocks|key|824057|text|语句，|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|824058|语句是构建所有C#程序的过程构建块.语句可以声明局部变量或常量、调用方法、创建对象或为变量、属性或字段分配值。|824059|由大括号包围的一系列语句形成了一个代码块。方法体是代码块的一个示例。|824060|bool+IsPositive(int+number)
{
++++if+(number+>+0)
++++{
++++++++return+true;
++++}
++++else
++++{
++++++++return+false;
++++}
}|code-block|syntax|javascript|824061|C#中的语句通常包含表达式。C#中的表达式是包含文字值、简单名称或运算符及其操作数的代码片段。|824062|表达式，|824063|表达式是可以计算到单个值、对象、方法或命名空间的代码片段。两种最简单的表达式类型是文字和简单名称。文字是没有名称的常量值。|824064|int+i+=+5;
string+s+=+"Hello+World";|824065|I和s都是标识局部变量的简单名称。在表达式中使用这些变量时，将检索变量的值并将其用于表达式。|824066|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/ms173143%2528v=vs.80%2529.aspx|1|http://msdn.microsoft.com/en-us/library/ms173144%2528v=vs.80%2529.aspx^0|2|1|0|2|0|0|0|0|0|0|3|1|0|3|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@$9|1B|A|1C|1|1D]]|E|$]]|$1|F|3|G|5|6|7|1E|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1F|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|1G|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1H|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1I|8|@$9|1J|A|1K|B|C]]|D|@$9|1L|A|1M|1|1N]]|E|$]]|$1|S|3|T|5|6|7|1O|8|@]|D|@]|E|$]]|$1|U|3|V|5|L|7|1P|8|@]|D|@]|E|$M|N]]|$1|W|3|X|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|Y|3|-4|5|6|7|1R|8|@]|D|@]|E|$]]]|Z|$10|$5|11|12|13|E|$14|15]]|16|$5|11|12|13|E|$14|17]]]]

<a href="http://msdn.microsoft.com/en-us/library/ms173143%28v=vs.80%29.aspx" rel="nofollow">Statement</a>,

A statement is a procedural building-block from which all C# programs are constructed. A statement can declare a local variable or constant, call a method, create an object, or assign a value to a variable, property, or field.

A series of statements surrounded by curly braces form a block of code. A method body is one example of a code block.

<pre><code>bool IsPositive(int number)
{
 if (number &gt; 0)
 {
 return true;
 }
 else
 {
 return false;
 }
}
</code></pre>

Statements in C# often contain expressions. An expression in C# is a fragment of code containing a literal value, a simple name, or an operator and its operands.

<a href="http://msdn.microsoft.com/en-us/library/ms173144%28v=vs.80%29.aspx" rel="nofollow">Expression</a>,

An expression is a fragment of code that can be evaluated to a single value, object, method, or namespace. The two simplest types of expressions are literals and simple names. A literal is a constant value that has no name.

<pre><code>int i = 5;
string s = "Hello World";
</code></pre>

Both i and s are simple names identifying local variables. When those variables are used in an expression, the value of the variable is retrieved and used for the expression.

blocks|key|824074|text|我更喜欢statement这个词的形式逻辑意义。它改变了计算中一个或多个变量的状态，从而能够对它们的值进行真语句或假语句。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|824075|我想，当新术语或新词汇被引入，现有词汇被“重新使用”，或者用户不知道他们所描述的事物的现有的、既定的或“适当的”术语时，计算世界和整个科学都会出现混乱。|824076|entityMap^0|4|9|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

I prefer the meaning of <code>statement</code> in the formal logic sense of the word. It is one that changes the state of one or more of the variables in the computation, enabling a true or false statement to be made about their value(s).

I guess there will always be confusion in the computing world and science in general when new terminology or words are introduced, existing words are 'repurposed' or users are ignorant of the existing, established or 'proper' terminology for what they are describing

blocks|key|114399|text|这是我找到的最简单答案之一的夏天。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|114400|最初由Anders+Kaseorg回答|114401|语句是执行某些操作的完整代码行，而表达式是代码中计算值的任何部分。|114402|表达式可以使用运算符“水平”组合成更大的表达式，而语句只能通过一个接一个地写入或与块结构进行“垂直”组合。|offset|length|style|BOLD|114403|每个表达式都可以用作语句(其效果是计算表达式并忽略结果值)，但大多数语句不能用作表达式。|114404|http://www.quora.com/Python-programming-language-1/Whats-the-difference-between-a-statement-and-an-expression-in-Python|114405|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|0|1H|0|0|18|0|0|3B|0|3B|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|6|7|Z|8|@$H|10|I|11|J|K]]|9|@]|A|$]]|$1|L|3|M|5|6|7|12|8|@$H|13|I|14|J|K]]|9|@]|A|$]]|$1|N|3|O|5|6|7|15|8|@$H|16|I|17|J|K]]|9|@$H|18|I|19|1|1A]]|A|$]]|$1|P|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Q|$R|$5|S|T|U|A|$V|O]]]]

Here is the summery of one of the simplest answer I found.

originally Answered by Anders Kaseorg

A statement is a complete line of code that performs some action, while an expression is any section of the code that evaluates to a value. 

Expressions can be combined “horizontally” into larger expressions using operators, while statements can only be combined “vertically” by writing one after another, or with block constructs. 

Every expression can be used as a statement (whose effect is to evaluate the expression and ignore the resulting value), but most statements cannot be used as expressions.

<a href="http://www.quora.com/Python-programming-language-1/Whats-the-difference-between-a-statement-and-an-expression-in-Python" rel="nofollow">http://www.quora.com/Python-programming-language-1/Whats-the-difference-between-a-statement-and-an-expression-in-Python</a>

blocks|key|114512|text|我对这里的任何一个答案都不满意。我看了一下C%2B%2B+(国际标准化组织2008年)的语法。然而，也许出于教学和编程的考虑，答案可能足以区分这两种因素(虽然现实看起来更复杂)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|114513|语句由零或多个表达式组成，但也可以是其他语言概念。这是语法的(语句的摘录)：|114514|statement:
++++++++labeled-statement
++++++++expression-statement+<--+can+be+zero+or+more+expressions
++++++++compound-statement
++++++++selection-statement
++++++++iteration-statement
++++++++jump-statement
++++++++declaration-statement
++++++++try-block|code-block|syntax|javascript|114515|我们可以看到在C%2B%2B中被认为是语句的其他概念。|114516|表达式-语句_s是自我解释的(语句可以由零或_more表达式组成，仔细阅读语法，这很棘手)|unordered-list-item|114517|例如，case是一个标记语句。|style|CODE|114518|_selection语句_s是if+if/else，case|114519|_迭代-语句_s是while，do...while，for+(...)|114520|_+break，continue，return+(可以返回表达式)，goto|114521|声明-语句是一组声明。|114522|是表示try/catch块的语句。|114523|在语法上可能会有更多|114524|这是一个显示表达式部分的摘录：|114525|expression:
++++++++assignment-expression
++++++++expression+","+assignment-expression
assignment-expression:
++++++++conditional-expression
++++++++logical-or-expression+assignment-operator+initializer-clause
++++++++throw-expression|114526|表达式通常是或包含赋值。|114527|条件表达式(听起来有误导性)指操作符的用法(%2B，-，*，/，&，%7C，&&，%7C%7C，.)|114528|扔-表情-呃？throw子句也是一个表达式。|114529|entityMap|0|LINK|mutability|MUTABLE|url|http://slps.github.io/zoo/cpp/iso-n2723.html^0|L|I|0|0|0|0|0|0|3|4|0|F|2|I|7|Q|4|0|9|5|F|A|Q|9|0|2|5|8|8|H|6|Y|4|0|0|3|9|0|0|0|0|0|M|1|O|1|Q|1|S|1|U|1|W|1|Y|2|11|2|0|7|5|0^^$0|@$1|2|3|4|5|6|7|1N|8|@]|9|@$A|1O|B|1P|1|1Q]]|C|$]]|$1|D|3|E|5|6|7|1R|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|1S|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|1T|8|@]|9|@]|C|$]]|$1|M|3|N|5|O|7|1U|8|@]|9|@]|C|$]]|$1|P|3|Q|5|O|7|1V|8|@$A|1W|B|1X|R|S]]|9|@]|C|$]]|$1|T|3|U|5|O|7|1Y|8|@$A|1Z|B|20|R|S]|$A|21|B|22|R|S]|$A|23|B|24|R|S]]|9|@]|C|$]]|$1|V|3|W|5|O|7|25|8|@$A|26|B|27|R|S]|$A|28|B|29|R|S]|$A|2A|B|2B|R|S]]|9|@]|C|$]]|$1|X|3|Y|5|O|7|2C|8|@$A|2D|B|2E|R|S]|$A|2F|B|2G|R|S]|$A|2H|B|2I|R|S]|$A|2J|B|2K|R|S]]|9|@]|C|$]]|$1|Z|3|10|5|O|7|2L|8|@]|9|@]|C|$]]|$1|11|3|12|5|O|7|2M|8|@$A|2N|B|2O|R|S]]|9|@]|C|$]]|$1|13|3|14|5|O|7|2P|8|@]|9|@]|C|$]]|$1|15|3|16|5|6|7|2Q|8|@]|9|@]|C|$]]|$1|17|3|18|5|H|7|2R|8|@]|9|@]|C|$I|J]]|$1|19|3|1A|5|O|7|2S|8|@]|9|@]|C|$]]|$1|1B|3|1C|5|O|7|2T|8|@$A|2U|B|2V|R|S]|$A|2W|B|2X|R|S]|$A|2Y|B|2Z|R|S]|$A|30|B|31|R|S]|$A|32|B|33|R|S]|$A|34|B|35|R|S]|$A|36|B|37|R|S]|$A|38|B|39|R|S]]|9|@]|C|$]]|$1|1D|3|1E|5|O|7|3A|8|@$A|3B|B|3C|R|S]]|9|@]|C|$]]|$1|1F|3|-4|5|6|7|3D|8|@]|9|@]|C|$]]]|1G|$1H|$5|1I|1J|1K|C|$1L|1M]]]]

I am not really satisfied with any of the answers here. I looked at the grammar for <a href="http://slps.github.io/zoo/cpp/iso-n2723.html" rel="nofollow">C++ (ISO 2008)</a>. However maybe for the sake of didactics and programming the answers might suffice to distinguish the two elements (reality looks more complicated though).

A statement consists of zero or more expressions, but can also be other language concepts. This is the Extended Backus Naur form for the grammar (excerpt for statement):

<pre><code>statement:
 labeled-statement
 expression-statement &lt;-- can be zero or more expressions
 compound-statement
 selection-statement
 iteration-statement
 jump-statement
 declaration-statement
 try-block
</code></pre>

We can see the other concepts that are considered statements in C++.

<ul>
<li>expression-statements is self-explaining (a statement can consist of zero or more expressions, read the grammar carefully, it's tricky) </li>
<li><code>case</code> for example is a labeled-statement</li>
<li>selection-statements are <code>if</code> <code>if/else</code>, <code>case</code></li>
<li>iteration-statements are <code>while</code>, <code>do...while</code>, <code>for (...)</code></li>
<li>jump-statements are <code>break</code>, <code>continue</code>, <code>return</code> (can return expression), <code>goto</code></li>
<li>declaration-statement is the set of declarations</li>
<li>try-block is statement representing <code>try/catch</code> blocks</li>
<li>and there might be some more down the grammar</li>
</ul>

This is an excerpt showing the expressions part:

<pre><code>expression:
 assignment-expression
 expression "," assignment-expression
assignment-expression:
 conditional-expression
 logical-or-expression assignment-operator initializer-clause
 throw-expression
</code></pre>

<ul>
<li>expressions are or contain often assignments</li>
<li>conditional-expression (sounds misleading) refers to usage of the operators (<code>+</code>, <code>-</code>, <code>*</code>, <code>/</code>, <code>&amp;</code>, <code>|</code>, <code>&amp;&amp;</code>, <code>||</code>, ...)</li>
<li>throw-expression - uh? the <code>throw</code> clause is an expression too</li>
</ul>

blocks|key|114557|text|为了改进和验证我先前的答案，编程语言术语的定义应在适用时从计算机科学类型理论中解释。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|114558|表达式的类型不同于底部类型，即它有一个值。语句具有Unit或底部类型。|114559|由此可以看出，语句在创建副作用时只能在程序中产生任何效果，因为它要么不能返回值，要么只返回单元类型的值，它要么是不可分配的(在某些语言中是不可分配的，比如C的void)，要么是可以存储的，以便对语句进行延迟的计算。|offset|length|style|CODE|114560|显然，@pragma或/*comment*/没有类型，因此与语句不同。因此，唯一没有副作用的语句类型将是非操作。非手术只能作为未来副作用的占位符.任何其他因陈述而采取的行动都会产生副作用。同样，编译器提示(例如@pragma+)不是语句，因为它没有类型。|114561|entityMap^0|0|0|27|4|0|3|7|B|B|2X|7|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@$F|Q|G|R|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@$F|T|G|U|H|I]|$F|V|G|W|H|I]|$F|X|G|Y|H|I]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|M|$]]

To improve on and validate my prior answer, definitions of programming language terms should be explained from computer science type theory when applicable.

An expression has a type other than the Bottom type, i.e. it has a value. A statement has the Unit or Bottom type.

From this it follows that a statement can only have any effect in a program when it creates a side-effect, because it either can not return a value or it only returns the value of the Unit type which is either nonassignable (in some languages such a C's <code>void</code>) or (such as in Scala) can be stored for a delayed evaluation of the statement.

Obviously a <code>@pragma</code> or a <code>/*comment*/</code> have no type and thus are differentiated from statements. Thus the only type of statement that would have no side-effects would be a non-operation. Non-operation is only useful as a placeholder for future side-effects. Any other action due to a statement would be a side-effect. Again a compiler hint, e.g. <code>@pragma</code>, is not a statement because it has no type.

blocks|key|820072|text|在面向语句的编程语言中，代码块被定义为语句列表.换句话说，语句是一种语法，您可以将其放入代码块中，而不会导致语法错误。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|820073|维基百科对单词语句的定义类似|820074|在计算机程序设计中，语句是命令式编程语言的句法单位，它表示要执行的某些动作。用这种语言编写的程序是由一个或多个语句组成的。|blockquote|820075|注意后一条语句。(虽然在这种情况下“程序”在技术上是错误的，因为C和Java都拒绝包含任何语句的程序。)|820076|维基百科将单词表达式定义为|820077|编程语言中的表达式是一个句法实体，可以对其进行计算以确定其值。|820078|然而，这是假的，因为在Kotlin中，throw+new+Exception("")是一个表达式，但是在计算时，它只是抛出一个异常，从不返回任何值。|offset|length|style|CODE|820079|在静态类型编程语言中，每个表达式都有一个类型。然而，这个定义在动态类型的编程语言中不起作用。|820080|就我个人而言，我将表达式定义为一段语法，该语法可以由运算符或函数调用组成，从而生成更大的表达式。这实际上类似于维基百科对表达的解释：|820081|它是一个或多个常量、变量、函数和运算符的组合，编程语言根据其特定的优先级和关联规则解释这些常量、变量、函数和运算符，并计算生成(在有状态环境中“返回”)另一个值。|820082|但是，问题是在C编程语言中，给定这样一个函数executeSomething：|820083|void+executeSomething(void){
++++return;
}|code-block|syntax|javascript|820084|executeSomething()是表达式还是语句？根据我的定义，它是一种语句，因为在微软的C引用语法中，|820085|不能以任何方式使用具有void类型的表达式的(不存在)值，也不能将void表达式(通过隐式或显式转换)转换为除void以外的任何类型。|820086|但同一页清楚地表明，这种语法是一个表达式。|820087|entityMap^0|0|0|0|0|0|0|J|N|0|0|0|0|0|0|0|I|0|0|0^^$0|@$1|2|3|4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1E|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1F|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|1G|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|1H|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|1I|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1J|8|@$O|1K|P|1L|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1M|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1N|8|@]|9|@]|A|$]]|$1|W|3|X|5|F|7|1O|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1P|8|@]|9|@]|A|$]]|$1|10|3|11|5|12|7|1Q|8|@]|9|@]|A|$13|14]]|$1|15|3|16|5|6|7|1R|8|@$O|1S|P|1T|Q|R]]|9|@]|A|$]]|$1|17|3|18|5|F|7|1U|8|@]|9|@]|A|$]]|$1|19|3|1A|5|6|7|1V|8|@]|9|@]|A|$]]|$1|1B|3|-4|5|6|7|1W|8|@]|9|@]|A|$]]]|1C|$]]

In a statement-oriented programming language, a code block is defined as a list of statements. In other words, a statement is a piece of syntax that you can put inside a code block without causing a syntax error.

Wikipedia defines the word statement similarly

<blockquote>
 In computer programming, a statement is a syntactic unit of an imperative programming language that expresses some action to be carried out. A program written in such a language is formed by a sequence of one or more statements
</blockquote>

Notice the latter statement. (although "a program" in this case is technically wrong because both C and Java reject a program that consists of nothing of statements.)

Wikipedia defines the word expression as 

<blockquote>
 An expression in a programming language is a syntactic entity that may be evaluated to determine its value
</blockquote>

This is, however, false, because in Kotlin, <code>throw new Exception("")</code> is an expression but when evaluated, it simply throws an exception, never returning any value.

In a statically typed programming language, every expression has a type. This definition, however, doesn't work in a dynamically typed programming language.

Personally, I define an expression as a piece of syntax that can be composed with an operator or function calls to yield a bigger expression. This is actually similar to the explanation of expression by Wikipedia:

<blockquote>
 It is a combination of one or more constants, variables, functions, and operators that the programming language interprets (according to its particular rules of precedence and of association) and computes to produce ("to return", in a stateful environment) another value
</blockquote>

But, the problem is in C programming language, given a function executeSomething like this:

<pre><code>void executeSomething(void){
 return;
}
</code></pre>

Is <code>executeSomething()</code> an expression or is it a statement? According to my definition, it is a statement because as defined in Microsoft's C reference grammar, 

<blockquote>
 You cannot use the (nonexistent) value of an expression that has type void in any way, nor can you convert a void expression (by implicit or explicit conversion) to any type except void
</blockquote>

But the same page clearly indicates that such syntax is an expression.

blocks|key|820103|text|语句是一个代码块，它不返回任何内容，它只是一个独立的执行单元。例如-|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|820104|if(a>=0)
printf("Hello+Humen,I'm+a+statement");|code-block|syntax|javascript|820105|另一方面，表达式返回或计算新值。例如-|820106|+if(a>=0)
++++return+a%2B10;//This+is+an+expression+because+it+evalutes+an+new+value;|820107|或|820108|+a=10%2By;//This+is+also+an+expression+because+it+returns+a+new+value.+|820109|entityMap^0|0|2|0|0|5|3|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|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|12|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|T|$]]

A statement is a block of code that doesn't return anything and which is just a standalone unit of execution. For example-
<pre><code>if(a&gt;=0)
printf(&quot;Hello Humen,I'm a statement&quot;);
</code></pre>
An expression, on the other hand, returns or evaluates a new value. For example -
<pre><code> if(a&gt;=0)
 return a+10;//This is an expression because it evalutes an new value;
</code></pre>
or
<pre><code> a=10+y;//This is also an expression because it returns a new value. 
</code></pre>

blocks|key|1114039|text|表达式|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1114040|一种语法，它可以被计算成某种值。换句话说，表达式是表达式元素的积累，如文字、名称、属性访问、运算符或函数调用，它们都返回一个值。与许多其他语言不同的是，并非所有的语言结构都是表达式。也有一些语句不能用作表达式，例如时间。作业也是语句，而不是表达式。|blockquote|1114041|语句|1114042|语句是套件(“代码块”)的一部分。语句要么是一个表达式，要么是带有关键字的几个构造中的一个，例如if、while或for。|1114043|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/glossary.html#term-expression|1|https://docs.python.org/3/glossary.html#term-statement^0|0|3|0|0|0|0|2|1|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$]]|$1|G|3|H|5|6|7|Z|8|@]|9|@$A|10|B|11|1|12]]|C|$]]|$1|I|3|J|5|F|7|13|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]]]

<a href="https://docs.python.org/3/glossary.html#term-expression" rel="nofollow noreferrer">Expression</a>
<blockquote>
A piece of syntax which can be evaluated to some value. In other words, an expression is an accumulation of expression elements like literals, names, attribute access, operators or function calls which all return a value. In contrast to many other languages, not all language constructs are expressions. There are also statements which cannot be used as expressions, such as while. Assignments are also statements, not expressions.
</blockquote>
<a href="https://docs.python.org/3/glossary.html#term-statement" rel="nofollow noreferrer">Statement</a>
<blockquote>
A statement is part of a suite (a “block” of code). A statement is either an expression or one of several constructs with a keyword, such as if, while or for.
</blockquote>

I'm asking with regards to c#, but I assume its the same in most other languages.

Does anyone have a good definition of expressions and statements and what the differences are?

Expression Versus Statement

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我问的是c#，但我认为在大多数其他语言中也是如此。有没有人对表达和陈述有一个很好的定义，区别是什么？

问表达式与语句
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问表达式与语句EN