Wyrażenie A Stwierdzenie

Chciałbym dokonać małej korekty powyższej odpowiedzi Joela.

C# nie zezwala na używanie wszystkich wyrażeń jako instrukcji. W szczególności jako instrukcji mogą być używane tylko wyrażenia assignment, call, increment i decrement.

Na przykład kompilator C# będzie oznaczał następujący kod jako błąd składni:

1 + 2;

• wyrażenie to wszystko, co daje wartość: 2 + 2
• Instrukcja jest jednym z podstawowych "bloków" wykonania programu.

Zauważ, że w C, " = " jest faktycznie operatorem, który robi dwie rzeczy:

• Zwraca wartość podwyrażenia prawej ręki.
• kopiuje wartość podwyrażenia prawej ręki do zmiennej po lewej stronie.

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

Wyrażenie jest czymś, co zwraca wartość, podczas gdy polecenie nie.

Na przykład:

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

Wielka sprawa między nimi polega na tym, że można łączyć wyrażenia ze sobą, podczas gdy wypowiedzi nie mogą być połączone łańcuchami.

Można to znaleźć na Wikipedii , ale wyrażenia są oceniane do pewnej wartości, podczas gdy wyrażenia nie mają wartości ocenianej.

Tak więc wyrażenia mogą być używane w wyrażeniach, ale nie odwrotnie.

Zauważ, że niektóre języki (takie jak Lisp, i wierzę, że Ruby i wiele innych) nie rozróżniają wyrażeń Od wyrażeń... w takich językach wszystko jest wyrażeniem i może być połączone łańcuchami z innymi wyrażeniami.

Dla wyjaśnienia istotnych różnic w składowości (łańcuchowości) wyrażeń vs wypowiedzi, moim ulubionym punktem odniesienia jest praca Johna Backusa z nagrodą Turinga, czy programowanie można wyzwolić ze stylu von Neumanna?.

Języki imperatywne (Fortran, C, Java, ...) podkreślają wypowiedzi dla programów strukturyzujących i mają wyrażenia jako rodzaj przemyślenia. Języki funkcyjne podkreślają wyrażenia. czysto języki funkcyjne mają takie potężne wyrażenia niż wyrażenia można całkowicie wyeliminować.

Po prostu: wyrażenie oblicza wartość, instrukcja nie.

Wyrażenia mogą być obliczane w celu uzyskania wartości, podczas gdy polecenia nie zwracają wartości (są typu void).

Wyrażenia wywołania funkcji mogą być oczywiście traktowane jako instrukcje, ale jeśli środowisko wykonawcze nie ma specjalnej wbudowanej zmiennej do przechowywania zwracanej wartości, nie ma możliwości jej odzyskania.

Języki zorientowane na instrukcje wymagają, aby wszystkie procedury były listą instrukcji. Języków zorientowanych ekspresyjnie, które prawdopodobnie wszystkie funkcjonalne języki, są listami wyrażeń, lub w przypadku Lispu, jednym długim S-wyrażeniem, które reprezentuje listę wyrażeń.

Chociaż oba typy mogą być komponowane, większość wyrażeń może być składana arbitralnie, o ile typy się zgadzają. Każdy typ wypowiedzi ma swój własny sposób komponowania innych wypowiedzi, jeśli potrafią to wszystko. Foreach i jeśli polecenia wymagają albo pojedynczego oświadczenia, albo że wszystkie polecenia podrzędne przechodzą do bloku instrukcji, jeden po drugim, chyba że podstatements pozwalają na własne podstatements.

Instrukcje mogą również zawierać wyrażenia, gdzie wyrażenie tak naprawdę nie zawiera żadnych instrukcji. Jednym z WYJĄTKÓW byłoby wyrażenie lambda, które reprezentuje funkcję, a więc może zawierać wszystko, co może zawierać funkcja, chyba że język zezwala tylko na ograniczone lambda, jak w Pythonie lambda z pojedynczym wyrażeniem.

