Выражение Против Утверждения

Выражение: что-то, что оценивает в значение. Пример: 1+2/x
Утверждение: строка кода, которая что-то делает. Пример: GOTO 100

В самых ранних языках программирования общего назначения, таких как FORTRAN, это различие было кристально ясным. В FORTRAN году утверждение было одной единицей исполнения, то есть тем, что вы делали. Единственная причина, по которой он не назывался A "line", заключалась в том, что иногда он охватывал несколько строк. Выражение лица само по себе ничего не могло сделать... вы должны были назначить его переменной.

1 + 2 / X

это ошибка в FORTRAN, потому что он ничего не делает. Надо было что-то делать с этим выражением лица:

X = 1 + 2 / X

У FORTRAN не было grammar, как мы его знаем today—that идея была изобретена вместе с формой Бэкуса-Наура (BNF), как часть определения Алгола-60. В этот момент семантическое различие ("иметь значение" или "делать что-то") было закреплено в синтаксисе : один вид фразы был выражением, а другой-утверждением, и синтаксический анализатор мог различать их.

Дизайнеры более поздних языков размыли это различие: они позволяли синтаксическим выражениям делать вещи, а синтаксическим утверждениям позволяли иметь значения. Самый ранний популярный языковой пример, который еще сохранился, - это C. Дизайнеры C поняли, что никакого вреда не будет, если вам разрешат оценить выражение и выбросить результат. В C каждое синтаксическое выражение может быть превращено в утверждение, просто поставив точку с запятой в конце:

1 + 2 / x;

это абсолютно законное утверждение, хотя абсолютно ничего не произойдет. Аналогично, в C выражение может иметь побочные эффекты —it может что-то изменить.

1 + 2 / callfunc(12);

потому что callfunc может просто сделать что-то полезное.

Как только вы разрешите любому выражению быть оператором, вы также можете разрешить оператор присваивания (=) внутри выражений. Вот почему C позволяет вам делать такие вещи, как

callfunc(x = 2);

Это вычисляет выражение x = 2 (присваивая значение 2 x), а затем передает его (2) функции callfunc .

