Örneğin, bir işlemciyi Android'de açık tutmak için aşağıdaki gibi kod kullanabilirim:

PowerManager powerManager = (PowerManager)getSystemService(POWER_SERVICE);
WakeLock wakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "abc");
wakeLock.acquire();

ama bence yerel değişkenler powerManagerve wakeLockelimine edilebilir:

((PowerManager)getSystemService(POWER_SERVICE))
    .newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "MyWakelockTag")
    .acquire();

benzer sahne iOS uyarı görünümünde görünür, örneğin:

UIAlertView *alert = [[UIAlertView alloc]
    initWithTitle:@"my title"
    message:@"my message"
    delegate:nil
    cancelButtonTitle:@"ok"
    otherButtonTitles:nil];
[alert show];

-(void)alertView:(UIAlertView *)alertView clickedButtonAtIndex:(NSInteger)buttonIndex{
    [alertView release];
}

için:

[[[UIAlertView alloc]
    initWithTitle:@"my title"
    message:@"my message"
    delegate:nil
    cancelButtonTitle:@"ok"
    otherButtonTitles:nil] show];

-(void)alertView:(UIAlertView *)alertView clickedButtonAtIndex:(NSInteger)buttonIndex{
    [alertView release];
}

Kapsamda bir kez kullanılmışsa, yerel bir değişkeni ortadan kaldırmak iyi bir uygulamadır mı?

Kod, yazıldığından çok daha fazla okunur, bu nedenle, bundan altı ay sonra (bu siz olabilirsiniz) kodu okumak zorunda kalacak olan zavallı ruha merhamet etmeli ve en açık, anlaşılması en kolay kod için uğraşmalısınız. Benim düşünceme göre, yerel değişkenli ilk biçim çok daha anlaşılabilir. Tek satırda üç eylem yerine üç satırda üç eylem görüyorum.

Ve eğer yerel değişkenlerden kurtularak herhangi bir şeyi optimize ettiğinizi düşünüyorsanız, değilsiniz. Modern bir derleyici , yöntemi çağırmak için yerel bir değişken kullanılmış olsun olmasın powerManagerbir kayıt defterine ¹ koyacaktır newWakeLock. Aynı şey için de geçerlidir wakeLock. Her iki durumda da aynı derlenmiş kodla bitirdiniz.

¹ Beyanname ile yerel değişkenin kullanımı arasında çok fazla müdahale kodu varsa, bu yığın üzerinde olabilir, ancak küçük bir detaydır.

Bazı çok eleştirilen yorumlar bunu belirtti, ancak gördüğüm cevapların hiçbiri yapmadı, ben de cevap olarak ekleyeceğim. Bu konuda karar vermedeki ana faktörün şudur:

Debuggability

Genellikle, geliştiriciler kod yazmaktan çok daha fazla zaman ve çaba harcarlar.

İle yerel değişkenler şunları yapabilirsiniz:

• Atanan çizgide kesme noktası (koşullu kesme, vb. Gibi tüm diğer kesme noktası süslemelerinde)

• Yerel değişkenin değerini inceleyin / izleyin / yazdırın / değiştirin

• Dökümler nedeniyle ortaya çıkan sorunları yakalayın.

• Okunabilir yığın izleri var (XYZ hattında 10 yerine bir işlem var)

Yerel değişkenler olmadan, yukarıdaki görevlerin tümü hata ayıklayıcınıza bağlı olarak ya çok daha zor, çok zor veya tamamen imkansızdır.

Bu şekilde, rezil makamı izleyin (kodu, kendinizden sonra korumak için bir sonraki geliştiricinin, nerede oturduğunuzu bilen çılgınca bir deliymiş gibi yazacağınız şekilde yazın) ve hata ayıklamanın daha kolay , yerel değişkenleri kullanmanın yanına bakın .

Sadece kodun anlaşılmasını kolaylaştırırsa. Örneklerinde, okumayı zorlaştırdığını düşünüyorum.

Derlenmiş koddaki değişkenleri ortadan kaldırmak saygın bir derleyici için önemsiz bir işlemdir. Doğrulamak için çıktıyı kendiniz inceleyebilirsiniz.