W języku opartym na wyrażeniach, wszystko, czego potrzebujesz, to pojedyncze wyrażenie dla funkcji, ponieważ wszystkie struktury kontrolne zwracają wartość (wiele z nich zwraca wartość NIL). Nie ma potrzeby stosowania instrukcji return, ponieważ ostatnio obliczone wyrażenie w funkcji jest wartością zwracaną.

Niektóre rzeczy o językach opartych na wyrażeniach:

Najważniejsze: wszystko zwraca wartość

Nie ma różnicy między nawiasami klamrowymi a klamrami do oddzielania bloków kodu i wyrażeń, ponieważ wszystko jest wyrażeniem. Nie wyklucza to jednak zakresu leksykalnego: zmienna lokalna może być zdefiniowana dla wyrażenia, w którym zawarta jest jej definicja, i wszystkich zawartych w niej wyrażeń, na przykład.

W język oparty na wyrażeniach, wszystko zwraca wartość. To może być trochę dziwne na początku -- co (FOR i = 1 TO 10 DO (print i)) zwraca?

Kilka prostych przykładów:

• (1) zwraca 1
• (1 + 1) zwraca 2
• (1 == 1) zwraca TRUE
• (1 == 2) zwraca FALSE
• (IF 1 == 1 THEN 10 ELSE 5) zwraca 10
• (IF 1 == 2 THEN 10 ELSE 5) zwraca 5

Kilka bardziej złożonych przykładów:

• niektóre rzeczy, takie jak niektóre wywołania funkcji, naprawdę nie mają sensowną wartość do zwrotu (rzeczy, które powodują tylko skutki uboczne?). Wywołanie OpenADoor(), FlushTheToilet() lub TwiddleYourThumbs() zwróci jakąś przyziemną wartość, taką jak OK, Done lub Success.
• gdy w jednym większym wyrażeniu jest obliczane wiele nie powiązanych wyrażeń, wartość ostatniej rzeczy obliczonej w dużym wyrażeniu staje się wartością dużego wyrażenia. Dla przykładu (FOR i = 1 TO 10 DO (print i)), wartość pętli for wynosi "10", powoduje to, że wyrażenie (print i) jest oceniane 10 razy, każdy czas wraca ja jako ciąg. Ostatni czas poprzez zwraca 10, nasza ostateczna odpowiedź

Jako szybki przykład:

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

Jest całkowicie poprawnym zamiennikiem dla wyrażenia nie opartego na

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

W niektórych przypadkach układ, który kod oparty na wyrażeniach wydaje mi się dużo bardziej naturalny.]} Oczywiście, może to prowadzić do szaleństwa. W ramach hobbystycznego projektu w języku skryptowym opartym na wyrażeniach o nazwie MaxScript, udało mi się wymyślić tę linię potworów

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
)

Wyrażenie jest szczególnym przypadkiem wyrażenia, o typie void. Tendencja języków do odmiennego traktowania wypowiedzi często powoduje problemy i lepiej byłoby, gdyby były odpowiednio uogólnione.

Na przykład, w C# mamy bardzo użyteczny Func<T1, T2, T3, TResult> przeciążony zestaw ogólnych delegatów. Ale musimy również mieć odpowiedni zestaw Action<T1, T2, T3>, a Ogólne programowanie wyższego rzędu musi być stale powielane, aby poradzić sobie z tym nieszczęsnym rozwidlenie.

Trywialny przykład-funkcja, która sprawdza, czy Referencja jest null przed wywołaniem innej funkcji:

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

Czy kompilator mógłby sobie poradzić z możliwością, że TResult będzie void? Tak. Wystarczy, że po return nastąpi wyrażenie typu void. Wynik default(void) będzie typu void, A przekazywany func będzie musiał mieć postać Func<TValue, void> (co byłoby równoważne Action<TValue>).

