语句是一段不返回任何东西的代码，它只是一个独立的执行单元。例如,

if(a>=0)
printf("Hello Humen,I'm a statement");

另一方面，表达式返回或计算一个新值。例如:

 if(a>=0)
    return a+10;//This is an expression because it evalutes an new value;

or

 a=10+y;//This is also an expression because it returns a new value. 

我更喜欢“陈述”这个词的形式逻辑意义。它改变了计算中一个或多个变量的状态，从而能够对它们的值做出真或假的声明。

我想，当新的术语或词汇被引入，现有的词汇被“重新定义”，或者用户对他们所描述的现有的、已建立的或“适当的”术语一无所知时，在计算世界和科学中总会出现困惑

表达式可以求值得到一个值，而语句不返回值(它们是void类型)。

当然，函数调用表达式也可以被视为语句，但除非执行环境有一个特殊的内置变量来保存返回值，否则无法检索它。

面向语句的语言要求所有过程都是语句列表。面向表达式的语言，可能是所有的函数式语言，都是表达式的列表，或者在LISP的情况下，是一个表示表达式列表的长s表达式。

尽管这两种类型都可以组合，但只要类型匹配，大多数表达式都可以任意组合。每种类型的语句都有自己的方式来组合其他语句，如果它们可以做到这一切的话。Foreach和if语句要么要求单个语句，要么要求所有子语句一个接一个地放入语句块中，除非子语句允许它们自己的子语句。

语句还可以包括表达式，而表达式实际上不包括任何语句。不过，lambda表达式是一个例外，它表示一个函数，因此可以包括函数可以包含的任何东西，除非语言只允许有限的lambdas，比如Python的单表达式lambdas。

在基于表达式的语言中，你所需要的只是一个函数的单个表达式，因为所有的控制结构都返回一个值(其中很多返回NIL)。不需要return语句，因为函数中最后求值的表达式就是返回值。

为了改进和验证我之前的回答，编程语言术语的定义应该从计算机科学类型理论中解释。

表达式具有除Bottom类型以外的其他类型，即它有一个值。语句具有Unit或Bottom类型。

由此可见，语句只有在产生副作用时才能在程序中发挥作用，因为它要么不能返回值，要么只返回Unit类型的值，而Unit类型的值要么不可赋值(在某些语言中，如C的void)，要么可以存储以用于语句的延迟求值。

显然，@pragma或/*comment*/没有类型，因此与语句有所区别。因此，唯一没有副作用的语句类型是非操作。非手术治疗只能作为未来副作用的占位符。由于声明而采取的任何其他行动都是副作用。同样，编译器提示，例如@pragma，不是语句，因为它没有类型。

你可以在维基百科上找到这个，但是表达式被求值为某个值，而语句没有求值。

因此，表达式可以用在语句中，但不能用在语句中。

请注意，一些语言(如Lisp，我相信Ruby，以及许多其他语言)并不区分语句和表达式……在这样的语言中，所有东西都是一个表达式，并且可以与其他表达式连接。

这些概念的事实基础是:

表达式:一种语法类别，其实例可以求值。

语句:一种语法类别，其实例可能涉及表达式的求值，并且不能保证求值的结果值(如果有的话)可用。

除了最初几十年的FORTRAN上下文之外，公认答案中表达式和语句的定义显然都是错误的:

Expressions can be unvaluated operands. Values are never produced from them. Subexpressions in non-strict evaluations can be definitely unevaluated. Most C-like languages have the so-called short-circuit evaluation rules to conditionally skip some subexpression evaluations not change the final result in spite of the side effects. C and some C-like languages have the notion of unevaluated operand which may be even normatively defined in the language specification. Such constructs are used to avoid the evaluations definitely, so the remained context information (e.g. types or alignment requirements) can be statically distinguished without changing the behavior after the program translation. For example, an expression used as the operand of the sizeof operator is never evaluated. Statements have nothing to do with line constructs. They can do something more than expressions, depending on the language specifications. Modern Fortran, as the direct descendant of the old FORTRAN, has concepts of executable statements and nonexecutable statements. Similarly, C++ defines declarations as the top-level subcategory of a translation unit. A declaration in C++ is a statement. (This is not true in C.) There are also expression-statements like Fortran's executable statements. To the interest of the comparison with expressions, only the "executable" statements matter. But you can't ignore the fact that statements are already generalized to be constructs forming the translation units in such imperative languages. So, as you can see, the definitions of the category vary a lot. The (probably) only remained common property preserved among these languages is that statements are expected to be interpreted in the lexical order (for most users, left-to-right and top-to-bottom).

