Выражение против заявления

• выражение — это все, что дает значение: 2 + 2
• оператор — один из основных «блоков» выполнения программы.

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

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

Вот выдержка из грамматики 9X_expressions ANSI C. Вы можете видеть, что в C не так 9X_language-agnostic много различных типов операторов... большинство 9X_expression операторов в программе являются операторами-выражениями, то 9X_language-agnostic есть выражениями с точкой с запятой в конце.

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

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

Например:

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

Большая разница 9X_expression между ними заключается в том, что вы можете 9X_expressions соединять выражения вместе, тогда как операторы 9X_language-features не могут быть связаны.

Вы можете найти это на wikipedia, но выражения оцениваются 9X_language-independent по какому-то значению, а операторы не имеют 9X_language-agnostic оцениваемого значения.

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

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

Для объяснения важных различий в компоновке 9X_expression (цепочности) выражений и утверждений мне 9X_language-features больше всего нравится справочная статья 9X_language-features Джона Бэкуса, посвященная награде Тьюринга, Can programming be liberated from the von Neumann style?.

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

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

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

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

Хотя оба типа могут быть 9X_language-agnostic составлены, большинство выражений могут 9X_expressions быть составлены произвольно, если типы совпадают. У 9X_expressions каждого типа утверждений есть свой собственный 9X_language-independent способ составления других утверждений, если 9X_expression они могут сделать все это. Для операторов 9X_language-agnostic Foreach и if требуется либо один оператор, либо 9X_expressions все подчиненные операторы идут в блоке операторов 9X_language-independent один за другим, если только подоператоры 9X_expressions не допускают свои собственные подоператоры.

Операторы 9X_expressions также могут включать выражения, в которых 9X_language-features выражение на самом деле не содержит никаких 9X_language-features операторов. Единственным исключением, однако, может 9X_expression быть лямбда-выражение, которое представляет 9X_language-agnostic функцию и поэтому может включать все, что 9X_expression может включать функция, если только язык 9X_language-features не допускает только ограниченные лямбда-выражения, такие 9X_language-features как лямбда-выражения Python с одним выражением.

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

Просто: выражение оценивается как значение, оператор 9X_language-independent — нет.

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

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

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

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

Еще 9X_language-independent пара сложных примеров:

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

Чтобы получить максимальную 9X_expressions отдачу от языка, основанного на выражениях, часто 9X_language-independent требуется небольшое изменение мышления, поскольку 9X_language-agnostic тот факт, что все является выражением, позволяет 9X_language-independent "встроить" многие вещи

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

 FOR i = 1 to (IF MyString == "Hello, World!" THEN 10 ELSE 5) DO
 (
    LotsOfCode
 )

- вполне допустимая замена не основанного 9X_language-independent на выражении

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

В некоторых случаях макет, допускаемый 9X_language-agnostic кодом на основе выражений, кажется мне более 9X_expression естественным

Конечно, это может привести 9X_expressions к безумию. В рамках хобби-проекта на языке 9X_language-independent сценариев на основе выражений под названием 9X_expression MaxScript мне удалось придумать эту монструозную 9X_language-independent линию

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
)

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

Оператор состоит из нуля 9X_language-independent или более выражений, но также может быть 9X_language-features концепциями другого языка. Это расширенная 9X_expressions форма Бэкуса Наура для грамматики (отрывок 9X_language-features для утверждения):

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

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

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

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

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

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

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

Например, в C# у нас есть очень 9X_language-features полезный перегруженный набор универсальных 9X_expression делегатов Func. Но у нас также должен быть соответствующий 9X_expressions набор Action, и необходимо постоянно дублировать 9X_language-agnostic универсальное программирование высшего порядка, чтобы 9X_language-agnostic справиться с этой неудачной бифуркацией.

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

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

Может 9X_language-features ли компилятор справиться с возможностью 9X_language-independent того, что TResult будет void? да. Все, что ему нужно 9X_language-independent сделать, это потребовать, чтобы после return 9X_expressions следовало выражение типа void. Результат default(void) будет 9X_language-agnostic иметь тип void, а передаваемая функция должна 9X_expressions иметь форму Func (что эквивалентно Action).

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

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

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

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

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

