这些概念的事实基础是:

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

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

除了最初几十年的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".

表达式是产生一个值的任何东西:2 + 2 语句是程序执行的基本“块”之一。

注意，在C语言中，“=”实际上是一个运算符，它做两件事:

返回右边子表达式的值。 将右边子表达式的值复制到左边的变量中。

下面是一段ANSI C语法的摘录。你可以看到C语言没有很多不同种类的语句……程序中的大多数语句都是表达式语句，即结尾带有分号的表达式。

statement
    : labeled_statement
    | compound_statement
    | expression_statement
    | selection_statement
    | iteration_statement
    | jump_statement
    ;

expression_statement
    : ';'
    | expression ';'
    ;

http://www.lysator.liu.se/c/ANSI-C-grammar-y.html

我对这里的答案都不太满意。我查看了c++ (ISO 2008)的语法。然而，出于教学和编程的考虑，答案可能足以区分这两个元素(尽管现实看起来更复杂)。

语句由零个或多个表达式组成，但也可以是其他语言概念。这是语法的扩展巴克斯诺尔形式(语句节选):

statement:
        labeled-statement
        expression-statement <-- can be zero or more expressions
        compound-statement
        selection-statement
        iteration-statement
        jump-statement
        declaration-statement
        try-block

我们可以看到c++中被认为是语句的其他概念。

表达式-语句是自解释的(一个语句可以由0个或多个表达式组成，仔细阅读语法，这很棘手) 例如，Case是一个带标签的语句 选择语句是if if/else, case 迭代语句是while, do…然而，对于(……) 跳转语句有break, continue, return(可以返回表达式)，goto Declaration-statement是声明的集合 try-block是表示try/catch块的语句 在语法中可能还有更多

以下是表达部分的节选:

expression:
        assignment-expression
        expression "," assignment-expression
assignment-expression:
        conditional-expression
        logical-or-expression assignment-operator initializer-clause
        throw-expression

表达式通常是或包含赋值 条件表达式(听起来容易误导人)指的是使用运算符(+，-，*，/，&，|，&&，||，…) 抛出表情——呃?throw子句也是一个表达式

下面是我找到的一个最简单的答案。

原文由Anders Kaseorg回答

语句是执行某些操作的完整代码行，而表达式是代码中求值的任何部分。

可以使用操作符将表达式“水平”组合成更大的表达式，而语句只能通过一个接一个地写入或使用块结构来“垂直”组合。

每个表达式都可以用作语句(其效果是计算表达式并忽略结果值)，但大多数语句不能用作表达式。

http://www.quora.com/Python-programming-language-1/Whats-the-difference-between-a-statement-and-an-expression-in-Python

很简单:表达式的值是一个值，而语句不是。

最准确地说，语句必须有“副作用”(即命令式)，表达式必须有值类型(即不是底部类型)。

语句的类型是单元类型，但由于停止定理，单元是虚构的，所以我们说底层类型。

Void并不是最下面的类型(它不是所有可能类型的子类型)。它存在于没有完整的声音类型系统的语言中。这听起来可能有点势利，但是完整性(如方差注释)对于编写可扩展软件是至关重要的。

让我们看看维基百科对这件事是怎么说的。

https://en.wikipedia.org/wiki/Statement_ (computer_science)

在计算机编程中，语句是命令式编程语言中最小的独立元素，它表示要执行的某些操作。 许多语言(例如C语言)区分语句和定义，语句只包含可执行代码和声明标识符的定义，而表达式只计算值。