Szereg innych odpowiedzi sugerują, że nie można łączyć wyrażeń jak można z wyrażeniami, ale nie jestem pewien, skąd ten pomysł pochodzi. Możemy myśleć o ;, który pojawia się po poleceniach jako binarny operator infiksu, pobierając dwa wyrażenia typu void i łącząc je w jedno wyrażenie typu void.

Statements - > Instructions to follow sequentially
Wyrażenia - > ocena zwracająca wartość

Instrukcje są w zasadzie jak kroki, czyli instrukcje w algorytmie, wynikiem wykonania instrukcji jest aktualizacja wskaźnika instrukcji (tzw. w asemblerze)

Wyrażenia nie implikują i wykonują rozkaz na pierwszy rzut oka, ich celem jest oszacowanie i zwrócenie wartości. W imperatywnych językach programowania ocena wyrażenia ma porządek, ale jest to tylko z powodu modelu imperatywnego, ale nie jest to ich istota.

Przykłady wypowiedzi:

for
goto
return
if

(wszystkie implikują przejście linii (instrukcji) wykonania do innej linii)

Przykład wyrażeń:

2+2

Wyrażenia to zdania pełne gramatycznie. Wyrażenia nie są. Na przykład

x = 5

Czyta jako " X dostaje 5."To jest pełne zdanie. Kod

(x + 5)/9.0

Czyta: "x plus 5 Wszystkie podzielone przez 9.0."To nie jest pełne zdanie. Oświadczenie

while k < 10: 
    print k
    k += 1

Jest pełnym zdaniem. Zauważ, że nagłówek pętli nie jest; "while k

Oświadczenie,

Instrukcja jest proceduralnym budulcem, z którego zbudowane są wszystkie programy C#. Polecenie może zadeklarować zmienną lokalną lub stałą, wywołać metodę, utworzyć obiekt lub przypisać wartość do zmiennej, Właściwości lub pola.

Szereg wypowiedzi otoczonych klamrami tworzy blok kodu. Ciało metody jest jednym z przykładów bloku kodu.

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

Wyrażenia w C# często zawierają wyrażenia. Wyrażenie w C# jest fragmentem kod zawierający wartość literałową, prostą nazwę lub operator i jego operandy.

Wyrażenie,

Wyrażenie jest fragmentem kodu, który może być oceniany do pojedynczej wartości, obiektu, metody lub przestrzeni nazw. Dwa najprostsze typy wyrażeń to literały i proste nazwy. Literał to stała, która nie ma nazwy.

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

ZARÓWNO i jak i s są prostymi nazwami identyfikującymi zmienne lokalne. Gdy zmienne te są używane w wyrażeniu, wartość zmienna jest pobierana i używana do wyrażenia.

Wolę znaczenie statement w sensie logiki formalnej tego słowa. Jest to taki, który zmienia stan jednej lub więcej zmiennych w obliczeniach, umożliwiając prawdziwe lub fałszywe oświadczenie o ich wartości(s).

Myślę, że zawsze będzie zamieszanie w świecie komputerów i nauki w ogóle, gdy nowa terminologia lub słowa są wprowadzane, istniejące słowa są "repurposed" lub użytkownicy są nieświadomi istniejącej, ustalonej lub "właściwej" terminologii dla tego, czym są opisujący

Nie jestem usatysfakcjonowany żadną z odpowiedzi tutaj. Przyjrzałem się gramatyce C++ (ISO 2008) . Być może jednak ze względu na dydaktykę i programowanie odpowiedzi mogą wystarczyć do rozróżnienia tych dwóch elementów (rzeczywistość wygląda jednak na bardziej skomplikowaną).

Wyrażenie składa się z zera lub więcej wyrażeń, ale może być również innymi pojęciami językowymi. Jest to rozszerzona forma Backus Naur dla gramatyki (fragment dla stwierdzenia):

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

Widzimy drugą pojęcia, które są uważane za wyrażenia w C++.