Это размытие выражений и операторов происходит во всех производных C (C, C++, C#, и Java), которые все еще имеют некоторые операторы (например, while), но которые позволяют использовать почти любое выражение в качестве оператора (в C# в качестве операторов могут использоваться только выражения присваивания, вызова, инкремента и декремента; см. ответ Скотта Вишневского ).

Наличие двух "syntactic categories" (что является техническим названием для такого рода вещей, как утверждения и выражения) может привести к дублированию усилий. Например, C имеет две формы условного выражения-форму оператора

if (E) S1; else S2;

и форма выражения

E ? E1 : E2

И иногда люди хотят дублирования, которого нет: например, в стандарте C только оператор может объявить новый локальный variable—but эта способность достаточно полезна, чтобы Компилятор GNU C обеспечивает расширение GNU, что позволяет выражение, чтобы объявить локальную переменную, а также.

Проектировщикам других языков не нравилось такое дублирование, и они рано поняли, что если выражения могут иметь побочные эффекты, а также значения, то синтаксическое различие между утверждениями и выражениями-это еще не все, от чего они избавились. Haskell, Icon, Lisp и ML-это все языки, которые не имеют синтаксических выражений statements—they, а имеют только выражения. Даже класс структурированных циклических и условных форм считается выражениями, и у них есть values—but не очень интересных.

Я хотел бы сделать небольшую поправку к ответу Джоэла выше.

C# не позволяет использовать все выражения в качестве операторов. В частности, в качестве операторов могут использоваться только выражения присваивания, вызова, инкремента и декремента.

Например, компилятор C# будет помечать следующий код как синтаксическую ошибку:

1 + 2;

• выражение-это все, что дает значение: 2 + 2
• оператор является одним из основных "blocks" выполнения программы.

Обратите внимание, что в C " = " на самом деле является оператором, который выполняет две вещи:

• возвращает значение правого подвыражения.
• копирует значение правого подвыражения в переменную с левой стороны.

Вот выдержка из Анси C grammar. Вы можете видеть, что 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

Выражение-это то, что возвращает значение, а оператор-нет.

За примерами:

1 + 2 * 4 * foo.bar()     //Expression
foo.voidFunc(1);          //Statement

Самое большое различие между ними заключается в том, что вы можете связывать выражения вместе, в то время как операторы не могут быть связаны.

Вы можете найти это в Википедии, но выражения оцениваются до некоторого значения, в то время как операторы не имеют оцененного значения.

Таким образом, выражения могут использоваться в операторах, но не наоборот.

Обратите внимание, что некоторые языки (такие как Lisp, и я считаю Ruby, и многие другие) не различают оператор и выражение... в таких языках все является выражением и может быть связано с другими выражениями.

Для объяснения важных различий в композиционности (цепочечности) выражений и утверждений Я предпочитаю использовать статью Джона Бэкуса о премии Тьюринга " можно ли освободить Программирование от стиля фон Неймана? ". .

Императивные языки (Fortran, C, Java,...) подчеркивают высказывания для структурирования программ и имеют выражения в качестве своего рода послесмысла. Функциональные языки подчеркивают выражения. Чисто функциональные языки обладают такими мощными выражениями, что их можно полностью исключить.

Выражения могут быть вычислены для получения значения, в то время как операторы не возвращают значение (они имеют тип void ).

Конечно, выражения вызова функций также можно считать операторами, но если в среде выполнения нет специальной встроенной переменной для хранения возвращаемого значения, то ее невозможно получить.

Языки, ориентированные на операторы, требуют, чтобы все процедуры были списком операторов. Языки, ориентированные на выражение, которые, вероятно, являются всеми функциональными языками, представляют собой списки выражений или, в случае LISP, одно длинное S-выражение, представляющее собой список выражений.

Хотя оба типа могут быть составлены, большинство выражений могут быть составлены произвольно, пока типы совпадают. Каждый тип операторов имеет свой собственный способ составления других операторов, если они могут сделать это все. Foreach и если операторы требуют либо одного утверждения, либо того, чтобы все подчиненные операторы шли в блоке операторов один за другим, если только подстанции не допускают их собственные подстанции.

Операторы также могут включать выражения, в которых выражение на самом деле не содержит никаких операторов. Одним исключением, однако, было бы выражение lambda, которое представляет функцию, и поэтому может включать все, что функция может включить, если только язык не допускает только ограниченные лямбды, такие как лямбды с одним выражением Python.

В языке, основанном на выражениях, все, что вам нужно, - это одно выражение для функции, поскольку все структуры управления возвращают значение (многие из них возвращают NIL). В операторе return нет необходимости, так как последнее вычисленное выражение в функции является возвращаемым значением.

Просто: выражение вычисляет значение, а оператор-нет.

Оператор-это частный случай выражения с типом void . Склонность языков по-разному трактовать высказывания часто вызывает проблемы, и было бы лучше, если бы они были правильно обобщены.

Например, в C# мы имеем очень полезный Func<T1, T2, T3, TResult> перегруженный набор универсальных делегатов. Но мы также должны иметь соответствующий набор Action<T1, T2, T3> , и общее Программирование высшего порядка постоянно должно дублироваться, чтобы справиться с этой неудачной бифуркацией.

Тривиальный пример-функция, которая проверяет, является ли ссылка null перед вызовом другой функции:

TResult IfNotNull<TValue, TResult>(TValue value, Func<TValue, TResult> func)
                  where TValue : class
{
    return (value == null) ? default(TValue) : func(value);
}

Может ли компилятор иметь дело с возможностью TResult быть void ? Да. Все, что ему нужно сделать, это потребовать, чтобы за возвращением последовало выражение типа void . Результат default(void) будет иметь тип void, а передаваемый func должен иметь вид Func<TValue, void> (что будет эквивалентно Action<TValue> ).

Многие другие ответы подразумевают, что вы не можете связывать утверждения, как вы можете это сделать с выражениями, но я не уверен, откуда взялась эта идея. Мы можем думать о ; , который появляется после операторов как двоичный оператор инфикса, беря два выражения типа void и объединяя их в одно выражение типа void .

Некоторые вещи о языках на основе выражений:

Самое главное: все возвращает значение

Нет никакой разницы между фигурными скобками и фигурными скобками для разграничения блоков кода и выражений, так как все является выражением. Однако это не мешает лексической области: локальная переменная может быть определена для выражения, в котором содержится ее определение, и всех операторов, содержащихся в нем, например.

В языке, основанном на выражениях, все возвращает значение. Поначалу это может показаться немного странным - что возвращает (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

Несколько более сложных примеров:

• Некоторые вещи, такие как некоторые вызовы функций, на самом деле не имеют значимого значения для возврата (вещи, которые вызывают только побочные эффекты?). Вызов OpenADoor(), FlushTheToilet() или TwiddleYourThumbs() вернет какое-то обычное значение, например OK, Done или Success.
• Когда в одном большем выражении вычисляется несколько несвязанных выражений, значение последней вещи, вычисленной в большом выражении, становится значением большого выражения. Если взять пример (FOR i = 1 TO 10 DO (print i)), то значение цикла for равно "10", он заставляет выражение (print i) вычисляться 10 раз, каждый раз возвращая i в виде строки. Последний раз через returns 10, наш окончательный ответ

Это часто требует небольшого изменения мышления, чтобы получить максимальную отдачу от языка, основанного на выражении, так как тот факт, что все является выражением, позволяет 'inline' многое сделать

В качестве быстрого примера:

 FOR i = 1 to (IF MyString == "Hello, World!" THEN 10 ELSE 5) DO
 (
    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
)

Инструкции - > инструкции для последовательного выполнения
Выражения - > вычисление, которое возвращает значение

Операторы в основном похожи на шаги или инструкции в алгоритме, результатом выполнения оператора является актуализация указателя инструкции (так называемый в ассемблере)

Выражения не подразумевают и порядок выполнения на первый взгляд, их цель-оценить и вернуть значение. В императивных языках программирования оценка выражения имеет порядок, но это только из-за императивной модели, но это не является их сущностью.

Примеры утверждений:

for
goto
return
if

(все они подразумевают продвижение строки (оператора) исполнения к другой строке)

Пример выражений:

2+2

(это подразумевает не идею исполнения, а оценку)

Высказывания-это грамматически законченные предложения. Выражений нет. Например

x = 5

читается как "x gets 5." это полное предложение. Код

(x + 5)/9.0

читает: "x плюс 5 все делится на 9.0.- Это еще не все предложение. Заявление

while k < 10: 
    print k
    k += 1

это полное предложение. Обратите внимание, что заголовок цикла не является; "while k < 10," является подчиняющим предложением.

Заявление

Я предпочитаю значение statement в формально-логическом смысле этого слова. Это тот, который изменяет состояние одной или нескольких переменных в вычислении, позволяя сделать истинное или ложное утверждение об их значении(значениях).

Я думаю, что всегда будет путаница в вычислительном мире и науке в целом, когда вводится новая терминология или слова, существующие слова являются 'repurposed' или пользователи не знают о существующей, установленной или 'proper' терминологии для того, что они описывают

Я действительно не удовлетворен ни одним из ответов здесь. Я посмотрел на grammar для C++ (ISO 2008) . Однако, возможно, ради дидактики и программирования ответов будет достаточно, чтобы различить эти два элемента (хотя реальность выглядит более сложной).

Оператор состоит из нуля или более выражений, но также может быть и другими языковыми понятиями. Это расширенная форма Backus Naur для grammar (выдержка для утверждения):

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

Мы можем видеть другие понятия, которые рассматриваются как операторы в C++.

• выражение-оператор s является самоописывающимся (оператор может состоять из нуля или более выражений, внимательно прочитайте grammar, это сложно)
• Например, case -это помеченный оператор
• выбор-заявление с if if/else , case
• итерация-оператор s - это while , do...while , for (...)
• jump-оператор s - это break, continue, return (может возвращать выражение), goto
• декларация-заявление - это совокупность деклараций
• try-block -Это оператор, представляющий try/catch блоков
• и там может быть еще несколько вниз по grammar

Это отрывок, показывающий часть выражений:

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

• выражения часто являются или содержат назначения
• условное выражение (звучит обманчиво) относится к использованию операторов ( + , - , * , / , & , | , && , || , ...)
• бросок-выражение -а? предложение throw тоже является выражением

Вот лето одного из самых простых ответов, которые я нашел.

изначально ответил Андерс Kaseorg

Оператор - это полная строка кода, которая выполняет некоторое действие, а выражение-это любой раздел кода, который вычисляет значение.

Выражения могут быть объединены “horizontally” в более крупные выражения с помощью операторов, в то время как операторы могут быть объединены только “vertically” путем записи друг за другом или с помощью блочных конструкций.

Каждое выражение может быть использовано в качестве оператора (эффект которого заключается в вычислении выражения и игнорировании результирующего значения), но большинство операторов не могут использоваться в качестве выражений.

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

Чтобы улучшить и подтвердить мой предыдущий ответ, определения терминов языка программирования должны быть объяснены из теории типов компьютерных наук, когда это применимо.

Выражение имеет тип, отличный от нижнего типа, т. е. оно имеет значение. Оператор имеет тип Unit или Bottom.

Из этого следует, что оператор может иметь какой-либо эффект в программе только тогда, когда он создает побочный эффект, потому что он либо не может возвращать значение, либо возвращает только значение типа единицы, которое либо не может быть присвоено (в некоторых языках, таких как C's void), либо (например, в Scala) может быть сохранено для отложенной оценки оператора.

Очевидно, что a @pragma или a /*comment*/ не имеют никакого типа и поэтому отличаются от утверждений. Таким образом, единственным типом утверждения, которое не имело бы побочных эффектов, было бы отсутствие операции. Бездействие полезно только как заполнитель для будущих побочных эффектов. Любое другое действие, вызванное заявлением, будет побочным эффектом. Опять же, подсказка компилятора, например @pragma, не является оператором, потому что она не имеет типа.

Наиболее точно, оператор должен иметь "side-effect" (т. е. быть императивным), а выражение должно иметь тип значения (т. е. не нижний тип).

Тип утверждения -это тип единицы, но из-за остановки теоремы единица является фикцией, так что давайте скажем Нижний тип .

Void -это не совсем Нижний тип (это не подтип всех возможных типов). Он существует в языках, которые не имеют полностью звуковой системы типов . Это может звучать как снобистское утверждение, но полнота, такая как аннотации дисперсии , имеет решающее значение для написания расширяемого программного обеспечения.

Давайте посмотрим, что говорит Википедия по этому поводу.

https://en.wikipedia.org/wiki/Statement_(вычислительная_техника)

В компьютерном программировании оператор - это самый маленький автономный элемент императивного языка программирования, который выражает некоторое действие , подлежащее выполнению.

Многие языки (например C) провести различие между операторами и определениями, причем оператор содержит только исполняемый код, а определение объявляет идентификатор, в то время как выражение оценивает только значение.