for
goto
return
if

(все они подразумевают продвижение 9X_language-independent строки (оператора) исполнения на другую 9X_language-agnostic строку)

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

2+2

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

Фактическая основа этих концепций:

Выражения: синтаксическая 9X_language-features категория, экземпляр которой может быть 9X_language-independent оценен как значение.

Утверждение: синтаксическая категория, экземпляр 9X_expression которой может быть связан с оценками выражения, и 9X_expressions результирующее значение оценки (если есть) не 9X_language-features гарантируется доступной.

Помимо самого начального 9X_expressions контекста FORTRAN в первые десятилетия, как 9X_language-agnostic определения выражений, так и утверждения 9X_expression в принятом ответе явно неверны:

• Выражения могут быть неоцененными операндами. Ценности никогда не производятся из них.
  • Подвыражения в нестрогих вычислениях могут быть заведомо невычисленными.
    • В большинстве C-подобных языков есть так называемые правила short-circuit evaluation, позволяющие условно пропускать некоторые вычисления подвыражений, не изменяя окончательный результат, несмотря на побочные эффекты.
  • C и некоторые C-подобные языки имеют понятие невычисляемого операнда, которое может быть даже нормативно определено в спецификации языка. Такие конструкции используются, чтобы определенно избежать вычислений, поэтому оставшуюся контекстную информацию (например, типы или требования к выравниванию) можно статически различить без изменения поведения после трансляции программы.
    • Например, выражение, используемое в качестве операнда оператора sizeof, никогда не вычисляется.
• Операторы не имеют ничего общего со строковыми конструкциями. Они могут делать нечто большее, чем выражения, в зависимости от спецификаций языка.
  • Современный Фортран, как прямой потомок старого FORTRAN, имеет концепции исполняемых операторов и неисполняемых операторов.
  • Точно так же C++ определяет объявления как подкатегорию верхнего уровня единицы перевода. Объявление в C++ — это оператор. _{(Это неверно в C.)} Существуют также операторы-выражения, подобные исполняемым операторам Fortran.
  • Для сравнения с выражениями важны только «исполняемые» операторы. Но вы не можете игнорировать тот факт, что операторы уже обобщены, чтобы быть конструкциями, формирующими единицы перевода в таких императивных языках. Итак, как видите, определения категории сильно различаются. Единственным (вероятно) общим свойством, сохранившимся среди этих языков, является то, что операторы должны интерпретироваться в лексическом порядке (для большинства пользователей — слева направо и сверху вниз).

_{(Кстати, я хочу добавить [цитирование] к этому ответу по поводу материалов о C, потому что я не могу вспомнить, есть ли у DMR такие мнения. Вроде нет, иначе не должно быть причин для сохранения дублирования функциональности в дизайн C: в частности, оператор запятой против утверждений.)}

(Следующее 9X_language-features обоснование не является прямым ответом на 9X_language-independent первоначальный вопрос, но я считаю необходимым 9X_language-features уточнить то, на что здесь уже дан ответ.)

Тем 9X_expressions не менее сомнительно, что в языках программирования 9X_language-features общего назначения нужна особая категория 9X_language-features «операторов»:

• Не гарантируется, что операторы будут иметь больше семантических возможностей по сравнению с выражениями в обычном дизайне.
  • Многие языки уже успешно отказались от понятия операторов, чтобы получить чистый, аккуратный и согласованный общий дизайн.
    • В таких языках выражения могут делать все то же, что и операторы старого стиля: просто отбрасывать неиспользуемые результаты при вычислении выражений, либо оставляя результаты явно неопределенными (например, в схеме RⁿRS), или иметь специальное значение (как значение единичного типа), которое нельзя получить из вычислений нормальных выражений.
    • Правила лексического порядка вычисления выражений могут быть заменены явным оператором управления последовательностью (например, begin на схеме) или синтаксическим сахаром монадических структур.
    • Правила лексического порядка других видов «утверждений» могут быть получены как синтаксические расширения (например, с использованием гигиенических макросов), чтобы получить аналогичную синтаксическую функциональность. (И на самом деле может do more.)
  • Наоборот, в утверждениях не может быть таких условных правил, потому что они не строятся на вычислении: просто не существует такого общего понятия «вычисление подпредложения». _{(Даже если и есть, я сомневаюсь, что может быть что-то большее, чем копирование и вставка из существующих правил вычисления выражений.)}
    • Как правило, языки, сохраняющие операторы, также имеют выражения для выражения вычислений, и существует подкатегория операторов верхнего уровня, сохраняемых для вычислений выражений для этой подкатегории. Например, C++ имеет так называемый оператор-выражение в качестве подкатегории и использует правила вычисления выражения с отброшенным значением для указания общих случаев вычислений полного выражения в таком контексте. Некоторые языки, такие как C#, предпочитают уточнять контексты, чтобы упростить варианты использования, но это еще больше раздувает спецификацию.
