陈述句是语法上完整的句子。表达式则不然。例如

x = 5

读起来是“x得到5”。这是一个完整的句子。的代码

(x + 5)/9.0

结果是，x + 5都除以9.0这不是一个完整的句子。该声明

while k < 10: 
    print k
    k += 1

是一个完整的句子。注意，循环头不是;"while k < 10 "是从句。

关于基于表达式的语言的一些事情:

最重要的是:所有内容都返回一个值

用于分隔代码块和表达式的花括号和大括号之间没有区别，因为所有内容都是表达式。不过，这并不会阻止词法作用域:例如，可以为包含其定义的表达式和该表达式中包含的所有语句定义局部变量。

在基于表达式的语言中，所有内容都返回一个值。这一开始可能有点奇怪——(FOR i = 1 TO 10 DO (print i))返回什么?

一些简单的例子:

(1)返回1 (1 + 1)返回2 (1 == 1)返回TRUE (1 == 2)返回FALSE (IF 1 == 1 THEN 10 ELSE 5)返回10 (IF 1 == 2 THEN 10 ELSE 5)返回5

还有一些更复杂的例子:

Some things, such as some function calls, don't really have a meaningful value to return (Things that only produce side effects?). Calling OpenADoor(), FlushTheToilet() or TwiddleYourThumbs() will return some sort of mundane value, such as OK, Done, or Success. 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 (FOR i = 1 TO 10 DO (print i)), the value of the for loop is "10", it causes the (print i) expression to be evaluated 10 times, each time returning i as a string. The final time through returns 10, our final answer

通常需要稍微改变一下心态，才能最大限度地利用基于表达式的语言，因为所有东西都是表达式，这使得“内联”很多东西成为可能

举个简单的例子:

FOR i = 1 to (IF MyString == "Hello, World!"然后就有10个人这样做了 （ LotsOfCode )

非基于表达式的替换是否完全有效

IF MyString == "Hello, World!"THEN TempVar = 10 ELSE TempVar = 5 FOR i = 1 TO TempVar DO （ LotsOfCode ）

在某些情况下，基于表达式的代码所允许的布局对我来说感觉更自然

当然，这可能导致疯狂。作为基于表达式的脚本语言MaxScript的爱好项目的一部分，我设法想出了这个怪物行

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
)

表达式是产生一个值的任何东西: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子句也是一个表达式

语句->按顺序执行的指令 表达式->返回值的求值

语句基本上就像算法中的步骤或指令，语句执行的结果是指令指针的实现(所谓的汇编程序)。

表达式乍一看并不意味着和执行顺序，它们的目的是求值并返回值。在命令式编程语言中，表达式的求值是有顺序的，但这只是命令式模型的原因，而不是它们的本质。

语句示例:

for
goto
return
if

(所有这些都意味着执行的行(语句)提前到另一行)

表达式示例:

2+2

(这并不是指执行，而是指评估)

这些概念的事实基础是:

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

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

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