• wyrażenie-twierdzenie S jest samo wyjaśniające (twierdzenie może składać się z zera lub więcej wyrażeń, przeczytaj uważnie gramatykę, to trudne)
• case na przykład jest oznakowane-oświadczenie
• selection-statementS są if if/else, case
• iteracja-twierdzenieS są while, do...while, for (...)
• jump-statements are break, continue, return (can return expression), goto
• deklaracja-deklaracja jest zbiorem deklaracji
• try-block jest deklaracją reprezentującą try/catch bloki
• i może być jeszcze trochę gramatyki

To jest fragment pokazujący część wyrażenia:

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

• wyrażenia są lub zawierają często przypisania
• wyrażenie warunkowe (Dźwięki mylące) odnosi się do użycia operatorzy (+, -, *, /, &, |, &&, ||, ...)
• throw-expression - uh? klauzula {[22] } jest również wyrażeniem

Oto podsumowanie jednej z najprostszych odpowiedzi, jakie znalazłem.

Oryginalnie odpowiedział Anders Kaseorg

Instrukcja jest kompletną linią kodu, która wykonuje jakąś akcję, podczas gdy wyrażenie jest dowolną sekcją kodu, która ocenia wartość.

Wyrażenia mogą być łączone " poziomo "w większe wyrażenia za pomocą operatorów, podczas gdy wyrażenia mogą być łączone" pionowo " przez pisanie jeden po drugim lub za pomocą konstrukcji blokowych.

Każdy wyrażenie może być użyte jako polecenie (którego efektem jest obliczenie wyrażenia i zignorowanie wynikowej wartości), ale większość poleceń nie może być użyta jako wyrażenie.

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

Aby poprawić i potwierdzić moją wcześniejszą odpowiedź, definicje terminów w języku programowania powinny być wyjaśnione z teorii typów informatyki, gdy mają zastosowanie.

Wyrażenie ma typ inny niż Typ Dolny, tzn. ma wartość. Instrukcja ma typ Unit lub Bottom.

Z tego wynika, że polecenie może mieć jakikolwiek efekt w programie tylko wtedy, gdy tworzy efekt uboczny, ponieważ albo nie może zwrócić wartości lub zwraca tylko wartość typu Unit co jest albo nieassignable (w niektórych językach, takich jak C void) lub (np. w Scali) mogą być przechowywane dla opóźnionej oceny instrukcji.

OczywiĹ "cie a @pragma lub a /*comment*/ nie majÄ ... typu i dlatego sÄ ... odrăłĺźnione od twierdzeĺ". Tak więc jedynym rodzajem stwierdzenia, które nie miałoby skutków ubocznych, byłoby brak operacji. Brak działania jest użyteczny tylko jako element zastępczy dla przyszłych efektów ubocznych. Wszelkie inne działania wynikające z Oświadczenia byłyby efektem ubocznym. Znowu podpowiedź kompilatora, np. @pragma, nie jest stwierdzeniem, ponieważ nie ma typu.

Najbardziej precyzyjnie, wyrażenie musi mieć "efekt uboczny" (tzn. Być imperatywem), a wyrażenie musi mieć awartość (tzn. nie jest to typ dolny).

Typ twierdzenia jest typem jednostkowym, ale z powodu twierdzenia o zatrzymaniu jednostka jest fikcją, więc powiedzmy typ Dolny.

Void nie jest dokładnie typem dolnym (nie jest to podtyp wszystkich możliwych typów). Istnieje w językach, które nie mają całkowicie sound type system . Może to brzmieć jak snobistyczne stwierdzenie, ale kompletność , taka jak adnotacje wariancji , jest krytyczna przy pisaniu rozszerzalnego oprogramowania.

Zobaczmy, co Wikipedia ma do powiedzenia w tej sprawie.

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

W programowaniu komputerowym instrukcja jest najmniejszym samodzielnym elementem imperatywu języka programowania wyrażającego pewne działanie do wykonania.

Wiele języków (np. C) rozróżnia instrukcje i definicje, przy czym instrukcja zawiera tylko kod wykonywalny i definicję deklarującą identyfikator, podczas gdy wyrażenie jest ewaluowane tylko do wartości.