Jaki jest powód używania małych liter dla pierwszego słowa w zmiennej lokalnej (np. WorkerCount, firstName)

Dużo krytykuję ze strony innych programistów ze względu na to, że wykorzystuję pełną odpowiednią obudowę dla wszystkich moich zmiennych. Na przykład typowy programista użyje employeeCountnazwy zmiennej, ale ja jej używam EmployeeCount. Używam pełnej właściwej obudowy do wszystkiego , czy to metoda void, metoda return, zmienna, właściwość lub stała. Nawet przestrzegam tej konwencji w Javascript. Ten ostatni naprawdę szelestuje żarty ludzi.

Typowym powodem, dla którego nie powinienem stosować się do tej „niestandardowej” konwencji dotyczącej obudów, jest to, że pełny właściwy przypadek powinien być zarezerwowany dla właściwości i metod void. Zmienna lokalna i metody zwracające wartość powinny mieć pierwsze słowo pisane małymi literami int employeeCount = getEmployeeCount().

Nie rozumiem jednak dlaczego.

Kiedy zadaję to pytanie, wydaje się, że po prostu otrzymuję arbitralną odpowiedź na to pytanie . Jakakolwiek jest odpowiedź, zwykle zawsze sprowadza się do Tak po prostu jest i nie kwestionuję tego. Po prostu podążam za tym. . Arbitralne odpowiedzi nigdy nie są dla mnie wystarczająco dobre.

Od samego początku programowania makr Excel 97 za pomocą Office IDE, nigdy nie potrzebowałem konwencji casing, aby powiedzieć mi, czy coś jest lokalną zmienną lub właściwością. Jest tak, ponieważ zawsze stosowałem bardzo intuicyjną konwencję nazewnictwa. Na przykład GetNuggetCount()wyraźnie sugeruje metodę, która gdzieś idzie i pobiera liczbę wszystkich samorodków. SetNuggetCount(x)sugeruje, że przypisujesz nową wartość do liczby bryłek. NuggetCountwszystko samo w sobie sugeruje właściwość lub zmienną lokalną, która po prostu przechowuje wartość. Do tego ostatniego można pokusić się o powiedzenie: „Ach ha! To jest pytanie. Własność lub zmienna? CO TO JEST?” Na to odpowiedziałbym: „Czy to naprawdę ma znaczenie?”

Oto tl; dr ;: Jakie są obiektywne, logiczne, nieobowiązkowe powody, aby używać małych liter dla pierwszego słowa w zmiennej lub w metodzie zwracanej?

Edycja: dla MainMa

Zamień ten kod na pierwszy przykładowy kod w odpowiedzi i sprawdź, jak dobrze utrzymuje się Twój argument:

public void ComputeMetrics()
{
    const int MaxSnapshots = 20;

    var Snapshots = this.LiveMeasurements.IsEnabled ?
        this.GrabSnapshots(MaxSnapshots, this.cache) :
        this.LoadFromMemoryStorage();

    if (!Snapshots.Any())
    {
        this.Report(LogMessage.SnapshotsAreEmpty);
        return;
    }

    var MeasurementCount = Measurements.Count();
    this.Chart.Initialize((count + 1) * 2);

    foreach (var s in Snapshots)
    {
        this.Chart.AppendSnapshot(s);
    }
}

Ta konwencja nazewnictwa jest często stosowana, gdy ludzie chcą mieć możliwość nadania zmiennej tej samej nazwy co jej typ. Na przykład:

Employee employee;

Niektóre języki wymuszają nawet stosowanie wielkich liter. Zapobiega to konieczności korzystania irytujących nazwy zmiennych takich jak MyEmployee, CurrentEmployee, EmployeeVar, itd. Zawsze można powiedzieć, czy coś jest rodzajem lub zmienna, tylko z liter. Zapobiega to pomyłkom w sytuacjach takich jak:

employee.function(); // instance method
Employee.function(); // static method

Ponadto w języku angielskim rzeczowniki zazwyczaj nie są pisane dużymi literami, więc nie można tak naprawdę twierdzić, że wielkość liter jest „odpowiednia”.

Co to ma wspólnego z twoją sytuacją? Oczywiście nie masz problemów z odczytaniem własnego kodu, ale utrzymując spójność w możliwie największym stopniu, zmniejszasz obciążenie umysłowe wszystkich osób, które muszą czytać Twój kod. W kodowaniu jak w piśmie dostosowujesz swój styl do czytelników.

Nie ma żadnych To właśnie robi większość ludzi, więc stało się standardem, ponieważ wszyscy tak robią. Wiele literatury jest zgodne z tą konwencją, więc ludzie nabrali nawyku.

Konwencja nie jest tak ważna jak spójność w całym kodzie. Tak długo, jak wszystko jest nazwane w spójny sposób, dzięki czemu mogę stwierdzić, na co patrzymy, nie ma znaczenia, czy pierwsza litera jest pisana wielką literą, czy nie.

