Tanımlayıcılardaki boşluk hiç aptalca oldu mu? [kapalı]

C # stili, sözcükleri sınırlandırmak için tanımlayıcılarda CamelCase kullanılmasını önerir . Lisp geleneği yerine-tire kullanarak önerir.

Tanımlayıcılarda boşluk kullanımına sadece izin vermekle kalmadı, aynı zamanda çok kelimeli tanımlayıcıları kullanırken yaygın olarak kullanılan bir deyim oldu mu?

Bazı Şema uygulamalarında boşluk içeren tanımlayıcılara sahip olmak mümkündür , ancak bu yaygın olarak görülen bir uygulama değildir. İşte bir örnek:

Petite Chez Scheme Version 8.4
Copyright (c) 1985-2011 Cadence Research Systems

> (define |hey there| 100)
> (define |x y z| 200)
> (list |hey there| |x y z|)
(100 200)

FORTRAN derleyicileri boşlukları görmezden geldi:

   result = value * factor  
   r e s u l t = val ue * fac tor
   result=value*factor`

Derleyici söz konusu olduğunda aynıydı.

Bazı SQL lehçeleri, sütun adlarında gömülü boşluklara izin verir, ancak kullanılmadan önce geri tırnak işaretleri veya başka bir sınırlayıcıyla çevrelenmeleri gerekir.

Visual Basic (ve VBScript) ayrıca, tanımlayıcıyı köşeli parantezle çevreliyorsanız tanımlayıcılardaki boşluklara izin verir.

Dim [Hello World]
[Hello World] = 123

Ancak, bunu yapmak oldukça nadirdir.

SQL sayılır mı?

create table "Registered Members" (
    "Full Name" varchar(100),
    "Mailing Address" varchar(100),
    etc...
);

Peki, Boşluk her şey hakkında ... boşluk:

Çoğu modern programlama dili beyaz boşluk karakterlerini (boşluklar, sekmeler ve yeni satırlar) sözdizimini dikkate almaz, sanki orada yokmuş gibi onları yok sayar. Bunun, karakter setinin bu mükemmel dost üyelerine büyük bir haksızlık olduğunu düşünüyoruz. Görünmez oldukları için göz ardı edilmeleri gerekir mi? Boşluk dengeyi azaltmak isteyen bir dildir. Herhangi bir boşluk olmayan karakter yoksayılır; sadece boşluklar, sekmeler ve yeni satırlar sözdizimi olarak kabul edilir.

Ne yazık ki Markdown sözdizimini desteklemiyor ve size bazı kodları gösteremiyorum, ancak Wikipedia'nın kullanıcı dostu bir kod örneği var .

Algol 68'de tanımlayıcılarda yer olabilir (anlamlı olup olmadıklarını hatırlamıyorum). Ancak, anahtar kelimeler dokunarak işaretlendi . İçlerinde boşluk olan isimleri kullanmak deyimseldi (en azından çevremde).

VHDL içlerinde önemli boşluklarla tanımlayıcıları kaçan sağlar: \foo bar\. Bu tanımlayıcı olarak anahtar kelimeler kullanması da olanak sağlar \and\, herhangi bir karakter \n<42>\tanımlayıcıları ve küçük harf duyarlılığı ( \Foo\ve \foo\süre farklıdır Foove foodengi ve farklı ya \Foo\ve\foo\!). Verilog ayrıca bu özelliklerin çoğuna sahip tanımlayıcılara sahipti (normal tanımlayıcılar büyük / küçük harfe duyarlıdır ve gereksiz yere kaçmak başka bir tanımlayıcı yapmaz), ancak boşluklara izin vermez. VHDL ve Verilog'daki kaçan tanımlayıcılardan duyulan ihtiyaç, tanımlayıcıların geleneksel olarak programlama dilinde olduğu gibi aynı kısıtlamaya sahip olmadığı diğer kaynaklardan (şematik gibi) otomatik olarak üretilmesinden kaynaklanmaktadır; AFAIK, başka durumlarda aptalca kullanılmazlar.

MediaWiki wikitext'in bir dil olduğunu düşünür müsünüz bilmiyorum ama boşluk içeren isimler kesinlikle aptalca:

==Example==
This example lacks text.
{{Expand section}}

"Genişletme bölümü" bir şablonun adıdır (http://en.wikipedia.org/wiki/Template:Expand_section)

Tanımlayıcıların rutin olarak boşluk içerdiği bir dil olan kriterleri karşıladığını tahmin ediyorum. Asla (sanırım?) Belirsizdir, çünkü tanımlayıcılar her zaman ham wiki metninden ayırmak için birçok noktalama işaretiyle çevrilidir.

Bilgilendirme 7 , çok kelimeli tanımlayıcıların ortak olduğu, doğal dil benzeri sözdizimini kullanarak etkileşimli kurgu geliştirmek için bir sistemdir:

Mr Jones wears a top hat. The crate contains a croquet mallet. 

Kısıtlama, elbette, bu belirsiz olduğunda bir tanımlayıcının bir anahtar kelime içerememesidir.

Benzer şekilde, alt çizgi ile tanımlayıcılar Agda muhtemelen en basit örneği olan ikinci el mixfix olabilir if_then_else_operatörü:

if_then_else_ : {A : Set} -> Bool -> A -> A -> A
if true  then x else y = x
if false then x else y = y

Scala, backticks kullanarak keyfi tanımlayıcılara izin verir. Bunun için genel kullanım çağırmaktır Thread.`yield`çünkü yieldScala'da ayrılmış bir kelimedir. Deyimsel Scala kodundan çok uzak olmasına rağmen, bu (ab) isimlerinde boşluklar kullanılmış olabilir.

val `the answer` = 42
println(`the answer`)

Heck, tanımlayıcılarda bile sekmeler olabilir:

scala> val `the\tanswer` = 42
the     answer: Int = 42

Sanırım bunun okuma yazma bilmeyen insanlar için aptalca bir deyişsel olabileceğini düşünüyorum. Olabilir.

F #, tanımlayıcı adlarında beyaz boşluğa izin veriyor, ancak çift geri tepmelerle çevrili olmaları gerekir. Bu sorunun cevabına bakınız: https://stackoverflow.com/questions/6639688/using-keywords-as-identifiers-in-f .

Bunu , isimlerin içinde gömülü olan argümanlarla etkili şekilde cümleler olduğu Salatalık / Gherkin'de olduğu gibi düşünebilirsiniz .

Bunun bir uzantısı olarak, dilin geliştiricilere dostça davrandığı küçük DSL'lerde daha yaygın olmasını beklerdim . Örneğin, pek çok kural motoru, kuralları tanımlayıcılarda boşlukların kullanılabildiği bir ingilizce benzeri açıklama ile kuralları tanımlama becerisi sağlar.

FWIW, Tcl tanımlayıcılarda boşluklara (ve hemen hemen her karaktere) izin verir, ancak bu özellikten yararlanmak yaygın değildir. Çok sık kullanılmamasının ana nedeni, sadece uygun fiyat teklifi kullanmak zorunda olmanızdır. Örneğin, aşağıdaki "benim adım" adlı bir değişkeni "bob" olarak ayarlar, sonra yazdırır

set "my name" "bob"
puts "hello, ${my name}"

OTOH, değişkenleri dinamik olarak oluştururken çok faydalıdır, çünkü böyle değişkenleri oluştururken, yasadışı karakterler hakkında endişelenmenize gerek yoktur.

Bildiğim çok az şey var. Bir ve lithe programlama dili üzerinde çalışıyorum . Bilgilendirir , ancak tam olarak genel amaçlı bir programlama dili değildir.

Bir otomatik DSL testi dilini düşünürseniz, robot çerçevesi anahtar kelime adlarında boşluk bırakılmasına izin verir ve bu çok salaktır. Aşağıdaki örnekte "Merhaba deyin" bir anahtar kelime adıdır, "Örnek sınama durumu" bir sınama durumu adıdır ve "$ {first name}" bir değişkendir:

*** Keywords ***
| Say hello | [Arguments] | ${first name}
| | log | Hello, ${first name}

*** Test Cases ***
| Example test case
| | Say hello | world

4D dil yöntemi isimleri ve değişkenlerde beyaz boşluğu sağlar. Genellikle topluluk içinde kaşlarını çattı, ancak tüm yerleşik yöntemler ve değişkenler uygulanabilir olduğunda bunları kullanır ( SET MENU ITEM PARAMETERörneğin)

Smalltalk a:b:c:, çağrıldığında boşluk içeren bir anahtar kelime yöntemine sahiptir . Ör: a: 100 b: 200 c: 300. Bu, dilde standart bir deyimdir.

Powershell değişken isimlerinde boşluklara izin verir:

PS C:\> ${the var} = 100

PS C:\> ${the var}
100

VB için de benzerlerinden bahsettim ama JS'de bu aslında çok kullanılıyor. JavaScript'teki bir nesnenin herhangi bir özelliğine, köşeli parantezler ile veya basit bir şekilde nesne değişmezleri içindeki dizeler olarak dize biçiminde erişilebilir ve ayarlanabilir. JS'nin değişken adlandırma kurallarına uymayan özellik adlarına erişilemez. gösterimde ama onlar kullanışlıdır. Örneğin, URL'leri davranışla eşleştirmek veya hepsinin benzersiz olduğundan emin olduğunuzda bir grup insanın ismine göre başvuruda bulunmasını isteyebilirsiniz. Genellikle çok uygun ve okunması kolay:

var peoplesFavoriteThings = {
    "Bob Jones":"kittens",
    "Jane Doe":"chainsaws"
}

for(var name in peoplesFavoriteThings){
    console.log(name + ' likes ' + peoplesFavoriteThings[name] + '.\n');
}

Bu, JSON'a bırakıldığında anlık nesne faktörünü kaybetmeden kullanım kolaylığı için JSON'un yeniden yapılandırılmasını kolaylaştırır.

Power Query , çok sayıda otomatik olarak oluşturulan kod kullanır. Oluşturulan tanımlayıcıların yarısından fazlasının beyaz boşluk kullandığını tahmin ediyorum:

let
    Source = Sql.Database(".", "Test"),
    dbo_pvt = Source{[Schema="dbo",Item="pvt"]}[Data],
    #"Filtered Rows" = Table.SelectRows(dbo_pvt, each [VendorID] <= 4),
    #"Removed Columns" = Table.RemoveColumns(#"Filtered Rows",{"Emp1", "Emp2"}),
    #"Grouped Rows" = Table.Group(#"Removed Columns", {"Emp3", "Emp4"}, {{"Count", each List.Sum([Emp5]), type number}})
in
    #"Grouped Rows"

Gördüğünüz gibi, birçok dilde olduğu gibi, tanımlayıcının ne olduğunu netleştirmek için fazladan sözdizimi vardır.

Ancak belirsiz olduğu yerlerde fazladan sözdizimine gerek yoktur:

let
    spaceRecord = [with space = 42, recursive record = @spaceRecord],
    drilldown = spaceRecord[recursive record][recursive record][recursive record][with space]
in
    drilldown   // 42

Gerçek bir dil olarak sayarsanız, JMP kodlama dili ( http://www.jmp.com/support/downloads/pdf/jmp_scripting_guide.pdf ). Tanımlayıcıların boşluklara sahip olmasını sağlar (onları daha "okunaklı hale getirmek" için) ve daha fazla veya daha az teşvik eder.

Şu anda geliştirmekte olduğum o42a programlama dili, çok kelimeli adları destekliyor . Dilin hiç anahtar sözcüğü yoktur ve adlar genellikle bazı sembollerle ayrılır. Nadir durumlarda, iki isim birbirini takip eder, alt çizgi onları ayırmak için kullanılır.

Komut dosyası dili, nesne yönelimli olmayan Pascal'a dayanan Authorware, değişken adlarda boşluklara izin veriyordu, ancak zamanla insanlar bunları kullanmadaki sorunları keşfetti ve ondan uzaklaştı. Http://books.google.com/books?id= bHC88YignAkC & pg = PA428 & lpg = PA428 .

Düzenleme: Bu cevap doğru olmadığı gösterildi, yorumlara bakın.

Sorunuzu doğru anlarsam, bir derleyici tanımlayıcı adındaki boşluklara izin veremez çünkü yinelenen adlara neden olabilir (sınırlayıcı kullanılmadığı sürece). Örneğin:

int = 0; sayımı bool = false; int sayısı = 0; eğer (sayım) ...

'sayım' terimi kafa karıştırıcı olabilir 'sayım' değişkenine atıfta bulunabilir veya geliştirici belki de benim ve sayım arasında bir ilişki işleci yazmayı unuttu.

COBOL, bölüm adlarının ve bölüm adlarının boşlukla ayrılmasına izin verdi, ancak bunlar, sorunuzda olduğu gibi tanımlayıcılar ve değişkenler değil.