İfade ve İfade

C # ile ilgili soruyorum, ama diğer birçok dilde aynı olduğunu varsayalım.

İfadelerin ve ifadelerin iyi bir tanımı var mı ve farklılıklar neler?

İfade: Bir değeri değerlendiren bir şey. Örnek: 1 + 2 / x
Açıklama: Bir şey yapan bir kod satırı. Örnek: GOTO 100

FORTRAN gibi en erken genel amaçlı programlama dillerinde, bu fark kristal berraklığındaydı. FORTRAN'da ifade bir yürütme birimiydi, yaptığınız bir şeydi. "Çizgi" olarak adlandırılmamasının tek nedeni, bazen birden çok satıra yayılmış olmasıdır. Tek başına bir ifade hiçbir şey yapamadı ... bunu bir değişkene atamak zorundaydınız.

1 + 2 / X

FORTRAN'da bir hata, çünkü hiçbir şey yapmıyor. Bu ifadeyle bir şeyler yapmak zorundaydınız:

X = 1 + 2 / X

FORTRAN'ın bugün bildiğimiz gibi bir grameri yoktu - bu fikir, Algol-60 tanımının bir parçası olarak Backus-Naur Formu (BNF) ile birlikte icat edildi. Bu noktada semantik ayrım ("bir şeye karşı" bir şey yap "yerine) bir sözdizimiyle ifade edildi: bir tür ifade bir ifadeydi ve diğeri bir ifadeydi ve ayrıştırıcı bunları birbirinden ayırabilirdi.

Daha sonraki dillerin tasarımcıları ayrımı bulanıklaştırdı: sözdizimsel ifadelerin bir şeyler yapmasına izin verdiler ve değerlere sahip sözdizimsel ifadelere izin verdiler. Hala hayatta kalan en eski popüler dil örneği C'dir. C tasarımcıları, bir ifadeyi değerlendirmenize ve sonucu atmanıza izin verilirse hiçbir zararın olmadığını fark ettiler. C'de, her sözdizimsel ifade, yalnızca bir noktalı virgülün sonuna doğru taranarak bir ifadeye dönüştürülebilir:

1 + 2 / x;

hiçbir şey olmayacak olmasına rağmen tamamen yasal bir ifadedir. Benzer şekilde, C'de bir ifadenin yan etkileri olabilir - bir şeyi değiştirebilir.

1 + 2 / callfunc(12);

çünkü callfuncyararlı bir şey yapabilir.

Herhangi bir ifadenin ifade olmasına izin verdikten sonra, atama operatörünün (=) ifadelerin içinde olmasına izin verebilirsiniz. Bu yüzden C,

callfunc(x = 2);