Uważam, że nieprzyjemnie jest napotkać kod napisany na twój sposób i powiedziałbym, że mi się nie podoba. Ale to kwestia stylu.

Teraz, jeśli robisz to w miejscu pracy, lepiej byłoby kodować w stylu zespołu, aby kod był spójny wszędzie. Zamiast mieć inny kod niż każdy inny.

http://thecodelesscode.com/case/94

1. Dlaczego standard istnieje?

Czyż nie byłoby lepiej pozwolić wszystkim pisać kod zgodnie z osobistymi preferencjami i przestać mówić o tym, który standard jest lepszy?

Faktem jest, że kiedy jesteś przyzwyczajony do jednego stylu, trudniej jest odczytać kod, który używa innego stylu. Twój mózg spędza więcej czasu próbując zrozumieć konwencję (jeśli istnieje), zamiast zrozumieć, co robi kod.

Co jest bardziej czytelne między tymi dwoma fragmentami kodu?

public void comp_metrics ()
{
  int Count;
  List<snapshot> measurements=fromMemoryStorage();
  if (_liveMeasurements.enabled)
    measurements = GrabSnapshots(20, _cache);
    if( !measurements.Any() ) {
        this.Report(LogMessage.Measurements_Are_Empty); return;
    }

    Count = measurements.Count ();

    this.Chart.initialize(( Count + 1 )*2);

    foreach(snapshot S in measurements) {
      this.Chart.append_Snapshot ( S );
    }
}

lub:

public void ComputeMetrics()
{
    const int MaxSnapshots = 20;

    var snapshots = this.liveMeasurements.isEnabled ?
        this.GrabSnapshots(MaxSnapshots, this.cache) :
        this.LoadFromMemoryStorage();

    if (!snapshots.Any())
    {
        this.Report(LogMessage.SnapshotsAreEmpty);
        return;
    }

    var count = measurements.Count();
    this.Chart.Initialize((count + 1) * 2);

    foreach (var s in snapshots)
    {
        this.Chart.AppendSnapshot(s);
    }
}

Oba fragmenty kodu działają podobnie. Jedyną różnicą jest to, że w pierwszym przypadku każdy programista, który pracował nad projektem, używał własnego stylu. To spowodowało, że kod był niespójny, nieczytelny i niebezpieczny. Fakt, że członkowie zespołu nie byli w stanie zgodzić się co do wielkości wcięcia, w połączeniu z faktem, że jeden z nich odmawiał użycia nawiasów klamrowych po każdym, ifsprawił, że kod był wyjątkowo podatny na błędy: patrząc na to, możemy sądzić, że drugi ifjest wykonywane tylko wtedy, gdy pierwsza ifjest prawdziwa, co nie jest prawdą.

W drugim przypadku wszyscy programiści przestrzegali tego samego standardu. Niektóre z nich były być może nieszczęśliwe, ponieważ wolały wcięcia dwóch spacji lub ponieważ były przyzwyczajone do metod rozpoczynających się małą literą. Faktem jest, że kod jest w ten sposób o wiele bardziej czytelny i nadal byłby taki, gdyby używali innego standardu.

Dzięki ścisłym, jednolitym standardom kod jest łatwiejszy do odczytania.

2. Dlaczego ich standard jest lepszy niż ten, który właśnie wymyśliłem?

Jeśli standard jest używany przez setki tysięcy programistów na całym świecie, po prostu trzymaj się go. Nie wymyślaj własnych: nawet jeśli jest to lepsze, łatwiej jest migrować do globalnego standardu niż do setek tysięcy programistów, aby zacząć korzystać z twojego.

Przykład: w mojej firmie mam określoną konwencję nazywania podstawowych i obcych kluczy i indeksów w bazie danych. Te nazwy wyglądają następująco:

• [FK for Application: CreatedByApplicationId],
• [IX for SessionIPAddress: SessionId] lub
• [PK for RoleOfPassword: RoleId, PasswordId].

Osobiście uważam tę konwencję za doskonałą i niezwykle jasną. Dla mnie. Ale to całkowicie do bani. Jest do bani, ponieważ jest moja i ponieważ żaden z tysięcy administratorów baz danych nigdy jej nie używał. To znaczy że:

• Kiedy zatrudnię DBA, będzie on zmuszony nauczyć się nowej konwencji, zamiast rozpocząć teraz pracę,

• Nie mogę udostępniać fragmentów kodu w Internecie w takim stanie: te dziwnie wyglądające nazwiska będą przeszkadzać ludziom, którzy czytają mój kod,

• Jeśli wezmę kod z zewnątrz, aby użyć go we własnym zakresie, będę zmuszony zmodyfikować nazwy, aby były jednolite,