(BTW，关于C的材料，我想补充一下[引文]，因为我不记得DMR是否有这样的意见。似乎不是，否则就没有理由在C语言的设计中保留功能重复:特别是逗号操作符和语句。)

(以下基本原理并不是对最初问题的直接回应，但我觉得有必要澄清这里已经回答过的一些问题。)

然而，在通用编程语言中，我们是否需要特定类别的“语句”是值得怀疑的:

Statements are not guaranteed to have more semantic capabilities over expressions in usual designs. Many languages have already successfully abandon the notion of statements to get clean, neat and consistent overall designs. In such languages, expressions can do everything old-style statements can do: just drop the unused results when the expressions are evaluated, either by leaving the results explicitly unspecified (e.g. in RnRS Scheme), or having a special value (as a value of a unit type) not producible from normal expression evaluations. The lexical order rules of evaluation of expressions can be replaced by explicit sequence control operator (e.g. begin in Scheme) or syntactic sugar of monadic structures. The lexical order rules of other kinds of "statements" can be derived as syntactic extensions (using hygienic macros, for example) to get the similar syntactic functionality. (And it can actually do more.) On the contrary, statements cannot have such conventional rules, because they don't compose on evaluation: there is just no such common notion of "substatement evaluation". (Even if any, I doubt there can be something much more than copy and paste from existed rules of evaluation of expressions.) Typically, languages preserving statements will also have expressions to express computations, and there is a top-level subcategory of the statements preserved to expression evaluations for that subcategory. For example, C++ has the so-called expression-statement as the subcategory, and uses the discarded-value expression evaluation rules to specify the general cases of full-expression evaluations in such context. Some languages like C# chooses to refine the contexts to simplify the use cases, but it bloats the specification more. For users of programming languages, the significance of statements may confuse them further. The separation of rules of expressions and statements in the languages requires more effort to learn a language. The naive lexical order interpretation hides the more important notion: expression evaluation. (This is probably most problematic over all.) Even the evaluations of full expressions in statements are constraint with the lexical order, subexpressions are not (necessarily). Users should ultimately learn this besides any rules coupled to the statements. (Consider how to make a newbie get the point that ++i + ++i is meaningless in C.) Some languages like Java and C# further constraints the order of evaluations of subexpressions to be permissive of ignorance of evaluation rules. It can be even more problematic. This seems overspecified to users who have already learned the idea of expression evaluation. It also encourages the user community to follow the blurred mental model of the language design. It bloats the language specification even more. It is harmful to optimization by missing the expressiveness of nondeterminism on evaluations, before more complicated primitives are introduced. A few languages like C++ (particularly, C++17) specify more subtle contexts of evaluation rules, as a compromise of the problems above. It bloats the language specification a lot. This goes totally against to simplicity to average users...

为什么是语句?不管怎样，历史已经一团糟了。似乎大多数语言设计者都没有仔细选择。

更糟糕的是，它甚至让一些类型系统爱好者(他们对PL历史不够熟悉)产生了一些误解，认为类型系统必须与操作语义上更基本的规则设计有重要关系。

严肃地说，基于类型的推理在许多情况下并不是那么糟糕，但在这个特殊情况下尤其没有建设性。即使是专家也会把事情搞砸。

For example, someone emphasizes the well-typing nature as the central argument against the traditional treatment of undelimited continuations. Although the conclusion is somewhat reasonable and the insights about composed functions are OK (but still far too naive to the essense), this argument is not sound because it totally ignores the "side channel" approach in practice like _Noreturn any_of_returnable_types (in C11) to encode Falsum. And strictly speaking, an abstract machine with unpredictable state is not identical to "a crashed computer".