Выражение против утверждения

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

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

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

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

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

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

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

Например:

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

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

Проще говоря: выражение дает значение, а оператор - нет.

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

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

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

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

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

1 + 2 / X

- это ошибка ФОРТРАНА, потому что он ничего не делает. Вы должны были что-то сделать с этим выражением:

X = 1 + 2 / X

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

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

1 + 2 / x;

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

1 + 2 / callfunc(12);

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

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

callfunc(x = 2);

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

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

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

if (E) S1; else S2;

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

E ? E1 : E2

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

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

• выражение - это все, что дает значение: 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

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

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

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

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

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

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

 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
)

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

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

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

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

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

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

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

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

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

x = 5

читается как «x получает 5.» Это полное предложение. Код

(x + 5)/9.0

гласит: «x плюс 5 все делится на 9,0». Это не полное предложение. Заявление

while k < 10: 
    print k
    k += 1

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

Точнее, оператор должен иметь "побочный эффект" (то есть быть обязательным), а выражение должно иметь тип имеютценить (т.е. не нижний тип).

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

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

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

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

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.

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

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

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

Примеры заявлений:

for
goto
return
if

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

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

2+2

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

Заявление,

Оператор - это процедурный строительный блок, из которого строятся все программы C#. Оператор может объявить локальную переменную или константу, вызвать метод, создать объект или присвоить значение переменной, свойству или полю.

Ряд операторов, заключенных в фигурные скобки, образуют блок кода. Тело метода - это один из примеров блока кода.

bool IsPositive(int number)
{
    if (number > 0)
    {
        return true;
    }
    else
    {
        return false;
    }
}

Операторы в C# часто содержат выражения. Выражение в C# - это фрагмент кода, содержащий буквальное значение, простое имя или оператор и его операнды.

Выражение,

Выражение - это фрагмент кода, который может быть оценен как одно значение, объект, метод или пространство имен. Двумя простейшими типами выражений являются литералы и простые имена. Литерал - это постоянное значение, у которого нет имени.

int i = 5;
string s = "Hello World";

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

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

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

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

Первоначально ответил Андерс Касеорг

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

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

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

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

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

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

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 самоочевиден (оператор может состоять из нуля или выражений более, внимательно прочтите грамматику, это сложно)
• case, например, помеченное заявление
• заявление о выборе - это ifif/else, case
• итерация-инструкция - это while, do...while, for (...)
• заявление о прыжке - это break, continue, return (может возвращать выражение), goto
• заявление-заявление - это набор объявлений
• пробный блок - оператор, представляющий блоки try/catch
• и может быть еще немного грамматики

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

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

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

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

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

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

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

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

Википедия определяет слово утверждение аналогично

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

Обратите внимание на последнее утверждение. (хотя «программа» в этом случае технически неверна, потому что и C, и Java отвергают программу, которая не состоит из операторов.)

Википедия определяет слово выражение как

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

Однако это неверно, потому что в Kotlin throw new Exception("") является выражением, но при оценке оно просто генерирует исключение, никогда не возвращая никакого значения.

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

Лично я определяю выражение как часть синтаксиса, которую можно составить с помощью вызова оператора или функции, чтобы получить более крупное выражение. На самом деле это похоже на объяснение выражения в Википедии:

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

Но проблема в языке программирования C, учитывая, что функция executeSome примерно такая:

void executeSomething(void){
    return;
}

executeSomething() - это выражение или утверждение? Согласно моему определению, это утверждение, потому что, как определено в справочной грамматике Microsoft C,

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

Но на той же странице ясно указано, что такой синтаксис является выражением.

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

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;

или же

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

Выражение

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.

Заявление

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.