Sihirli dizgilerin nesi var?

Deneyimli bir yazılım geliştiricisi olarak sihirli iplerden kaçınmayı öğrendim.

Benim sorunum, onları kullanmaya başladığımdan bu yana çok zaman geçtiği için, nedenlerin çoğunu unuttum. Sonuç olarak, daha az deneyimli meslektaşlarım için neden sorun olduklarını açıklamakta güçlük çekiyorum.

Onlardan kaçınmak için hangi nesnel nedenler var? Hangi sorunlara neden olurlar?

1. Derleyen bir dilde , derleme zamanında bir sihirli dizgenin değeri kontrol edilmez . Dizginin belirli bir desenle eşleşmesi gerekiyorsa, o desene uymasını garanti etmek için programı çalıştırmanız gerekir. Enum gibi bir şey kullandıysanız, derleme zamanında değer yanlış değer olsa bile en azından geçerlidir.

2. Sihirli bir dize birden fazla yere yazılıyorsa , hepsini güvenlik olmadan (derleme zamanı hatası gibi) değiştirmeniz gerekir. Bu, yalnızca bir yerde bildirilmesi ve değişkenin yeniden kullanılması ile önlenebilir.

3. Yazım hatası ciddi hatalar olabilir. Eğer bir işlevin varsa:

   func(string foo) {
       if (foo == "bar") {
           // do something
       }
   }
   

   ve yanlışlıkla birileri:

   func("barr");
   

   Daha nadir veya daha karmaşık olan dizgenin daha kötü olması, özellikle projenin ana dilini bilmeyen programcılar varsa.

4. Sihirli dizeler nadiren kendi kendini belgeliyor. Bir dize görürseniz, bu dize başka ne olabilir / olması gerektiğini söylemez. Doğru ipi seçtiğinizden emin olmak için muhtemelen uygulamaya göz atmanız gerekecektir.

   Bu tür bir uygulama, sızdıran bir şeydir, özellikle karakter mükemmel olması gerektiğinden (3. maddede olduğu gibi) ne yazılması gerektiğini anlamak için dış belgelere ya da koda erişime ihtiyaç duyar.

5. IDE'lerde "find string" işlevlerinin dışında, kalıbı destekleyen az sayıda araç vardır.

6. Aynı sihirli ipi iki yerde tesadüfen kullanabilirsiniz, gerçekten farklı şeyler oldukları zaman, eğer bir Bul ve Değiştir yaptıysanız ve her ikisini de değiştirdiyseniz, ikisi de biri çalışırken kırılabilir.

Diğer cevapların neyi kavradığının zirvesi, “sihirli değerlerin” kötü olduğu değil, olmaları gerektiğidir:

1. tanınabilir olarak sabitler olarak tanımlanır;
2. tüm kullanım alanları içerisinde yalnızca bir kez tanımlanmış (eğer mümkünse);
3. Bir şekilde ilişkili bir sabitler dizisi oluştururlarsa birlikte tanımlanırlar;
4. kullanıldığı uygulamada uygun bir genellikte tanımlanmış; ve
5. uygunsuz bağlamlarda kullanımlarını sınırlayacak şekilde tanımlanır (örn. kontrol tipine uygun).

Tipik olarak kabul edilebilir "sabitleri" "sihirli değerlerden" ayıran şey, bu kuralların bir veya daha fazlasının ihlalidir.

İyi kullanıldığında, sabitler kodumuzun belirli aksiyomlarını ifade etmemize izin verir.

Bu da beni son bir noktaya getiriyor; yukarıdaki kriterlere uymasa bile, sabit değerlerin aşırı kullanımı (ve dolayısıyla değerler açısından ifade edilen aşırı sayıda varsayım ya da kısıtlama), (özellikle onlardan sapması durumunda), Bu, tasarlanan çözümün yeterince genel veya iyi yapılandırılmamış olduğu anlamına gelebilir (bu nedenle artık sabitlerin artıları ve eksileri hakkında değil, iyi yapılandırılmış kodun artıları ve eksileri hakkında gerçekten konuşmuyoruz).