Sorunuz "Sadece bir kez kullanıldığında yerel bir değişkeni ortadan kaldırmak iyi bir pratik midir?" yanlış kriterleri test ediyor. Bir yerel değişkenin yardımcı programı, kullanılma sayısına bağlı değildir, ancak kodu daha açık hale getirip getirmediğine bağlıdır. Ara değerlerin anlamlı adlarla etiketlenmesi, kodu kodunuzu daha küçük, daha sindirilebilir, parçalara ayırdığı için sunduğunuz gibi durumlarda netliği artırabilir.

Benim görüşüme göre, sunduğunuz değiştirilmemiş kod değiştirilmiş kodunuzdan daha açık ve bu nedenle değiştirilmemelidir. Aslında, netliği arttırmak için yerel bir değişkeni değiştirilmiş kodunuzdan çıkarmayı düşünürdüm.

Yerel değişkenlerden herhangi bir performans etkisi beklemem ve her ne kadar kodun programın kritik bir bölümünde çok dar bir döngüde olmadıkça dikkate alınmayacak kadar küçük olması muhtemeldir.

Olabilir.

Şahsen bir typecast katılıyorsa yerel değişkenleri ortadan kaldırmaktan çekinirim. Parantez sayısı sahip olduğum zihinsel bir limite yaklaşmaya başladığında, kompakt versiyonunuzu daha az okunabilir buluyorum. Yerel bir değişken kullanarak biraz daha ayrıntılı sürümde gerekmeyen yeni bir parantez seti bile sunar.

Kod editörü tarafından sağlanan sözdizimi vurgulaması, bu endişeleri bir dereceye kadar azaltabilir.

Gözlerime göre, bu daha iyi bir uzlaşmadır:

PowerManager powerManager = (PowerManager)getSystemService(POWER_SERVICE);
powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "abc").acquire();

Böylece bir yerel değişkeni tutmak ve diğerini kazmak. C # 'da ilk satırdaki var anahtar sözcüğünü kullanırdım, çünkü typecast zaten tip bilgisini veriyordu.

Yerel değişkenleri destekleyen cevapların geçerliliğini kabul etsem de, şeytanın avukatı oynayacağım ve karşıt bir görüş sunacağım.

Kişisel değişkenleri sadece belgeleme amaçları için hangi miktarlarda kullanılacağına dair yalnızca yerel değişkenleri kullanmaya karşıyım, bu nedenin kendisi uygulamanın bir değeri olduğunu gösterir: yerel değişkenler kodu etkin bir şekilde sahte olarak belgelemektedir.

Senin durumunda, asıl sorun değişkenlerin olmaması değil, girintilemedir. Kodu aşağıdaki gibi biçimlendirebilirsiniz (ve gerekir):

((PowerManager)getSystemService(POWER_SERVICE))
        .newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,"MyWakelockTag")
        .acquire();

Bunu yerel değişkenlerle olan sürümle karşılaştırın:

PowerManager powerManager=(PowerManager)getSystemService(POWER_SERVICE);
WakeLock wakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,"abc");
wakeLock.acquire();

Yerel değişkenlerle: isimler okuyucuya bir miktar bilgi ekler ve türler açıkça belirtilir, ancak gerçek yöntem çağrıları daha az görülür ve (bence) net olarak okunmuyor.

Yerel değişkenleri kullanmadan: daha özlüdür ve yöntem çağrıları daha belirgindir, ancak ne döndürüleceği hakkında daha fazla bilgi isteyebilirsiniz. Ancak bazı IDE'ler size bunu gösterebilir.

Üç ek yorum:

1. Benim görüşüme göre, işlevsel kullanımı olmayan bir kod eklemek bazen okuyucunun gerçekten işlevsel bir kullanımının olmadığını ve “dokümantasyon” için orada olduğunu fark etmesi gerektiği için kafa karıştırıcı olabilir. Örneğin, bu yöntem 100 satır uzunluğunda olsaydı, tüm değişkenleri okumadığınız sürece yerel değişkenlerin (ve bu nedenle de yöntem çağrısı sonucunun) daha sonraki bir noktada gerekli olmadığı açık olmazdı.

2. Yerel değişkenleri eklemek, türlerini belirtmeniz gerektiği anlamına gelir ve bu, kodda aksi durumda olmayacak bir bağımlılık getirir. Metotların dönüş tipi önemsizce değiştiyse (örneğin, yeniden adlandırıldıysa), kodunuzu güncellemeniz gerekirken, yerel değişkenler olmadan bunu yapmazsınız.