Bu, x = 2 (2'ye x değerini atama) ifadesini değerlendirir ve ardından (2) işlevine iletir callfunc.

İfadelerin ve ifadelerin bu şekilde bulanıklaştırılması, hala bazı ifadelere (gibi while) sahip olan ancak hemen hemen her ifadenin bir ifade olarak kullanılmasına izin veren tüm C türevlerinde (C, C ++, C # ve Java) meydana gelir (yalnızca C # atamasında, çağrı, artış ve azalma ifadeleri ifadeler olarak kullanılabilir; bkz. Scott Wisniewski'nin cevabı ).

İki "sözdizimsel kategoriye" (bu tür ifadelerin ve ifadelerin teknik adıdır) sahip olmak çabanın tekrarlanmasına yol açabilir. Örneğin, C'nin iki koşullu formu vardır, ifade formu

if (E) S1; else S2;

ve ifade formu

E ? E1 : E2

Ve bazen insanlar orada olmayan çoğaltma ister : örneğin standart C'de yalnızca bir ifade yeni bir yerel değişken bildirebilir - ancak bu yetenek, GNU C derleyicisinin bir ifadenin bir yerel değişken de.

Diğer dillerin tasarımcıları bu tür kopyalamayı sevmiyorlardı ve ifadelerin değerlerin yanı sıra yan etkileri de olabiliyorsa, ifadeler ve ifadeler arasındaki sözdizimsel ayrım o kadar da kullanışlı olmadığını gördüler - bundan kurtuldular . Haskell, Icon, Lisp ve ML sözdizimsel ifadeleri olmayan dillerdir - sadece ifadeleri vardır. Sınıfta yapılandırılmış döngü ve koşullu formlar bile ifadeler olarak kabul edilir ve değerlere sahiptir - ama çok ilginç değiller.

• bir ifade değer veren herhangi bir şeydir: 2 + 2
• bir ifade, program yürütmenin temel "bloklarından" biridir.

C'de "=" ifadesinin aslında iki şey yapan bir işleç olduğunu unutmayın:

• sağ alt ifadenin değerini döndürür.
• sağ alt ifadenin değerini sol taraftaki değişkene kopyalar.

İşte ANSI C dilbilgisinden bir alıntı. C'nin birçok farklı türde ifadesi olmadığını görebilirsiniz ... bir programdaki ifadelerin çoğu ifade ifadeleridir, yani sonunda noktalı virgül içeren bir ifadedir.

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

İfade, değer döndüren bir şeydir, ancak ifade vermez.

Örneğin:

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

İkisi arasındaki Büyük Anlaşma ifadeleri birbirine zincirleyebilmenizdir, oysa ifadeler zincirlenemez.

Bunu wikipedia'da bulabilirsiniz , ancak ifadeler bir değere göre değerlendirilirken, ifadelerin değerlendirilmiş bir değeri yoktur.

Bu nedenle, ifadeler ifadelerde kullanılabilir, ancak tam tersi şekilde kullanılamaz.

Bazı dillerin (Lisp ve ben Ruby'ye inanıyorum gibi pek çok dilin) ​​ifadeyi ifade ile ifade arasındaki farkı ayırt etmediğini unutmayın ... bu dillerde her şey bir ifade ve diğer ifadelerle zincirlenebilir.

İfadelerin ve ifadelerin birleştirilebilirliğindeki (zincirlenebilirlik) önemli farklılıkların açıklaması için en sevdiğim referans John Backus'un Turing ödül belgesi, Programlama von Neumann stilinden kurtarılabilir mi? .

Zorunlu diller (Fortran, C, Java, ...) programları yapılandırmaya yönelik ifadeleri vurgular ve bir tür düşünce sonrası ifadeleri içerir. İşlevsel diller ifadeleri vurgular. Tamamen işlevsel diller, ifadelerin tamamen ortadan kaldırılabileceğinden çok güçlü ifadelere sahiptir.

İfadeler bir değer elde etmek için değerlendirilebilirken, ifadeler bir değer döndürmez (bunlar geçersiz tiptedir ).

İşlev çağrısı ifadeleri de elbette ifadeler olarak kabul edilebilir, ancak yürütme ortamında döndürülen değeri tutmak için özel bir yerleşik değişken yoksa, onu almanın bir yolu yoktur.

Deyim yönelimli diller, tüm prosedürlerin bir deyimler listesi olmasını gerektirir. Muhtemelen tüm işlevsel diller olan ifadeye yönelik diller, ifade listeleridir veya LISP durumunda, ifadelerin listesini temsil eden uzun bir S ifadesidir.

Her iki tür de oluşturulabilse de, türler eşleştiği sürece çoğu ifade keyfi olarak oluşturulabilir. Her bir ifade türünün, eğer hepsini yapabiliyorsa, başka ifadeler oluşturmanın kendi yolu vardır. Foreach ve if ifadeleri, tek bir ifade gerektiriyorsa veya tüm alt ifadeler, alt bölümler kendi alt bölümlerine izin vermedikçe, birbiri ardına bir deyim bloğunda yer almaktadır.

İfadeler, bir ifadenin gerçekten herhangi bir ifade içermediği ifadeleri de içerebilir. Bununla birlikte, bir istisna, bir işlevi temsil eden bir lambda ifadesi olacaktır ve bu nedenle dil, Python'un tek ifadeli lambdasları gibi yalnızca sınırlı lambdalara izin vermediği sürece bir işlevin dahil edebileceği her şeyi içerebilir.

İfade tabanlı bir dilde, tüm kontrol yapıları bir değer döndürdüğü için (birçoğu NIL döndürür) bir işlev için tek ihtiyacınız olan tek bir ifadedir. İşlevdeki son değerlendirilen ifade döndürme değeri olduğundan döndürme ifadesine gerek yoktur.

Basitçe: bir ifade bir değeri değerlendirir, bir ifade değildir.

İfade tabanlı diller hakkında bazı şeyler:

En önemlisi: Her şey bir değer döndürür

Kod bloklarını ve ifadeleri sınırlamak için süslü parantezler ve parantezler arasında hiçbir fark yoktur, çünkü her şey bir ifadedir. Bu, sözcüksel kapsamayı engellemez: Örneğin, tanımının bulunduğu ifade ve bunun içindeki tüm ifadeler için yerel bir değişken tanımlanabilir.

İfade tabanlı bir dilde, her şey bir değer döndürür. Bu başlangıçta biraz garip olabilir - Ne (FOR i = 1 TO 10 DO (print i))dönüyor?

Bazı basit örnekler:

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

Birkaç daha karmaşık örnek:

• Bazı işlev çağrıları gibi bazı şeylerin gerçekten dönmesi için anlamlı bir değeri yoktur (Sadece yan etki üreten şeyler?). Arayan OpenADoor(), FlushTheToilet()ya TwiddleYourThumbs()böyle Yapıldı OK, ya Başarı olarak sıradan değeri, çeşit dönecektir.
• Birden fazla bağlantısız ifade bir büyük ifade içinde değerlendirildiğinde, büyük ifadede değerlendirilen son şeyin değeri büyük ifadenin değeri olur. Örneğin (FOR i = 1 TO 10 DO (print i)), for döngüsünün değeri "10" dur, (print i)ifadenin 10 kez değerlendirilmesine neden olur , her seferinde i bir dize olarak döner. İade yoluyla son kez 10, son cevabımız

İfade tabanlı bir dilden en iyi şekilde yararlanmak için genellikle hafif bir zihniyet değişikliği gerektirir, çünkü her şeyin bir ifade olması gerçeği, birçok şeyi 'satır içi' yapmayı mümkün kılar

Kısa bir örnek olarak:

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

ifadeye dayalı olmayanlar için tamamen geçerli bir alternatiftir

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

Bazı durumlarda, ifade tabanlı kodun izin verdiği düzen benim için çok daha doğal geliyor

Tabii ki, bu deliliğe yol açabilir. MaxScript adlı ifade tabanlı bir betik dilinde hobi projesinin bir parçası olarak, bu canavar çizgisini bulmayı başardım

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
)

İfade, voidtür içeren bir ifadenin özel bir halidir . Dillerin ifadeleri farklı şekilde ele alma eğilimi sıklıkla sorunlara neden olur ve uygun şekilde genelleştirilmeleri daha iyi olur.

Örneğin, C # 'da çok faydalı Func<T1, T2, T3, TResult>aşırı yüklenmiş genel delegeler kümesine sahibiz . Ancak aynı zamanda buna karşılık gelen bir setimiz Action<T1, T2, T3>olmalı ve bu talihsiz çatallanma ile başa çıkmak için genel amaçlı yüksek dereceli programlama sürekli olarak çoğaltılmalıdır.

Önemsiz örnek - başka bir işlevi çağırmadan önce başvurunun boş olup olmadığını kontrol eden bir işlev:

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

Derleyici TResultolma olasılığı ile başa çıkabilir voidmi? Evet. Tek yapması gereken, dönüşün ardından türden bir ifade gelmesidir void. Sonuç default(void)türü olabilir voidve aktarılan fonk formuna Func<TValue, void>(buna eşdeğer olacaktır Action<TValue>) sahip olmalıdır.

Diğer bazı cevaplar, ifadeleri olduğu gibi ifadeleri zincirleyemeyeceğiniz anlamına gelir, ancak bu fikrin nereden geldiğinden emin değilim. ;İfadelerden sonra ortaya çıkan durumun , iki tür ifadeyi alarak voidve bunları tek bir tür ifadesinde birleştirerek ikili bir infix operatörü olarak düşünebiliriz void.

İfadeler -> Sıralı olarak izlenecek talimatlar
İfadeler -> Değer döndüren değerlendirme

İfadeler temel olarak bir algoritmadaki adımlar veya talimatlar gibidir, bir ifadenin yürütülmesinin sonucu, talimat işaretçisinin (montajcıda denir) gerçekleştirilmesidir.

İfadeler ima etmez ve ilk bakışta icra emri verir, amaçları bir değeri değerlendirmek ve döndürmektir. Zorunlu programlama dillerinde, bir ifadenin değerlendirilmesinin bir sırası vardır, ancak bu sadece zorunlu modelden kaynaklanır, ancak bunların özü değildir.

İfadeler Örnekleri:

for
goto
return
if

(hepsi, icra hattının (ifade) başka bir satıra ilerlemesini ima eder)

İfadelere örnek:

2+2

(yürütme fikrini değil, değerlendirme fikrini ima eder)

Açıklama ,

Bir ifade, tüm C # programlarının oluşturulduğu yordamsal bir yapı taşıdır. Bir ifade yerel bir değişken veya sabit bildirebilir, bir yöntemi çağırabilir, bir nesne oluşturabilir veya bir değişken, özellik veya alana değer atayabilir.

Kıvırcık parantezlerle çevrili bir dizi ifade bir kod bloğu oluşturur. Yöntem gövdesi bir kod bloğunun bir örneğidir.

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

C # ifadeleri genellikle ifadeler içerir. C # 'daki bir ifade, değişmez değer, basit bir ad veya bir işleç ve işlenenleri içeren bir kod parçasıdır.

Anlatım ,

İfade, tek bir değer, nesne, yöntem veya ad alanına göre değerlendirilebilen bir kod parçasıdır. En basit iki ifade türü değişmez değerler ve basit adlardır. Değişmez, adı olmayan sabit bir değerdir.

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

Hem i hem de s, yerel değişkenleri tanımlayan basit adlardır. Bu değişkenler bir ifadede kullanıldığında, değişkenin değeri alınır ve ifade için kullanılır.

statementKelimenin biçimsel mantık anlamında anlamını tercih ederim . Hesaplamadaki bir veya daha fazla değişkenin durumunu değiştirerek değer (ler) i hakkında doğru veya yanlış bir ifade yapılmasına olanak tanıyan odur.

Sanırım bilgisayar dünyasında ve bilimde genel olarak yeni terminoloji veya kelimeler tanıtıldığında, mevcut kelimeler 'yeniden tasarlandı' veya kullanıcılar tarif ettikleri şey için mevcut, yerleşik veya 'uygun' terminolojiden habersiz olacaklardır.

Buradaki cevapların hiçbirinden gerçekten memnun değilim. C ++ (ISO 2008) dilbilgisine baktım . Bununla birlikte, belki didaktik ve programlama uğruna cevaplar iki unsuru ayırt etmek için yeterli olabilir (gerçeklik daha karmaşık görünmektedir).

Bir ifade sıfır veya daha fazla ifadeden oluşur, ancak diğer dil kavramları da olabilir. Bu dilbilgisi için Genişletilmiş Backus Naur formudur (ifade için alıntı):

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

C ++ 'da ifade olarak kabul edilen diğer kavramları görebiliriz.

• expression-expression s kendi kendini açıklar (bir ifade sıfır veya daha fazla ifadeden oluşabilir , dilbilgisini dikkatlice okuyabilir, zor olabilir)
• caseörneğin etiketli bir ifadedir
• Seçim-ifadesi ler vardır if if/else,case
• yineleme-deyim ler vardır while, do...while,for (...)
• sıçrama ifadesi ler vardır break, continue, return, (ifade dönebilir)goto
• beyan-beyanı bir dizi beyan
• try-block , try/catchblokları temsil eden ifadedir
• ve gramerde biraz daha olabilir

Bu ifadeler bölümünü gösteren bir alıntıdır:

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

• ifadeler genellikle ödevdir veya içerir
• koşullu ifade (sesler yanıltıcı) operatörlerin kullanımına atıfta ( +, -, *, /, &, |, &&, ||, ...)
• atış ifadesi - uh? throwmaddesi de bir ifadedir

İfadeler dilbilgisi bakımından tam cümlelerdir. İfadeler değildir. Örneğin

x = 5

"x 5 alır." Bu tam bir cümle. Kod

(x + 5)/9.0

"x artı 5'in tümü 9,0'a bölünmüş." Bu tam bir cümle değil. İfade

while k < 10: 
    print k
    k += 1

tam bir cümledir. Döngü üstbilgisinin olmadığına dikkat edin; "k <10 iken" bağımlı bir cümledir.

İşte bulduğum en basit cevaplardan birinin yaz mevsimi.

Tarafından cevap Anders Kaseorg

İfade, bazı eylemleri gerçekleştiren eksiksiz bir kod satırıdır; ifade ise kodun bir değeri değerlendiren herhangi bir bölümüdür.

İfadeler işleçler kullanılarak daha büyük ifadelerle “yatay olarak” birleştirilebilirken, ifadeler yalnızca birbiri ardına yazarak veya blok yapılarla “dikey” olarak birleştirilebilir.

Her ifade bir ifade olarak kullanılabilir (etkisi ifadeyi değerlendirmek ve elde edilen değeri yok saymaktır), ancak çoğu ifade ifade olarak kullanılamaz.

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

Bu kavramların fiili temeli:

İfadeler : Örneği bir değere göre değerlendirilebilen sözdizimsel bir kategori.

Açıklama : Örneği bir ifadenin değerlendirilmesinde yer alabilecek sözdizimsel bir kategori ve değerlendirmenin (eğer varsa) sonuç değerinin mevcut olduğu garanti edilmez.

On yılların başlarında FORTRAN'ın ilk bağlamının yanı sıra, kabul edilen cevaptaki ifade ve ifadelerin her ikisi de açıkça yanlıştır:

• İfadeler değerlenmemiş işlenen olabilir. Değerler asla onlardan üretilmez.
  • Katı olmayan değerlendirmelerdeki alt ifadeler kesinlikle değerlendirilmeyebilir.
    • Çoğu C benzeri dilde , yan etkilere rağmen nihai sonucu değiştirmeyen bazı alt ifade değerlendirmelerini şartlı olarak atlamak için kısa devre değerlendirme kuralları vardır.
  • C ve bazı C benzeri diller, dil spesifikasyonunda normatif olarak tanımlanabilen değerlendirilmemiş işlenen kavramına sahiptir. Bu tür yapılar, değerlendirmelerden kesinlikle kaçınmak için kullanılır, bu nedenle kalan bağlam bilgileri (örn. Türler veya hizalama gereksinimleri), program çevirisi sonrasındaki davranış değiştirilmeden statik olarak ayırt edilebilir.
    • Örneğin, sizeofoperatörün işleneni olarak kullanılan bir ifade hiçbir zaman değerlendirilmez.
• İfadelerin çizgi yapılarıyla hiçbir ilgisi yoktur. Dil özelliklerine bağlı olarak ifadelerden daha fazlasını yapabilirler.
  • Modern Fortran, eski FORTRAN'ın doğrudan torunu olarak, yürütülebilir deyim ler ve nonexecutable deyim s.
  • Benzer şekilde, C ++ bildirimleri bir çeviri biriminin en üst düzey alt kategorisi olarak tanımlar. C ++ 'da bir bildirim bir deyimdir. _{(Bu C'de doğru değildir.)} İfade ifadesi de vardır Fortran'ın yürütülebilir ifadeleri gibi .
  • İfadelerle karşılaştırmanın yararına yalnızca "yürütülebilir" ifadeler önemlidir. Ancak, ifadelerin bu tür zorunlu dillerde çeviri birimlerini oluşturan yapılar olarak genelleştirilmiş olduğu gerçeğini göz ardı edemezsiniz. Gördüğünüz gibi, kategorinin tanımları çok değişiyor. (Muhtemelen) sadece bu diller arasında korunan ortak özellik olarak kalmıştır, ifadelerin sözcük sırasına göre yorumlanması beklenmektedir (çoğu kullanıcı için soldan sağa ve yukarıdan aşağıya).