Yüksek seviyeli diller, sabit seviyelerde çalışmak zorunda kalacak olan düşük seviyeli dillerdeki kalıplar için yapılara sahiptir. Aynı paternler üst seviye bir dilde de kullanılabilir, ancak kullanılmaması gerekir.

Ancak bu, tüm koşulların izlenimine ve bir çözümün neye benzemesi gerektiğine ve bu kararın tam olarak nasıl haklı çıkacağına dayanan bir uzman kararı olabilir. Gerçekten de, "Aşina olduğum, daha iyi yaptığım bu tür işleri görecek kadar yaşlandım" iddiası dışında, genel ilkeler açısından haklı bulunmayabilir!

EDIT: bir düzenlemeyi kabul etmiş, bir başkasını reddetmiş ve şimdi kendi düzenlememi yaptım, şimdi bir kez ve tüm haha ​​için çözülecek olan kural listemin biçimlendirme ve noktalama stilini düşünebilir miyim?

• İzlemeleri zor.
• Tümünü değiştirmek, muhtemelen birden fazla projede birden fazla dosya değiştirmeyi gerektirebilir (bakımı zor).
• Bazen amaçlarının ne olduğunu sadece değerlerine bakarak söylemek zor.
• Yeniden kullanım yok.

Gerçek hayattan örnek: "Varlıklar" ın "alanlar" ile depolandığı üçüncü parti bir sistemle çalışıyorum. Temel olarak bir EAV sistemi. Başka bir alan eklemek oldukça kolay olduğundan, alanın adını dize olarak kullanarak birine erişebilirsiniz:

Field nameField = myEntity.GetField("ProductName");

("ProductName" sihirli dizesine dikkat edin)

Bu birkaç soruna yol açabilir:

• "ProductName" in bile bulunduğunu ve tam olarak yazımını bilmek için harici belgelere başvurmam gerekiyor
• Artı, o alanın veri tipinin ne olduğunu görmek için o doktora başvurmam gerekiyor.
• Bu sihirli dizede yazım hatası, bu kod satırı yürütülene kadar yakalanmaz.
• Birisi bu alanı sunucuda yeniden adlandırmaya karar verdiğinde (veri kaybını önlerken zor, ancak imkansız değildir), o zaman bu adı nerede ayarlamam gerektiğini görmek için kodumla kolayca arama yapamıyorum.

Bu yüzden benim çözümüm, varlık türüne göre düzenlenen bu isimler için sabitler üretmekti. Yani şimdi kullanabilirim:

Field nameField = myEntity.GetField(Model.Product.ProductName);

Hala bir dize sabittir ve aynı ikili dosyaya derlenir, ancak birkaç avantajı vardır:

• "Model" yazdıktan sonra, IDE sadece mevcut varlık türlerini gösterir, bu yüzden kolayca "Ürün" ü seçebilirim.
• O zaman IDE'm sadece bu tür bir varlık için uygun olan ve aynı zamanda seçilebilir olan alan adlarını sağlar.
• Otomatik olarak oluşturulan belgeler bu alanın ne anlama geldiğini ve değerlerini saklamak için kullanılan veri türünü gösterir.
• Sabitten başlayarak, IDE'm bu sabitin kullanıldığı tüm yerleri bulabilir (değerinin aksine)
• Yazım hatası derleyici tarafından yakalanacak. Bu, sabitleri yeniden oluşturmak için yeni bir model (muhtemelen bir alanı yeniden adlandırdıktan veya sildikten sonra) kullanıldığında da geçerlidir.

Listemde sonra: bu sabitleri kuvvetle yazılan sınıfların arkasına gizleyin - ardından veri türü de güvence altına alındı.

Sihirli teller her zaman kötü değil , bu yüzden onlardan kaçınmak için bir battaniye nedeni bulamamanızın nedeni olabilir. ("Sihirli string" ile demek istediğim, bir ifadenin parçası olarak değişmez ve string olarak tanımlanmamış).