3. Hata ayıklayıcınız yöntemlerden döndürülen değerleri göstermiyorsa, hata ayıklama yerel değişkenlerle daha kolay olabilir. Ancak bunun için düzeltme, hata ayıklayıcılardaki eksiklikleri gidermek, kodu değiştirmek değildir.

Burada motivasyon gerginliği var. Geçici değişkenlerin tanıtılması kodun okunmasını kolaylaştırabilir. Ancak, Ayıklama Yöntemi ve Sıcaklığı Sorgula Değiştirme gibi diğer olası yeniden alevlendirmeleri de önleyebilir ve görmeyi zorlaştırabilir . Bu sonraki yeniden yapılandırma tipleri, uygun olduğunda, genellikle geçici değişkenden çok daha büyük yararlar sağlar.

Fowler , bu yeniden yapılanmalar için motivasyon üzerine şöyle yazıyor :

“Temps ile ilgili sorun geçici ve yerel olmalarıdır. Yalnızca kullanıldıkları yöntem bağlamında görülebildiklerinden, temps daha uzun yöntemleri teşvik etme eğilimindedir, çünkü temp'a ulaşmanın tek yolu budur. temp parametresini bir sorgu yöntemiyle değiştirmek, sınıftaki herhangi bir yöntem bilgiyi alabilir. Bu, sınıf için daha temiz bir kodun gelmesinde çok yardımcı olur. "

Bu nedenle, evet, kodları daha okunaklı kılarlarsa, özellikle sizin ve ekibiniz için yerel bir norm ise temps kullanın. Ancak, bunu yapmanın bazen daha büyük alternatif gelişmeleri tespit etmeyi zorlaştırabileceğinin farkında olun. Bu kadar temps olmadan gitmenin ve ne zaman yapmanın daha rahat olabileceğini hissetme yeteneğinizi geliştirebilirseniz, bu muhtemelen iyi bir şeydir.

FWIW Ben şahsen on yıl boyunca Fowler'ın "Refactoring" kitabını okumaktan kaçındım çünkü bu kadar basit konularda söylenecek fazla bir şey olmadığını hayal ettim. Tamamen yanılmışım. Sonunda okuduğumda, günlük kodlama uygulamalarım değişti, daha iyisi için.

Eh, yerel değişkenleri ortadan kaldırmak için iyi bir fikirdir sen eğer bu şekilde kod daha okunabilir olun. Sizin uzun bir gömlek sizin okunabilir değil, ancak daha sonra ayrıntılı bir OO stilini takip ediyor. Eğer böyle bir şeye indirgeyebilirsen

acquireWakeLock(POWER_SERVICE, PARTIAL, "abc");

o zaman muhtemelen iyi bir fikir olacağını söyleyebilirim. Belki de onu benzer bir şeye indirgemek için yardımcı yöntemler sunabilirsiniz; Bunun gibi bir kodun birden çok kez görünmesi durumunda, buna değer olabilir.

Burada Demeter Yasasını düşünelim . LoD hakkındaki Wikipedia makalesinde aşağıdakiler belirtilmiştir:

İşlevler için Demeter Yasası, O nesnesinin m yönteminin yalnızca aşağıdaki nesne türlerinin yöntemlerini çağırmasını gerektirebilir: [2]

1. O
2. m'nin parametreleri
3. M içinde oluşturulan / örneklenen nesneler
4. O'nun doğrudan bileşen nesneleri
5. M kapsamında O tarafından erişilebilen global bir değişken

Bu Yasayı izlemenin sonuçlarından biri, diğer yöntemlerle döndürülen nesnelerin yöntemlerini, yukarıdaki ikinci örnekte gösterildiği gibi, uzun noktalı bir dizede çağırmaktan kaçınmanız gerektiğidir:

((PowerManager)getSystemService(POWER_SERVICE)).newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,"MyWakelockTag").acquire();

Bunun ne yaptığını anlamak gerçekten zor. Bunu anlamak için her bir prosedürün ne yaptığını anlamanız ve daha sonra hangi nesnenin hangi nesne üzerinde çağrıldığını deşifre etmeniz gerekir. İlk kod bloğu

PowerManager powerManager=(PowerManager)getSystemService(POWER_SERVICE);
WakeLock wakeLock=powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,"abc");
wakeLock.acquire();