• Jeśli pewnego dnia zdecyduję się użyć jakiegoś znanego standardu, będę zmuszony przejść i zmodyfikować każdą z kilkuset nazw.

3. A co z dużymi literami?

Właściwości mają większy zasięg lub widoczność niż pola lub zmienne lokalne. Tworzenie właściwości zaczyna się od dużej litery, a pola i zmienne - od małej idzie w tym kierunku.

Jeśli weźmiesz pod uwagę C #, ta logika jest wystarczająco spójna.

Jeśli wziąć pod uwagę Javę, metody zaczynają się od małych liter, co nie jest zgodne z logiką.

Więc nie, nie ma ostatecznego dowodu, że ta konwencja jest lepsza od twojej. Po prostu ten jest używany na całym świecie, a twój nie. Żadne nie jest lepsze .

W JavaScript funkcje zaczynają się od małej litery, chyba że wymagają newwcześniejszego. Czy nie byłoby lepiej na odwrót? Może. Faktem jest, że od lat programiści JavaScript używali tego standardu, a nie odwrotnie. Przepisanie każdej książki i zmuszenie każdego programisty do zmiany stylu byłoby teraz nieco skomplikowane.

Technicznie nie ma to znaczenia (a przynajmniej w większości języków nie ma znaczenia).

Jednak większość społeczności programistycznych (niezależnie od tego, czy są to ogólnoświatowe społeczności, które utworzyły się wokół jednego określonego języka, podgrupy takich społeczności, grupy, które powstały wokół popularnej biblioteki lub zestawu narzędzi, czy tylko pojedyncze zespoły) opracowały ustalone standardy kodowania. Dokładne szczegóły są stosunkowo mało ważny (choć w wielu przypadkach dobrym argumentem może być dla nich), co jest ważne jest, aby trzymać się ich.

Nie dlatego, że są najlepsi, ale dlatego, że są tym, czego wszyscy inni używają; jeśli będziesz trzymał się tego standardu, twój kod będzie zgodny z większością innych kodów, których ostatecznie użyjesz - bibliotek, kodu członków drużyny, wbudowanych języków. Konsekwentne nazewnictwo to jedna potężna broń produktywności, ponieważ oznacza to, że kiedy odgadniesz nazwę czegoś, zwykle zgadniesz. Jest to file.SaveTo(), File.saveTo(), file.save_to(), FILE.save_to()? Konwencja nazewnictwa powie ci.

Przenoszenie osobistych preferencji na każdy język, z którym się spotykasz, jest szczególnie niebezpieczne, ponieważ przede wszystkim każdy język ma swoją kulturę, a konwencje nazewnictwa są często niezgodne; a po drugie, istnieje wiele subtelnych różnic między językami, jeśli chodzi o nazewnictwo.

Tylko jeden przykład: w języku C # typy i zmienne żyją w osobnych przestrzeniach nazw; kompilator jest wystarczająco inteligentny, aby poznać różnicę. Jednak w C oba rodzaje nazw mają wspólną przestrzeń nazw, więc nie można mieć typu i zmiennej o tej samej nazwie w tym samym zakresie. Z tego powodu C potrzebuje konwencji nazewnictwa, która odróżnia typy od zmiennych, podczas gdy C # nie.

Dziwi mnie, że nikt inny tego nie powiedział, ale myślę, że różnica wielkości liter jest niezwykle pomocna z jednego powodu: miło i wygodnie jest wiedzieć, czy zmienna ma zasięg lokalny, czy nie. Jeśli zmienna jest lokalna, nie martwię się tak bardzo o skutki uboczne jej zmiany, takie jak refaktoryzacja nazwy. Lubię więc konwencję, która rozróżnia członków klasy od prywatnych zmiennych klasy od zmiennych lokalnych.

W przypadku nowoczesnego Intellisense ma to coraz mniejsze znaczenie, ale nadal daje mi pewne punkty orientacyjne, gdy czytam kod, aby wiedzieć, gdzie powinienem szukać definicji.

Spora część tego może pozostać z mojego gorszego stylu sprzed lat, kiedy metody nie były tak prawdopodobne, aby zmieściły się na jednym ekranie.

To wydaje się bardziej kwestią konwencji niż konkretnej konwencji.

Z każdą złamaną konwencją dodajesz więcej pracy dla wszystkich innych. Być może w idealnym świecie cała firma pracuje nad jednym produktem przez całe życie ... jednak w rzeczywistości nie jest to prawdą. Ludzie przeskakują między projektami, czasem między firmami, a nawet dla zabawy. Im bardziej losowy jest kod, tym trudniej i drożej jest pracować. Jako właściciel firmy lub interesariusz nie chciałbym zatrudniać programistów, którzy myślą samolubnie, niż dla dobra projektu.