_{(BTW, C hakkındaki materyallerle ilgili bu cevaba [atıf gerekli] eklemek istiyorum, çünkü DMR'nin bu tür görüşlere sahip olup olmadığını hatırlayamıyorum. : özellikle virgül operatörü ifadelere karşı.)}

(Aşağıdaki mantık orijinal soruya doğrudan cevap değildir, ancak burada zaten cevaplanmış bir şeyi açıklığa kavuşturmanın gerekli olduğunu hissediyorum.)

Bununla birlikte, genel amaçlı programlama dillerinde belirli bir "deyim" kategorisine ihtiyacımız olduğundan şüphelenilmektedir:

• İfadelerin normal tasarımlardaki ifadelere göre daha semantik yetenekleri olduğu garanti edilmez.
  • Birçok dil, temiz, düzenli ve tutarlı genel tasarımlar elde etmek için ifade kavramını başarıyla terk etti.
    • Bu tür dillerde, ifadeler eski stil ifadelerinin yapabileceği her şeyi yapabilir: ifadeler değerlendirilirken, sonuçları açıkça belirtilmemiş bırakarak (örneğin, R ⁿ RS Şemasında) veya özel bir değere ( birim türünün değeri) normal ifade değerlendirmelerinden üretilemez.
    • İfadelerin değerlendirilmesine ilişkin sözcüksel düzen kuralları, açık sekans kontrol operatörü (örn. begin Şemada) veya monadik yapıların sözdizimsel şekeri ile değiştirilebilir.
    • Diğer tür "ifadelerin" sözcüksel sıra kuralları, benzer sözdizimsel işlevselliği elde etmek için sözdizimsel uzantılar (örneğin hijyenik makrolar kullanılarak) olarak türetilebilir. (Ve aslında daha fazlasını da yapabilir .)
  • Aksine, ifadeler böyle geleneksel kurallara sahip olamazlar, çünkü değerlendirmeye dayanmazlar: "alt değerlendirme değerlendirmesi" gibi yaygın bir kavram yoktur. _{(Varsa bile, mevcut ifade değerlendirme kurallarından kopyalayıp yapıştırmaktan çok daha fazlası olabileceğinden şüpheliyim.)}
    • Tipik olarak, deyimleri koruyan diller de hesaplamaları ifade etmek için ifadelere sahip olacaktır ve söz konusu alt kategori için ifade değerlendirmelerine korunmuş ifadelerin üst düzey bir alt kategorisi vardır. Örneğin, C ++ alt kategori olarak expression-deyimine sahiptir ve bu bağlamda tam ifade değerlendirmelerinin genel durumlarını belirtmek için atılan değer ifade değerlendirme kurallarını kullanır . C # gibi bazı diller, kullanım durumlarını basitleştirmek için bağlamları hassaslaştırmayı seçer, ancak spesifikasyonu daha fazla şişirir.
• Programlama dillerinin kullanıcıları için, ifadelerin önemi onları daha fazla karıştırabilir.
  • Dilde ifade ve ifade kurallarının ayrılması, bir dil öğrenmek için daha fazla çaba gerektirir.
  • Saf sözcüksel sıralama yorumu, daha önemli bir kavramı gizler: ifade değerlendirmesi. (Bu muhtemelen en sorunludur.)
    • İfadelerdeki tam ifadelerin değerlendirmeleri sözcüksel düzenle kısıtlı olsa bile, alt ifadeler (zorunlu olarak) değildir. Kullanıcılar nihayetinde bunu ifadelere eklenmiş kuralların dışında öğrenmelidir. (Bir acemi nasıl oluncaya kadar düşünün++i + ++i C'de anlamsız .)
    • Java ve C # gibi bazı diller, alt kuralların değerlendirilme sırasını, değerlendirme kurallarını bilmemesine izin verecek şekilde kısıtlar. Daha da sorunlu olabilir.
      • Bu, ifade değerlendirme fikrini daha önce öğrenmiş olan kullanıcılara fazlaca belirtilmiş gibi görünüyor. Ayrıca kullanıcı topluluğunu dil tasarımının bulanık zihinsel modelini izlemeye teşvik eder.
      • Dil özelliklerini daha da şişiriyor.
      • Daha karmaşık ilkel unsurlar ortaya çıkmadan önce, belirsizliğin değerlendirmelerdeki anlamlılığını eksik bırakarak optimizasyona zararlıdır.
    • C ++ gibi birkaç dil (özellikle C ++ 17), yukarıdaki sorunların bir uzlaşması olarak değerlendirme kurallarının daha ince bağlamlarını belirtir.
      • Dil özelliklerini çok fazla şişiriyor.
      • Bu, ortalama kullanıcılar için tamamen basitliğe aykırıdır ...

Peki neden ifadeler? Her neyse, tarih zaten bir karmaşa. Görünüşe göre çoğu dil tasarımcısı seçimlerini dikkatli bir şekilde almıyor.

Daha da kötüsü, bazı tip sistem meraklılarına (PL geçmişine yeterince aşina olmayanlar) bile, tip sistemlerinin operasyonel semantik üzerindeki daha temel kural tasarımlarıyla ilgili önemli şeylere sahip olması gerektiği konusunda bazı yanlış düşünceler verir.

Ciddi olarak, türlere bağlı olan akıl yürütme birçok durumda o kadar kötü değildir, ancak bu özel olanda özellikle yapıcı değildir. Uzmanlar bile işleri mahvedebilir.

Örneğin, birisi, iyi yazılmamış doğayı, süreksiz sürekliliklerin geleneksel muamelesine karşı merkezi bir argüman olarak vurgulamaktadır . Sonuç biraz makul olsa da ve birleşik fonksiyonlarla ilgili içgörüler OK ( ama yine de öz için çok naif ) olsa da, bu argüman sağlam değildir çünkü _Noreturn any_of_returnable_typeskodlamada (C11'de) gibi pratikte "yan kanal" yaklaşımını tamamen görmezden gelir Falsum. _{Ve açık konuşmak gerekirse, öngörülemeyen bir duruma sahip soyut bir makine "çökmüş bir bilgisayar" ile aynı değildir.}

Deyim yönelimli programlama dilinde, kod bloğu deyimlerin listesi olarak tanımlanır. Başka bir deyişle, ifade, bir sözdizimi hatasına neden olmadan bir kod bloğunun içine koyabileceğiniz bir sözdizimi parçasıdır.

Wikipedia kelime ifadesini benzer şekilde tanımlar

Bilgisayar programlamasında, ifade, gerçekleştirilmesi gereken bazı eylemleri ifade eden zorunlu bir programlama dilinin sözdizimsel birimidir. Böyle bir dilde yazılmış bir program, bir veya daha fazla ifadeden oluşan bir sıra ile oluşturulur

İkinci ifadeye dikkat edin. (bu durumda "bir program" teknik olarak yanlış olmasına rağmen, hem C hem de Java deyimlerden oluşan bir programı reddetmektedir.)

Wikipedia, ifade kelimesini şu şekilde tanımlar:

Programlama dilinde ifade, değerini belirlemek için değerlendirilebilen sözdizimsel bir varlıktır

Bununla birlikte, bu yanlıştır, çünkü Kotlin'de throw new Exception("")bir ifadedir, ancak değerlendirildiğinde, herhangi bir değer döndürmeyen bir istisna atar.

Statik olarak yazılan bir programlama dilinde, her ifadenin bir türü vardır. Ancak bu tanım dinamik olarak yazılmış bir programlama dilinde çalışmaz.

Şahsen, bir ifadeyi daha büyük bir ifade elde etmek için bir işleç veya işlev çağrıları ile oluşturulabilecek bir sözdizimi parçası olarak tanımlıyorum. Bu aslında Wikipedia'nın ifade açıklamasına benzer:

Programlama dilinin yorumladığı (özel öncelik ve ilişkilendirme kurallarına göre) başka bir değer üretmek ("geri dönmek") için başka bir değer üretmek için hesapladığı bir veya daha fazla sabit, değişken, işlev ve işleçlerin birleşimidir.

Ancak, executeS işlevi gibi C programlama dilinde sorun şöyledir:

void executeSomething(void){
    return;
}

Mı executeSomething()bir ifade ya da bir ifadedir? Benim tanımım gereği, bu bir açıklama çünkü Microsoft'un C referans dilbilgisinde tanımlandığı gibi,

Void türüne sahip bir ifadenin (var olmayan) değerini hiçbir şekilde kullanamazsınız ve void ifadesini (örtük veya açık dönüşümle) void dışındaki herhangi bir türe dönüştüremazsınız

Ancak aynı sayfa, bu sözdiziminin bir ifade olduğunu açıkça göstermektedir.

Önceki cevabımı geliştirmek ve doğrulamak için, programlama dili terimlerinin tanımları, uygulanabilir olduğunda bilgisayar bilimi türü teorisinden açıklanmalıdır.

Bir ifadenin Alt türü dışında bir türü vardır, yani bir değeri vardır. İfadenin Birim veya Alt türü vardır.

Bundan sonra, bir ifadenin bir programda yalnızca bir yan etki oluşturduğunda herhangi bir etkisi olabileceğinden, ya bir değer döndüremediğinden ya da yalnızca atanamayan Birim türünün değerini döndürdüğünden (örneğin bazı dillerde) bir C void ) veya (Scala'da olduğu gibi) ifadenin gecikmeli olarak değerlendirilmesi için saklanabilir.

Açıkçası a @pragmaveya a /*comment*/tipi yoktur ve bu nedenle ifadelerden ayrılır. Dolayısıyla, hiçbir yan etkisi olmayacak tek tür ifade işlem yapılmayacaktır. Çalışmama, yalnızca gelecekteki yan etkiler için bir yer tutucu olarak yararlıdır. İfadeden dolayı yapılacak her türlü işlem bir yan etki olacaktır. Yine derleyici ipucu, örneğin @pragma, türü olmadığı için bir ifade değildir.

En doğrusu, bir deyim olması gerekir "yan etkisi" (yani olması zorunludur ) ve bir ifade olmalıdır var bir değer türü (yani değil alt türü).

Bir ifadenin tipi birimi türü olmakla esas lokasyonlar için teoremi birim kurgudur nedeniyle öylesine diyelim alt türü .

Voidtam olarak alt tür değildir (tüm olası türlerin alt türü değildir). Tamamen ses tipi bir sisteme sahip olmayan dillerde mevcuttur . Bu kibirli bir ifade gibi gelebilir, ancak varyans açıklamaları gibi eksiksizlik, genişletilebilir yazılım yazmak için kritik öneme sahiptir.

Bakalım Wikipedia bu konuda neler söylüyor.

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

Bilgisayar programlamasında bir ifade, gerçekleştirilmesi gereken bazı eylemleri ifade eden zorunlu bir programlama dilinin en küçük bağımsız öğesidir .

Birçok dil (örn. C), yalnızca yürütülebilir kod içeren bir deyimle ve bir tanımlayıcı bildiren bir tanımla ifadeler ve tanımlar arasında bir ayrım yaparken, ifade yalnızca bir değeri değerlendirir.