ne yapmaya çalıştığınızı açıkça gösteriyor - bir PowerManager nesnesi alıyorsunuz, PowerManager'dan bir WakeLock nesnesi alıyorsunuz, ardından wakeLock'u alıyorsunuz. Yukarıdakiler LoD kural # 3'ü izler - bu nesneleri kodunuzda başlatırsınız ve böylece onları ihtiyacınız olan şeyi yapmak için kullanabilirsiniz.

Belki de düşünmenin başka bir yolu da, yazılımı oluştururken açıklık için yazmanız gerektiğini, kısalık için değil, hatırlamanızdır. Tüm yazılım geliştirmenin% 90'ı bakımdır. Asla bir kod yazmayın, saklamaktan memnun olmazsınız.

İyi şanslar.

Unutulmaması gereken bir şey, kodun farklı "derinliklere" sık sık okunmasıdır. Bu kod:

PowerManager powerManager = (PowerManager)getSystemService(POWER_SERVICE);
WakeLock wakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "abc");
wakeLock.acquire();

"yağsız" kolaydır. 3 ifade var. İlk önce bir ile geldik PowerManager. Sonra bir ile geldik WakeLock. Sonra . Bunu her satırın başlangıcına bakarak kolayca görebiliyorum; basit değişken atamaları kısmen "TypeName = ..." olarak tanımlamak ve sadece zihinsel olarak "..." üzerine bakmak çok kolaydır. Benzer şekilde, son ifade açık bir şekilde ödevin şekli değildir, ancak yalnızca iki isim içerir, bu yüzden “ana esas” hemen anlaşılır. Genellikle, sadece "bu kod ne yapar?" Diye cevaplamaya çalışıyor olsaydım, bilmem gereken tek şey bu olurdu. yüksek düzeyde.acquirewakeLock

Burada olduğunu düşündüğüm zekice bir böceğin peşindeysem, açıkçası bunu daha ayrıntılı olarak incelemem gerekecek ve aslında "..." yi hatırlayacağım. Ancak ayrı ifade yapısı hala bir kerede bir açıklama yapmama yardımcı oluyor (özellikle her ifadede çağrılan şeylerin daha derine atlanması gerekirse işe yarar; geri döndüğümde “bir üniteyi” tamamen anladım. ve sonra bir sonraki ifadeye geçebilir).

((PowerManager)getSystemService(POWER_SERVICE))
    .newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "MyWakelockTag")
    .acquire();

Şimdi hepsi bir açıklama. Üst düzey yapı yağsız okunması kolay değildir; OP'nin orijinal versiyonunda, herhangi bir yapıyı görsel olarak iletmek için çizgiler ve girintiler olmadan, 3 basamaklı bir dizinin kodunu çözmek için parantezleri saymam gerekecekti. Çok parçalı ifadelerin bazıları, bir yöntem çağrısı zinciri olarak düzenlenmekten ziyade, birbirlerinin içine yerleştirilmişse, o zaman yine de buna benzer bir şekilde görünebilir, bu yüzden parantezleri saymadan güvenmeye dikkat etmek zorundayım. Ve eğer girintiye güveniyorsam ve tüm bunların varsayılan noktası olarak son şeyden önce kayıyorsam, .acquire()bana ne söyler?

Bazen de, istediğin bu olabilir. Dönüşümünüzü yarı yolda uygularsam ve şunu yazarsam:

WakeLock wakeLock =
     ((PowerManeger)getSystemService(POWER_SERVICE))
    .newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "MyWakeLockTage");
wakeLock.acquire();

Şimdi bu hızlı bir yağsız iletişim kurar "a WakeLock, o acquirezaman". İlk versiyondan bile daha basit. Hemen elde edilen şeyin bir olduğu açıktır WakeLock. Bunu elde etmek, PowerManagerbu kodun amacına göre oldukça önemsiz olan bir alt ayrıntı ise, ancak wakeLockönemli olan şey, o zaman gerçekten PowerManagerhızlı bir şekilde almaya çalışıyorsanız, üzerine atlamak için doğal olan şeyleri gömmek için yardımcı olabilir. bu kodun ne yaptığı hakkında fikir. Adlandırma değil , sadece bir kez kullanıldığını, bazen de bu olduğunu Önemli olan (kapsamın geri kalanı çok uzunsa, tekrar kullanılıp kullanılmayacağını söylemek için hepsini okumak zorundayım; ancak, açık alt kapsamları kullanmak, eğer diliniz destekliyorsa, bunu ele almanın başka bir yolu olabilir).