Sprowadza się to do profesjonalizmu: czasami musimy odłożyć nasz osobisty styl na bok i zastosować coś, co jest bardziej skuteczne w przypadku masowej adopcji. To zachęca do współpracy i usuwa zewnętrzne bariery, których przede wszystkim nie powinno być.

Zgodnie z twoją obecną konwencją, CapitalCamelCase jest zwykle zarezerwowane dla nazw klas (lub w JavaScript, konstruktorów). Jeśli zobaczę zmienną pisaną wielkimi literami, wyedukowane przypuszczenie będzie dyktować, że muszę ją utworzyć, aby z niej skorzystać. Jeśli to źle, będę wkurzony, że kod nie spełnia standardów społeczności. Nawet w przypadku większości innych języków wszyscy inni, którzy patrzą na to po raz pierwszy, są natychmiast wprowadzani w błąd. Chcę, żeby kod był oczywisty, a nie wprowadzający w błąd.

„ponieważ pełna właściwa wielkość liter powinna być zarezerwowana dla właściwości i metod void. Zmienna lokalna i metody zwracające wartość powinny mieć pierwsze słowo pisane małymi literami”, ponieważ jest to standardowa konwencja.

Inni programiści wyciągają teraz twój kod i myślą, że jest to właściwość, a tak naprawdę zmienna lokalna, co utrudnia pracę.

Jak inni powiedzieli, nie ma żadnego prawdziwego powodu, z wyjątkiem uzyskania konwencji nazewnictwa. Jeśli umieścisz cały zespół na tej samej stronie, prawdopodobnie zaoszczędzisz trochę czasu. Na przykład osobiście zacząłem normę kodowania, która weszła w to i użyliśmy camelCase do wszystkich prywatnych odmian, a także rzeczy przekazanych przez Val, podczas gdy PascalCase użyliśmy do rzeczy publicznych, a także rzeczy przekazanych przez Ref.

Linie stają się trochę rozmyte, gdy mamy do czynienia z takimi rzeczami, jak chroniony, Out czy coś takiego.

Język (z formalnym i konwencjonalnym aspektem) jest ważny dla uporządkowania myśli, ma władzę nad twoimi sposobami myślenia. Tak więc przejście od jednego stylu do drugiego jest bardzo uciążliwe.

Symbole pisane małymi i dużymi literami mają duże różnice semantyczne w Haskell, również różnią się nieznacznie w Scali i użyłem obu z nich. Inne języki, których używam, nie robią różnicy między tymi dwoma rodzajami identyfikatorów, ale trzymanie myśli w sposób, w jaki Haskell postrzega identyfikatory, jest dla mnie o wiele łatwiejsze niż dzielenie umysłu na różne języki.

Dla mnie sprowadza się to do oczekiwań.

Kiedy czytam większość kodu, oczekuję, że wszystko, co zaczyna się od a, lowerCasebędzie zmienną lokalną lub funkcją (w języku C # to byłaby tylko zmienna). Gdybym zobaczył zmienną lokalną ProperCase, prawdopodobnie potknęłbym się i przez pewien czas byłbym zdezorientowany, myśląc, że jest to albo nazwa klasy, albo własność, albo coś innego. Spowoduje to, że ponownie przeczytam kod i irytuje mnie.

To prawdopodobnie dzieje się w twoim przypadku.

Ponadto wygodnie jest móc określić rolę, jaką odgrywa zmienna, patrząc tylko na pierwszą literę, i pozwala uniknąć konfliktów między nazwą instancji a nazwą klasy.

Dla lokalnych zmiennych należy używać małych liter, aby ułatwić pisanie (klawisz prędkości / brak klawisza Shift). Wielkie litery są używane, aby poprawić czytelność, oddzielając słowa w nazwie. Kod z lokalnymi pojedynczymi słowami zmiennych (które powinny być wspólne) jest szybki i łatwy do wpisania. Używanie wielkich liter dla każdego nowego słowa w nazwie jest również szybsze (i mniej miejsca) niż stosowanie podkreślników, które dodają inny znak - jest to również znane jako wielbłąd.

Zgadzam się z PO tutaj. camelCase wygląda po prostu źle. Zgadzam się również z faktem, że jest to standard i musimy trzymać się tego samego standardu lub jaki jest sens posiadania standardu. Ma to również sens, że PascalCaps może być używany do metod itp., A camelCase do własnych zmiennych itp. Jako sposób na rozróżnienie, gdy nie używa się IDE, które koloruje metody dla ciebie.

Aby obejść ten problem, zawsze poprzedzam nazwy mojego obiektu typem obiektu. Więc jeśli jest to zmienna łańcuchowa, nazywam strMyVariable. Jeśli jest to jakiś obiekt, nazywam go objMyObject itp. W ten sposób zaczyna się od małych liter zgodnie ze standardem i wygląda dobrze.