Bazı özel durumlarda, sihirli dizgilerden kaçınılmalıdır:

• Aynı dize, kodda birden çok kez görüntüleniyor. Bu, yerlerden birinde bir yazım hatası olabilir anlamına gelir. Ve dize değişikliklerinin bir güçlüğü olacak. Dize bir sabit haline getirin, bu sorundan kaçınırsınız.
• Dize göründüğü koddan bağımsız olarak değişebilir. Örneğin. dizge son kullanıcıya görüntülenen metin ise, herhangi bir mantık değişikliğinden bağımsız olarak değişecektir. Bu dizgiyi ayrı bir modüle (veya harici konfigürasyona veya veritabanına) ayırmak, bağımsız olarak değiştirmeyi kolaylaştıracak
• Dizenin anlamı, bağlamdan açık değildir. Bu durumda bir sabit tanıtmak kodun anlaşılmasını kolaylaştıracaktır.

Ancak bazı durumlarda, "sihirli dizeler" iyi. Basit bir ayrıştırıcınız olduğunu söyleyin:

switch (token.Text) {
  case "+":
    return a + b;
  case "-":
    return a - b;
  //etc.
}

Burada gerçekten sihir yok ve yukarıda açıklanan sorunlardan hiçbiri geçerli değil. IMHO'nun tanımlanması string Plus="+"vb. Yararı olmayacaktı . Basit tutun.

Mevcut cevaplara eklemek için:

Uluslararasılaşma (i18n)

Ekranda görüntülenecek metin kodlanmış ve işlev katmanlarına gömülmüşse, o metnin diğer dillere çevirisini sağlamak için çok zor bir zaman geçireceksiniz.

Bazı geliştirme ortamları (örneğin Qt), temel dil metin dizesinden çevrilen dile kadar arama yaparak çevirileri işler. Sihirli dizgiler genellikle hayatta kalabilir - aynı metni başka bir yerde kullanmak ve bir yazım hatası almak istediğinize karar verene kadar. O zaman bile, başka bir dile destek eklemek istediğinizde hangi sihirli dizgelerin çevrilmesi gerektiğini bulmak çok zor.

Bazı geliştirme ortamları (örneğin, MS Visual Studio) başka bir yaklaşıma sahiptir ve tüm çevrilmiş dizgilerin bir kaynaklar veritabanında tutulmasını ve bu dizinin benzersiz kimliği ile mevcut yerel ayar için tekrar okunmasını gerektirir. Bu durumda, sihirli dizelerle uygulamanız, basit bir şekilde yeniden işleme tabi tutulmadan başka bir dile çevrilemez. Etkili geliştirme, tüm metin dizelerinin kaynaklar veritabanına girilmesini ve kod ilk yazıldığında benzersiz bir kimlik verilmesini gerektirir ve bundan sonra i18n oldukça kolaydır. Gerçek şu ki bunu doldurmaya çalışmak genellikle çok büyük bir çaba gerektirecektir (ve evet, orada oldum!), Bu yüzden her şeyi en başta yapmak çok daha iyidir.

Bu herkes için bir öncelik değil, ancak kodunuzdaki kaplin / uyum ölçütlerini otomatik olarak hesaplamak istiyorsanız, sihirli dizeler bunu neredeyse imkansız hale getirir. Bir yerdeki bir dize, başka bir yerdeki bir sınıfa, yönteme veya işleve atıfta bulunur ve dizenin yalnızca kodu ayrıştırma yaparak sınıfa / yönteme / işleve bağlandığını belirlemenin kolay ve otomatik bir yolu yoktur. Sadece temel çerçevenin (Açısal, örneğin) bir bağlantı olduğunu belirleyebilir - ve bunu sadece çalışma zamanında yapabilir. Eşleştirme bilgisini kendiniz elde etmek için, çözümleyiciniz, kullandığınız çerçeve hakkında, kodladığınız temel dilin üstünde ve ötesinde her şeyi bilmek zorundadır.

Fakat yine de, bu geliştiricilerin çok ilgilendiği bir şey değil.