Bu, hepsinin içeriğe ve ne iletişim kurmak istediğine bağlı olduğunu gösterir. Doğal dilde nesir yazma gibi, orada her zaman bilgi içerik bakımından temelde eşdeğer olan bir kod verilmiş parça yazmak için pek çok yöntem. Genellikle gerektiğini aralarında seçim kadar doğal dilde düzyazı, yazma gibi değil gibi mekanik kurallarını uygulamak olmak "yalnızca bir kez oluştuğunda herhangi bir yerel değişken ortadan kaldırmak". Aksine nasılKodunuzu yazmayı seçerseniz, bazı şeyleri vurgulayacak ve diğerlerini de vurguluyorsunuz. Gerçekte vurgulamak istediklerinize dayanarak, bu seçimleri bilinçli bir şekilde yapmak için çaba göstermelisiniz (teknik nedenlerle daha az okunabilir kod yazma seçeneği dahil). Özellikle, sadece kodunuzun "özüne kavuşması" gereken okuyuculara neyin hizmet edeceğini bir düşünün (çeşitli seviyelerde), çünkü bu, ifadeye göre çok yakın bir ifadeden çok daha sık olur.

Bu bile kendi adıyla bir antipattern: Train Wreck . Değişimden kaçınmak için birkaç neden daha önce belirtilmiştir:

• Okumak zor
• Hata ayıklaması zor (hem değişkenleri izlemek hem de istisnalar konumlarını tespit etmek için)
• Demeter Yasasının İhlali (LoD)

Bu yöntemin diğer nesnelerden çok fazla şey bildiğini düşünün. Metot zincirleme , kuplajı azaltmanıza yardımcı olabilecek bir alternatiftir.

Ayrıca, nesnelere yapılan referansların gerçekten ucuz olduğunu unutmayın.

Belirtilen soru "Yapabilirsek yerel değişkenleri ortadan kaldırmalı mıyız?"

Hayır, yapabildiğiniz için yok etmemelisiniz.

Mağazanızdaki kodlama kurallarına uymalısınız.

Çoğunlukla yerel değişkenler, kodu okumayı ve hata ayıklamayı kolaylaştırır.

Yaptıklarını beğendim PowerManager powerManager. Benim için sınıfın küçük bir örneği, sadece bir kez kullanım anlamına gelir.

Yapmamanız gereken, değişkenin pahalı kaynaklara dayanıp dayanmayacağıdır. Birçok dilde temizlenmesi / bırakılması gereken yerel bir değişken için sözdizimi vardır. C # kullanıyor.

using(SQLconnection conn = new SQLconnnection())
{
    using(SQLcommand cmd = SQLconnnection.CreateCommand())
    {
    }
}

Önemli cevaplardan biri diğer cevaplarda belirtilmemiştir: Bir değişken eklediğinizde, değişken duruma geçersiniz. Bu genellikle kötü bir şeydir çünkü kodunuzu daha karmaşık hale getirir ve bu nedenle anlamak ve test etmek daha zordur. Tabii ki, değişkenin kapsamı ne kadar küçükse, sorun o kadar az olur.

İstediğiniz şey aslında değeri değiştirilebilen bir değişken değil, geçici bir sabit. Bu nedenle, eğer diliniz izin veriyorsa, bunu kodunuzda ifade etmeyi düşünün. Java'da kullanabilirsinizfinal ve C ++ da kullanabilirsiniz const. Çoğu işlevsel dilde, varsayılan davranış budur.

Yerel değişkenlerin en az zararlı değişken durum olduğu doğrudur. Üye değişkenler çok daha fazla soruna neden olabilir ve statik değişkenler daha da kötüdür. Yine de, yapmanız gerekenleri kodunuzda mümkün olduğunca doğru ifade etmenin önemli olduğunu düşünüyorum. Ve daha sonra değiştirilebilecek bir değişken ile ara sonuç için yalnızca bir ad arasında çok büyük bir fark var. Diliniz bu farkı ifade etmenize izin veriyorsa, sadece yapın.