• Пользователей языков программирования значение операторов может еще больше запутать.
  • Разделение правил выражений и утверждений в языках требует больше усилий для изучения языка.
  • Наивная интерпретация лексического порядка скрывает более важное понятие: оценку выражения. (Это, вероятно, самая проблематичная из всех.)
    • Даже вычисления полных выражений в утверждениях ограничены лексическим порядком, подвыражения — нет (обязательно). В конечном итоге пользователи должны усвоить это помимо любых правил, связанных с утверждениями. (Подумайте, как заставить новичка понять, что ++i + ++i не имеет смысла в C.)
    • Некоторые языки, такие как Java и C#, дополнительно ограничивают порядок вычислений подвыражений, допуская игнорирование правил вычисления. Это может быть еще более проблематично.
      • Пользователям, которые уже познакомились с идеей вычисления выражений, это кажется слишком конкретным. Это также побуждает сообщество пользователей следовать размытой ментальной модели языкового дизайна.
      • Это еще больше раздувает спецификацию языка.
      • Вредно для оптимизации упускать выразительность недетерминированности вычислений до введения более сложных примитивов.
    • Несколько языков, таких как C++ (в частности, C++17), определяют более тонкие контексты правил вычисления в качестве компромисса вышеперечисленных проблем.
      • Это сильно раздувает спецификацию языка.
      • Это полностью противоречит простоте для обычных пользователей...

Так почему заявления? Так или 9X_expression иначе, история уже запуталась. Похоже, что 9X_language-independent большинство разработчиков языков не очень 9X_language-independent тщательно подходят к своему выбору.

Хуже 9X_language-agnostic того, это даже дает некоторым энтузиастам 9X_expressions систем типов (которые недостаточно знакомы 9X_language-agnostic с историей PL) некоторые неверные представления 9X_language-features о том, что системы типов должны иметь важные 9X_language-independent вещи, связанные с более важными конструкциями 9X_language-independent правил операционной семантики.

Серьезно, рассуждения 9X_language-agnostic в зависимости от типов во многих случаях 9X_language-independent не так уж и плохи, но особенно неконструктивны 9X_language-independent в этом конкретном случае. Даже специалисты 9X_language-features могут все испортить.

Например, кто-то подчеркивает 9X_expression хорошо печатающий характер as the central argument against the traditional treatment of undelimited continuations. Хотя вывод 9X_language-agnostic несколько разумен, а понимание составных 9X_language-agnostic функций в порядке (but still far too naive to the essense), этот аргумент не является 9X_language-agnostic обоснованным, поскольку он полностью игнорирует 9X_expression практический подход «побочного канала», такой 9X_language-features как _Noreturn any_of_returnable_types (в C11) для кодирования Falsum . _{И, строго говоря, абстрактная машина с непредсказуемым состоянием не тождественна "зависшему компьютеру".}

Statement,

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

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

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

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

Expression,

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

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

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

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

Я 9X_expressions полагаю, что в компьютерном мире и науке 9X_expressions в целом всегда будет путаница, когда вводится 9X_language-features новая терминология или слова, существующие 9X_expression слова "перепрофилируются" или пользователи 9X_language-independent игнорируют существующую, устоявшуюся или 9X_language-independent "правильную" терминологию для того, что 9X_language-features они собой представляют. описывающий

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

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

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

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

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

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