A göndör zárójeleknek a saját vonalukon kell megjelenniük? [zárt]
On február 14, 2021 by adminMegjegyzések
- Megtalálom a " == true " zavaróbb, mint a zárójel elhelyezésének megválasztása.
- @Dan: Úgy gondolom, hogy a feltételes kifejezés mindig kifejtése nagyban hozzájárul az áttekinthetőséghez. kérdés lenne, ha a Az IDE / editor nem ' nem támogatja a göndör zárójel felismerését.
- @ leeand00: néhányunk még mindig kinyomtatja összetett / ismeretlen kódot tanulmányozása / kommentálása céljából. A jó szép nyomtató enyhíti a legtöbb problémát.
- sajnos a kérdés lezárult. Bizonyos idő után a behúzáson alapuló szintaxis használat után átváltottam (talán furcsa) egy másik kapcsos szerkezetre. Mint az első, de záró zárójel a blokk utolsó sorában. (a kódsor után)
Válasz
Diákkoromban göndör zárójeleket tettem ugyanarra sor, így kevesebb sor van, és a kód kevesebb oldalra lesz nyomtatva. Bosszantó, ha egyetlen zárójeles karaktert nyomtatnak, mint az egyetlen dolgot a sorban. (környezet, papírpazarlás)
De a nagy alkalmazások kódolásakor megfizethető lehet néhány vonal engedélyezése, csak zárójelekkel.
Bármelyik stílust is választja , légy következetes , hogy ne váljon saját agyad számára több stílus feldolgozásához kapcsolódó kóddarabok . Különböző forgatókönyvekben (mint fent) azt mondanám, hogy rendben van a különböző stílusok használata, könnyebb “kontextust váltani” magas szinten.
Megjegyzések
- Másrészt az új vonal merevítője ANSI STANDARD, K & R nem. De a szépség a szabványokban az, hogy olyan sok van különbözőek (lásd még: uncyclopedia.wikia.com/wiki/AAAAAAAAA ! az uncyclopedia oldalon).
- " kevesebb sor van " Terabájt tér és sok pixel van. Miért érdekelne több sor használata?
- @ 12431234123412341234123: I azt hiszem, azért gondol, mert néhány ember kinyomtatja a kódot a kód felülvizsgálatához. És minden nem feltétlenül szükséges új sor papírpazarlás, vagy km ² erdő nagymértékben elpazarolt. Ha azonban ne ' ne nyomtassa ki (én bizonyosan ne ' t), akkor az ANSI sokkal jobb, mint a K & R. Emellett bárkinek, aki nyomtatni szándékozik, valószínűleg használnia kell egy automatikus kódformázót – tehát ennek nem a kódolási stílusnak, hanem az eszközöknek a kérdése kell lennie.
- Egyetértek azzal, hogy következetesnek kell maradnia, I “b54ea6a0a5″>
évek óta használok göndör zárójeleket új vonalakon, de más módon kell kevernöm a kódomba, például függvények, névtelen függvények, objektum literálok hívásakor stb. / névtelen kód sokkal könnyebbé teszi az ugyanazon a sorban lévő zárójeleket
Válasz
Soha ne hajtsa végre a harmadik módszert. Ezzel kiegészít valamit a másik záradékkal anélkül, hogy észrevenné, hogy a blokk hiányzik. A nadrágtartó sok fájdalmat fog okozni.
Írja meg a kódot másoknak.
megjegyzések
- bárcsak tudnám, honnan származik ez a kis bölcsesség. Mert a kódod megírása azok számára, akik nyertek ' t, hogy ne olvassák el, körülbelül olyan értelmetlen, amennyire csak lehet …
- A második programozó hozzáadhatja a sajátját nadrágtartó, amikor hozzáad valamit. ' nem hülye, és egy olyan kódolási eljárásban, amely ösztönzi a zárójelek elhagyását az ilyen egyszerű dolgokhoz, ' tudni fogja.
- Az opcionális nadrágtartó nem választható. Kevés rosszabb tervezési döntés született, amelyeket C-ben hoztak meg, és utódainak továbbvittek. Az, hogy egy olyan nyelven él tovább, mint a C #, feldühít.
- Nem ' nem számít, mennyire okos vagy, vagy hogy az egysoros kihagyott göndörök köré épült-e a kódolási szabvány: ha ' probléma vagy hiba megoldására törekszik, valószínűleg hiányolni fogja, hogy a göndöröket kihagyták. És összesen 2 másodpercnyi munka esetén tényleg olyan rossz, ha kifejezetten kifejezed magad?
- Van egy előnye a 3. stílus stílusának ', hogy ' minden hiányzik: Egyszerre több kódot kap a képernyõn.
Válasz
Sokáig azt állítottam, hogy egyenlő értékűek, vagy nagyon közel az egyenlő a helyes választás lehetséges nyeresége messze, messze elmaradt a vitatkozás költségeiről .
A következetesség azonban fontos . Tehát azt mondtam, hogy fordítsunk meg egy érmét, és folytassuk a kódírást.
Láttam, hogy a programozók korábban ellenálltak az ilyen változásoknak. Tedd magad túl rajta! Sokszor váltottam a karrierem során. Még más stílusokat is használok a C # -ben, mint a PowerShell-ben.
Néhány évvel ezelőtt egy olyan csapatnál (~ 20 fejlesztő) dolgoztam, amely úgy döntött, hogy kér írja be, majd hozzon döntést, majd hajtsa végre ezt az egész kódalapon. 1 hetet kellene eldöntenünk.
Sok nyögés & eye -gördülő. Rengeteg “szeretem az utamat, mert” jobb “, de nincs tartalma.
Miközben a kérdés finomabb pontjait tanulmányoztuk, valaki megkérdezte, hogyan kell kezelni ezt a kérdést a brace-on-the -same-line stílus:
void MyFunction( int parameterOne, int parameterTwo) { int localOne, int localTwo }
Ne feledje, hogy nem azonnal nyilvánvaló a paraméterlista vége, és a törzs kezdődik. Összehasonlítás a következővel:
void MyFunction( int parameterOne, int parameterTwo) { int localOne, int localTwo }
Olvastunk néhányat arról, hogy a világ minden táján hogyan foglalkoztak ezzel a problémával, és megtaláltuk azt a mintát, hogy a nyitás után egy üres sort kell hozzáadni kapcsos zárójel:
void MyFunction( int parameterOne, int parameterTwo) { int localOne, int localTwo }
Ha vizuális szünetet fog végrehajtani, akkor azt egy merevítővel is megteheti. Ezután a vizuális törései is következetesek lesznek .
Szerkesztés : Két alternatíva az “extra üres sor” megoldáshoz K & R:
1 / A függvény argumentumait a függvénytesttől eltérően behúzza
2 / Helyezze az első argumentumot ugyanarra a sorra, mint a függvény neve és igazítsa az új sorok további argumentumait az első argumentumhoz.
Példák:
1 /
void MyFunction( int parameterOne, int parameterTwo) { int localOne, int localTwo }
2 /
void MyFunction(int parameterOne, int parameterTwo) { int localOne, int localTwo }
/ Szerkesztés
Még mindig azt állítom, hogy a következetesség fontosabb, mint más szempontok, de ha nincs “div id =” 4 de511d705 “>
megalapozta a precedenst , majd a következő sorra történő fogszabályozás következik.
Megjegyzések
- FYI, lehet, hogy ésszerű embernek hangzom, de ' valójában dió vagyok. Egyszerű, egysoros blokkokhoz nem használok sem zárójelet, sem új vonalat, így ' if (foo) bar () ' vonal. Arra törekszem, hogy a kódom elég egyszerű legyen, így ' nem jelent problémát.
- Jött ide, hogy pontosan ezt közzétegye. Rengeteg ember, aki ugyanazon a vonalon tartja a nyitó zárójelet, üres sorral követi (különösen az órák és módszerek elején), mert különben ' s nehéz elválasztani az osztály / metódus fejlécet a törzstől. Nos, ha ' úgyis használ egy extra sort, akkor oda is teheti a zárójelet, és a behúzás további előnye, hogy könnyebben látható.
- I ' nem láttam az üres sort – I ' m jobban ismerem a MyFunction () paramétereinek kettős behúzását, amikor rátévednek egy másik sorra.
- A paraméterek több sorra történő felosztása őrültséget okoz.
- A " függvény paramétere " argumentum vörös hering. Az érveknek nyilvánvalóan kettősnek kell lenniük. Semmi probléma megkülönböztetni a következő kódtól.
Válasz
A sarkalatos szabályok a következők:
- Kövesse a projekt meglévő kódolási szabványát.
- Ha nincs kódolási szabvány, és valaki más tulajdonában lévő meglévő kódbázist szerkeszt – legyen összhangban a meglévő kód, függetlenül attól, hogy mennyire tetszik / nem tetszik.
- Ha zöldmezős projekten dolgozik – beszéljen meg a csoport többi tagjával, és jusson konszenzusra egy hivatalos vagy informális kódolási szabványról.
- Ha zöldmezős projekten dolgozik egyedüli fejlesztőként, határozza meg saját véleményét, majd legyen kíméletlenül következetes .
Még akkor is, ha nincsenek külső korlátozások, az (IMO) a legjobb, ha meglévő (széles körben használt) kódolási szabványt vagy stílusirányelvet keres, és megpróbálja követni. Ha a saját stílusát tekinti, jó eséllyel néhány év múlva megbánja.
Végül egy olyan stílus, amelyet a meglévő stílusellenőrzők és kódformázók segítségével lehet megvalósítani / megvalósítani, jobb, mint olyan, amelyet manuálisan kell végrehajtani.
Megjegyzések
- Ez a válasz több szavazatot érdemel.
- következetesség a kulcs
Válasz
Az első módszer előnye, hogy vertikálisan kompaktabb , így több kódot helyezhet el a képernyőn, és ezért jobban szeretem. Az egyetlen érv, amelyet a második módszer mellett hallottam, az, hogy megkönnyíti a nyitó és záró zárójel párosítását, de a legtöbb IDE-nek van egy billentyűparancs erre, és ez valójában hamis állítás – a nyitó zárójel és a záró zárójel párosítása helyett párosíthat egy záró zárójelet a “blokk kezdete” kifejezéshez (ha másként, addig, míg) ugyanazon behúzási szint, ezért ugyanolyan könnyen meghatározható ahol a blokk kezdete van.
Nem látok okot arra, hogy egy egész sort csak zárójelre pazaroljunk, amikor az előző / while / if konstrukció már vizuálisan jelzi a blokk kezdetét.
Ennek ellenére úgy gondolom, hogy a zárójelnek a saját sorában kell lennie, mert szükségünk van valamire, amely látható módon jelzi a blokk végét és behúzási szerkezetét.
Megjegyzések
- Nem … I ' azt mondom, miért csökkentem a lehetséges kód mennyiségét illeszkedjen a képernyőn olyasmivel, hogy ' nem ad hozzá az ' egyértelműségű kódhoz?
- Amikor kezdtem a kódolást, mindegyik zárójel tetszett a saját vonalán, most inkább az első módszert részesítem előnyben.
- Hatalmas kutatási kör van, egészen a korai Steam Age-ig (Weinberg, " A számítógépes programozás pszichológiája "), amely azt mutatja, hogy a programozó megértése DRAMATIKUSAN leesik, amikor a megtekinteni kívánt kód mennyisége meghaladja a egyszer (azaz egy szitanyomás, egy nyomtató oldal). Ez a jelenség erősen érvel amellett, hogy a vertikális teret értékes erőforrásnak tekintsék, és ne pazarolják el ingyen, ezért előnyben részesítik az első módszert.
- LOL @ " egy TELJES sor ". ISTENEM! Azt nem!! = P
- @Julio A főiskolán erőteljesen támogattam az 1. módszert, és nem tudtam ' t elolvasni a 2. módszert. Miután dolgozni kezdtem egy olyan cégnél, amely C # -t használ , ahol a standard a 2. módszer, én ' ugyanúgy megkedveltem. Most már tudok olvasni vagy használni; egyik sem zavar. Azok az emberek, akik erősen elutasítóan reagálnak egyikre vagy másikra, általában túlreagálnak valamit, amit nem ismernek.
Válasz
Inkább
if (you.hasAnswer()) { you.postAnswer(); } else { you.doSomething(); }
át
if (you.hasAnswer()) { you.postAnswer(); } else { you.doSomething(); }
, mert a you.postAnswer();
sokkal könnyebben olvasható és első pillantásra megtalálható. Második módon keveredik a felette levő vonallal (you.hasAnswer()
), így a szememnek jobban kell összpontosítania, hogy elolvassa.
Megjegyzések
- Ez mindaddig igaz, amíg a program nem haladja meg a képernyő magasságát. 😉
- @ weberc2 Úgy gondolom, hogy amikor a program meghaladja a képernyő magasságát, két sor kevésbé nyer ' t sokat változtat.
- 10 évvel ezelőtt megállapodtam volna a képernyőről. Ma 1920 * 1200-as képernyőt használok. Rengeteg kódhoz illik, több, mint amennyit az agyam képes feldolgozni egyszerre. Az első módszer lehetővé teszi számomra, hogy visszahúzódjak és megnézzem a különböző hatókörök nyitását / zárását anélkül, hogy el kellene olvasnom.
- Sosem tudtam felfogni, miért választottam ezt a módszert, de ' s pontosan erre.
- @Mageek Ez késik, de ' nem 2 sor, ez ' s Minden sorhoz 2 sor tartozik. Ez ' s O (N), nem O (1). Nem igazán érzem ezt ennyire erősen '; ' sokkal fontosabb, hogy olyan stílust válasszon, amely olvashatóvá teszi a hosszú paraméterlistákat.
Válasz
Inkább az első módszert részesítem előnyben. A nadrágtartók egyáltalán nem érik meg a külön sort.
Az a helyzet, hogy a nadrágtartó nem fontos. “Csak szintaktikai szemetet , ami teljesen felesleges annak megértéséhez, hogy mi a kód, annak célja és célja Csak tisztelgés a régi stílusú C-szerű nyelvek előtt, ahol az operátorok vizuális csoportosítása lehetetlen volt a rendelkezésre álló alacsony képernyő miatt.
Vannak olyan nyelvek (Python, Haskell, Ruby), amelyek zárójelek nélkül teljesen rendben vannak. Ez csak azt erősíti meg, hogy a nadrágtartó szemétkosár, és nem szabad érdemelniük egy sort számukra, amikor csak lehetséges:
if (you.hasAnswer()){ you.postAnswer(); }else{ you.doSomething(); }
Megjegyzések
- Nem tudok ' nem Haskellről vagy Ruby-ról, de a Python a fehértérben érzékeny, ezért nem igényli ' zárójelek vagy más elválasztók a tömbök jelölésére. A nadrágtartók nem csak szintaktikai zajok; tényleges célt szolgálnak.
- @Robert, C-ben mind a szóközt, mind a zárójelet meg kell tennie. A Pythonban csak szóközt kell végrehajtani. Melyik a jobb?
- @Pavel, a C ' fájlban nem kell ' írni a szóközt.
- A @KenBloom C programokat szóköz nélkül lehetetlen olvasni. Tehát mindenképp meg kell tennie őket.
- Függetlenül attól, hogy a kapcsos zárójel jó ötlet-e vagy sem, a puszta létező nyelvek, amelyek nem használják őket ', nem használják őket ' t érvnek tűnik mellettük vagy ellenük. Csak azt sugallja, hogy nyelv is létezhet nélkülük, nem pedig az, hogy ez jó vagy rossz nyelvterv.
Válasz
Használja a Pythont, és teljesen mellőzze az argumentumot.
Megjegyzések
- +1
SyntaxError: not a chance
- Ez egyszerűen nem lehetséges a projektek túlnyomó többségében. Ráadásul a csoportosított behúzással ' megvan a problémák aránya.
- @Bryan, tudom, hogy ez nem ' t nagyon praktikus. Csak azt gondoltam, hogy ez egy olyan nézőpont, amelynek kint kell lennie, erősebbnek, mint pusztán egy megjegyzés. És én ' soha nem találkoztam olyan problémákkal, amelyeket az Ön által sugallt behúzás okoz, valószínűleg azért, mert nem keverem a füleket és a szóközöket. <' / li>
- A Go gombbal teljesen mellőzze az argumentumot (plusz a statikus gépelés, a sebesség és a fordító!) 🙂
- Ezután nyomja meg túl sokszor a szóközt és nézze meg, ahogy a fordító / tolmács nevet rád. ' ez nem fog megtörténni a legtöbb merevített nyelvben.
Válasz
A göndör zárójelek helyzetének konfigurálhatónak kell lennie
metaadatok
konfigurálhatóak az IDE-ben a programozó. Így ezek a bosszantó zárójelek minden kódban, a szerzőtől függetlenül, ugyanúgy néznek ki.
Megjegyzések
- Teljesen egyetértek. ' bemutatása és nem adatai.
- Az a kérdés, hogy ha hagyod, hogy mindenki beállítsa a sajátját, akkor a dolgok nagyon gyorsan elrontódjanak, amikor a kötelezettségvállalások megtörténnek.
- @Andy: Ez ' pontosan a lényeg, az IDE megváltoztatja a megjelenésüket, de csak az IDE-ben! A tényleges forrás nem lesz megérintve. A verziókezeléshez hozzáadhat olyan kampókat, amelyek lefordítják a göndör zárójelek beállításait, bármi is volt a helyzet, így mindenki ugyanúgy ellenőrzi a kódot.
- @klaar Minden modern IDE i ve megváltoztatja a füleket szóközökké, és zárójeleket áthelyez a saját vonalukra vagy a " nyitó " vonal; <
nem tudom, miért gondolja, hogy a forrás nem ' érinti ezeket az eseteket, és ez az oka a megjegyzésemnek. Általában az IDE-k változtatják meg, a fejlesztői beállításoktól függően, ami azt jelenti, hogy egy elkötelezettség során ' sok változást látok, amelyek csak zajok, amikor a nadrágtartók átkerültek a saját vonalukra, így elrejtve a TÉNYLEGES változtatást, amelyet valaki végrehajtott.
Válasz
Az elsőt részesítem előnyben, mert nekem nehezebben látom a hibát ebben a példában.
if (value > maximum); { dosomething(); }
mint ebben a példában
if (value > maximum); { dosomething(); }
A ; {
egyszerűen rosszabbnak tűnik számomra, mint egy ;
ezért valószínűbb, hogy észreveszem.
Megjegyzések
- Jó érvelést mondasz, de személy szerint ez csak soha 5 éves programozásom során egyszer történt velem. Nem tudtam ' kitalálni, hogy miért nem ' hajtották végre, feltettem SO-ra és valaki gyorsan rámutatott a pontosvesszőre. Azonban minden egyes alkalommal, amikor ezt az 1-gyel kevesebb sort használom, nehezebben tudom olvasni.
- A "; {" úgy néz ki, mint a amolyan kacsintó morcos arc, esetleg bajuszos ember.
- +1 Kiváló példa a válaszra: nagyon finom hiba, könnyen figyelmen kívül hagyható. Elgondolkodtató ez az elrendezés is.
- Természetesen minden tisztességes IDE megjelöli az üres vezérlő utasítást, és minden tisztességes fordító figyelmeztetést ad ki.
- @Dunk Az egyetlen hiba a érv (amellyel erőteljesen egyetértek) az, hogy manapság olyan sok ember használ értelmezett nyelveket (JavaScript, PHP és mtsai), hogy sok " programozó " nem tudna ' nem ismerni egy fordítót egy kettős latte-ból.
Válasz
Ez attól függ.
Ha Javascriptben vagy jQuery-ben kódolok, akkor az első űrlapot használom:
jQuery(function($) { if ($ instanceOf jQuery) { alert("$ is the jQuery object!"); } });
De ha C # kódot kódolok, akkor a második űrlapot használom, mert ez kanonikus módszer a C # formátumban történő végrehajtásra.
public int CalculateAge(DateTime birthDate, DateTime now) { int age = now.Year - birthDate.Year; if (now.Month < birthDate.Month || (now.Month == birthDate.Month && now.Day < birthDate.Day)) age--; return age; }
Ne feledje, hogy példád írható
if (you.hasAnswer()) you.postAnswer(); else you.doSomething();
a C # -ba.
Megjegyzések
- Sok ilyen nyelven írható, mert egy blokk-utasítás egy állítás. Hozzátéve! 🙂
- A " Kerettervezési irányelvek szerint " a " kanonikus módon " az, hogy a nyitó zárójelet ugyanarra a vonalra helyezzük (vagyis az első formára). Csak mondd ' …
- @Uwe: Talán. De a Microsoft elfogadta a " igazított zárójeleket " az összes MSDN C # példájához, és ez / div> s a Visual Studio-ba sült, így …
- @Uwe: Ez ' s Cwalina ' könyvét, és ez ' rettenetesen meg van nevezve, mivel sokkal több ennél. Az MSDN-n lévő FDG-nek erről nincs mit mondania. Arra is kíváncsi vagyok, miért mondanának a Framework Design irányelvek bármit is a C # kódolás gyakorlatról?
- Tulajdonképpen göndör zárójeleket kell ugyanarra a sorra tenni a Javascriptben. Hibákat okozhat, ha a göndör zárójelek a saját vonalukon vannak. Lásd például: encosia.com/…
Válasz
Az 1) enyhe változatát kedvelem.
if (you.hasAnswer()) { you.postAnswer(); } // note the break here else { you.doSomething(); }
Miért?
-
Szerintem a mindig a zárójelek saját vonalukra helyezése csökkenti az olvashatóságot. Csak bizonyos mennyiségű forráskód fér el a képernyőn. A 2) zárójel stílusa fájdalmasan hosszú, sok beágyazott hurkot és feltételeket tartalmazó algoritmusokat készít.
-
Szeretném azonban, ha a
else
elindulna új soron, mert aif
és aelse
vizuálisan összetartozik. Ha zárójel van aelse
előtt, akkor sokkal nehezebb felismerni, hogy mi tartozik mihez. -
3 ) kizárja magát. Mindannyian tudjuk, hogy milyen rossz dolgok történhetnek, ha elhagyja a zárójeleket, és megfeledkezik róla.
Megjegyzések
- Láttam ezt, ahol dolgozom. ' érdekes.
- Ez a stílus is jobban tetszik, mivel lehetővé teszi, hogy a megjegyzést a
else
sort, ha szükséges, és / vagy tegyen egy üres sort az if-block és az else-block közé, hogy a dolgok kevésbé legyenek zsúfoltak. A 2. zárójel stílus nem tesz mást, mint hogy elhatárolja a műveleteket a feltételektől. Ennek ellenére a kedvencem mindenképpen a python ' nincs zárójeles stílus 🙂 - Ha fontos a képernyőn látható kódsorok számának maximalizálása, akkor egyszerűen tedd el új vonalakkal. ' sok sort tudsz elérni egy képernyőn. Inkább nem okoz semmi szünetet és gondolkodást olvasás közben, azaz. definícióm az olvashatóbb. A nadrágtartóval az elmém figyelmen kívül hagyja őket. A nadrágtartó nélkül az elmémnek szünetet kell tartania és igazítania kell a vezérlő blokkokat. Nem hosszú szünet, de mégis szünet.
- Igen, ha és még tartoznak egymáshoz, DE ugyanígy vannak {és} és mivel} külön sorban vannak, {külön kell lennie. vonal is. " Csak egy bizonyos mennyiségű forráskódot tudok elhelyezni a képernyőn " És hogy ' s pontosan miért nem mondható el a 3) kimondása " önmagának kizárása ". Egy évtizedes munka után 3) Nem felejtettem el zárójelek hozzáadását új kódsor hozzáadásakor, és soha nem ismerek senkit sem. Ha hozzá kell igazítanom a kódot az emberekhez, ki ' nem tud megfelelően olvasni, hol ér véget? Megszűnik bizonyos nyelvi funkciók használata, mert a kódolvasók egy része esetleg nem érti őket?
Válasz
Valahol olvastam, hogy néhány könyv szerzői azt akarták, hogy kódjuk a következő legyen:
if (you.hasAnswer()) { you.postAnswer(); } else { you.doSomething(); }
De a kiadó helyszűke miatt ezt kellett használniuk:
if (you.hasAnswer()) { you.postAnswer(); } else { you.doSomething(); }
Most nem tudom, hogy ez igaz-e (mivel már nem találom), de ez utóbbi stílus nagyon elterjedt a könyvekben.
Személyes szinten inkább a zárójeleket választom külön sor, mint:
a) új hatókört jeleznek
b) könnyebben észrevehető, ha nem egyezik (bár ez kevésbé olyan probléma egy IDE-ben, amely kiemeli a hibákat neked).
Megjegyzések
- … A második lehetőség megkönnyíti mindkét pontodat (csak a behúzás szolgálja a zárójel célját / behúzási kombináció). 🙂
Válasz
Ah, a Egy igazi merevítő stílus .
Minden benne van a Szent W-ben ay – még egy próféta is (Richard “az utam vagy az autópálya” Stallman).
A srác annyira tévedett sok mindenben, de a GNU figyelemre méltó, amikor a nadrágtartóról van szó.
[Frissítés] Láttam a fényt, és most imádok Allmant
Megjegyzések
- Nem ' nem látom a GNU stílus lényegét, nem pedig azt, hogy lisp kódot modellezne. Sok munkának tűnik kevés haszonért.
- Nem ismerek senkit, aki használja a GNU stílust. 1TBS egészen.
- Nem tehet ' blokkonként két behúzási szintnél rosszabbat, kivéve természetesen a lisp stílust, ami magától értetődik.
- +1 a kapcsos stílusok linkjéhez. Ez azt mutatja, hogy bármilyen stílusú is, sok nagyszerű ember nem ért egyet veled.
- @RobertHarvey Nincs többletmunka, ha van, akkor nem használja ' megfelelő eszköz a kód írásához vagy a dint konfigurálásához. Ennek előnye sokkal olvashatóbb kód, nagyon gyorsan látja a zárójelben lévő hibákat, és egyszerűen olvashatja csak a kódot, miközben figyelmen kívül hagyja az alblokkokat.
Válasz
Második példa: Nagyon nagy vagyok az olvashatóságban. Nem állhatok ki más módon, ha blokkolom = (
megjegyzések
- A kutatások szerint ' könnyebben olvasható kompakt kód, ha egy kódbázis meghaladja a képernyő magasságát.
- @ weberc2 , tudna DOI-kat adni ezekhez a kutatási cikkekhez?
Válasz
Egyszerű válasz: mit könnyebb hibakeresni?
// Case 1: void dummyFunction() { for (i = 0; i != 10; ++i) { if (i <= 10) std::cout << "i is: " << i << "\n"; std::cout << 10 - i << " steps remaining\n"; // Some hard work here // which is really hard // and does take some screen estate } else std::cout << "We"ll never get there"; } } // COMPILER ERROR HERE // Case 2: void dummyFunction() { for (i = 0; i != 10; ++i) if (i <= 10) { std::cout << "i is: " << i << "\n"; std::cout << 10 - i << " steps remaining\n"; // Some hard work here // which is really hard // and does take some screen estate } else std::cout << "We"ll never get there\n"; } } // COMPILER ERROR HERE
Melyik esetben diagnosztizálta először a problémát?
Nem érdekel a személyes preferenciák (sok más van stílusok, beleértve a kovácsot és másokat is), és én nem érdekelek sokat … mindaddig, amíg ez nem akadályozza a kódolvasás képességét és hibakeresést it.
A s a “space space” argumentumhoz, nem veszem meg: úgyis inkább üres sorokat adok a logikai csoportok közé, hogy világosabbá tegyem a programot …
Hozzászólások
- Mindkettőjüket olyan könnyű hibakeresni, főleg azért, mert ' rövid kódblokk. A behúzás következetes, ami megkönnyíti a tényleges kódblokkok vizualizálását.
- @Htbaa: valóban 🙂 Akkor miért bajlódni?
- @MatthieuM. Az első blokk értelmesebb számomra, mert az új vonalak (a második blokkban) a funkció aláírás, a for-utasítás és az if-utasítás között azt hiszem, hogy nem kapcsolódnak egymáshoz, de nyilvánvalóan nem ' t. Az üres sorok elkülönítik a független kódbiteket; a kód, amelyet ' más kódsorok közelében áll, azt jelenti, hogy azok valójában kapcsolatban állnak egymással. Ez természetesen ' imo ', de kíváncsi voltam, mi a véleményed. SZERKESZTÉS: a megfelelő IDE is észrevesz minden hiányzó zárójelet, és hibákat okoz a kód értelmezése során.
- Szeretném felhívni a figyelmet arra, hogy ez a két kódrész teljesen különbözik egymástól. Fordítói hibák lennének a kód különböző pontjain. Az elsőnek fordítói hibája lenne a " else ", az utolsó pedig göndör. A másodiknál csak az utolsó göndörnél lenne fordítói hiba.
Válasz
Nem mintha bárki észrevenné, de ezért a zárójelek a azonos sorba tartoznak, mint a feltételesek (kivéve a nagyon hosszú feltételeket, de ez egy él eset):
A C-ben ez egy érvényes konstrukció:
while(true); { char c; getchar(); //Wait for input }
Gyors! Mit csinál ez a kód? Ha válaszolt ” végtelen ciklus, amely bemenetet kér “, téved! Még a bemenetig sem jut el. A (z) while(true)
oldalon akad el. Figyelje meg azt a pontosvesszőt a végén.Ez a minta valójában gyakoribb, úgy tűnik, annak kellene lennie; A C megköveteli, hogy a blokk elején deklaráld a változókat, ezért indítottak újat.
A kódsor egy gondolat. A nadrágtartó a gondolatnak a feltételes vagy a hurok részét képező része. Ezért a azonos sorba tartoznak.
Megjegyzések
- Ez messze a legjobb érv a K & R stílus mellett, amit láttam, a többi ma már nevetséges ' s IDE rendszerek kódhajtogatással. Ez csak azokra a C stílusú nyelvekre vonatkozik, amelyek támogatják a
;
blokkvégeket. Ezért is megvetem ezt a blokkvégző rendszert, amely az IMHO elavult, és a Go nyelv ezt bizonyítja. Sokszor láttam ezt a kérdést, bár nem ebben a forgatókönyvben. Általában ott történik, ahol valamit hozzá akarnak adni az állításhoz, és elfelejtik.
Válasz
Tetszik a első módszer. Rendesebbnek tűnik az IMO, és kompaktabb, ami tetszik.
SZERKESZTÉS: Ah, egy harmadik. Lehetőleg a legjobban kedvelem, mivel még kisebb / rendesebb.
Válasz
Írhatná:
you.hasAnswer() ? you.postAnswer() : you.doSomething();
válaszold meg a kérdést; A göndör zárójeleket inkább a saját vonalukon részesítettem előnyben, de azért, hogy ne kelljen gondolkodnom a pontosvesszővel történő automatikus beillesztés hibáiról a böngészőkben, elkezdtem az egyiptomi stílust használni a javascripthez. Amikor a java-t kódoltam a napfogyatkozásban, nem érdekelt az alapértelmezett zárójel-stílus harcolása (vagy konfigurálása), ezért ebben az esetben is az egyiptommal jártam. Most jól állok mindkettővel.
Megjegyzések
- így használhatók,
postAnswer()
és AdoSomething()
értéknek vissza kell adnia a háromszintű operátor számára, ami gyakran nem így van: nagyon jól visszaadhatja az érvénytelen értéket (nincs érték), és a?:
hozzá kell rendelni valamilyen változóhoz
Válasz
Szinte az összes válasz itt mondunk néhány változatot a “Bármit is csinálsz, maradj egy vagy kettő mellett”.
Szóval egy pillanatig elgondolkodtam rajta, és be kellett vallanom, hogy csak nem látom olyan fontosnak . Tud valaki őszintén megmondani, hogy az alábbiakat nehéz betartani?
int foo(int a, Bar b) { int c = 0; while(a != c) { if(b.value[a] == c) { c = CONST_A; } c++; } return c; }
Nem vagyok biztos senki másban … de mentálisan teljesen nulla problémám van Előre-hátra váltás a stílusok között. Néhány percbe tellett, mire rájöttem, hogy mit csinált a kód, de ez annak az eredménye, hogy csak véletlenszerűen írtam be a C-szerű szintaxist. 🙂
Nem túl szerény véleményem szerint a nyitó zárójelek szinte teljesen lényegtelenek a kód olvashatóság szempontjából. Van néhány fentebb felsorolt sarokeset, ahol az egyik vagy a másik stílus változtat, de az üres sorok megfontolt használata tisztázza ezt.
FWIW, a munkahelyi kódolási stílusaink kissé használnak strukturáltabb 1. forma és egy módosított 3. forma. (C ++)
// blank line is required here if (x) { //This blank line is required y = z; } // blank line is required here too, unless this line is only another "}" if (x) y = z; //allowed if (x) y = z; // forbidden
Kíváncsi vagyok, hogy azok, akik erősen kedvelik a 2. formát, megtalálják az 1. forma ezen változatát jobb, csak azért, mert az üres sor erősebb vizuális elválasztást eredményez.
Megjegyzések
- Ahogy a példád is mutatja, a behúzás annyira fontos, mint a zárójel az olvashatóság érdekében kód. Valójában egyes nyelvek a behúzást teszik az utasítások beágyazásának csak csak módjává!
- Rendben, őszintén szólva nehezen olvashatónak találom az inkonzisztens példát. Nem igazán nehéz, de nehezebb, mintha következetesek voltak.
- Egyetértek az Almo-val. Nem " esetről van szó, valóban nehéz " . " esetről van szó, egyértelműen nehezebb ", még ha nem is nehéz. Akkor miért nehezíti meg a dolgokat? A " toy " játékok példáiban az emberek természetesen nem sok különbséget mutatnak. Tapasztalatom szerint amikor valaki csúnya kódot örökölök mástól, és ők az 1. módszert alkalmazták, elég gyakran szükségessé válik a továbbfejlesztés és a 2. módszerré alakítása, csak a logika követése érdekében. Mivel gyakran szükségessé válik; automatikusan megválaszolja azt a kérdést, hogy melyik módszer a jobb és könnyebben érthető.
- @Dunk: Nem tudom felismerni azt a kódot, amelyet érezhetően javítanék az ilyen lényegtelen részletek felcserélésével.
- @jkerian -Nem látszik, hogy ' nem sok kódot örökölt másoktól, akik már rég elhagyták a projektet vagy a vállalatot. ' nem tudom felismerni, hogy néhány év tapasztalattal senki ne kerüljön ebbe a helyzetbe. De akkor megint mindenkinek más a helyzete '. Továbbá, ha " formális " kódellenőrzést kell elvégeznie, a formázás nagy különbséget jelent. Nagyon fontos, hogy természetesen elolvashassuk a kódot.Biztosan tudok szünetet tartani és gondolkodni a zárójelek összeillesztésén, de ez lassítja a folyamatot. Az egyik mód nem igényel szünetet, a többiek igen. Ez ' ezért nem látom ', hogy miért lehetne más választást javasolni.
Válasz
Nem lepődtem meg, hogy ezt még nem vetettem fel. Inkább a második megközelítést részesítem előnyben, mert így könnyebben kiválaszthatja a blokkot.
Amikor a zárójelek ugyanabban az oszlopban és a saját vonalukon kezdődnek és végződnek, választhat a margóból vagy a 0. oszlop kurzorával billentyűleütések billentyűzet választással.
Eredetileg fogszabályozóval dolgoztam ugyanazon a vonalon, mint a feltételes, de amikor váltottam, azt tapasztaltam, hogy ez gyorsabbá tette a munkát. Természetesen nem éjjel és nappal, hanem valami olyasmi, ami lassítani fogja a feltételrendszer melletti nadrágtartóval való munkát.
Megjegyzések
- A hozzám hasonló öreg időzítők három billentyűleütéssel választják ki a blokkot, függetlenül attól, hogy hol vannak az átkozott zárójelek.
Válasz
Én személy szerint szeretem a második utat.
Azonban az, ahogyan bemutatom, véleményem szerint a legjobb, mert ez a legnagyobb munkabiztonságot eredményezi! Egyetemi hallgatótársam segítséget kért tőlem a házi feladatokhoz, és így nézett ki a kódja. Az egész program egyetlen blokknak tűnt. Érdekesség, hogy az általa készített program hibáinak 95% -a nem megfelelő fogszabályozóból származott. A többi 5% nyilvánvaló volt, miután a zárójeleket összeillesztették.
while(1){ i=0; printf("Enter coded text:\n"); while((s=getchar())!="\n"){ if(i%1==0){ start=(char*)realloc(input,(i+1)*sizeof(char)); if(start==NULL){ printf("Memory allocation failed!"); exit(1);} input=start;} input[i++]=s;} start=(char*)realloc(input,(i+1)*sizeof(char)); if(start==NULL){ printf("Memory allocation failed!!!"); exit(1);} input=start; input[i]="\0"; puts(input);
Megjegyzések
- Rossz, rossz , Szörnyű, szörnyű példát értek. A probléma nem a nadrágtartó! ' ez az őrült behúzás!
- @Martinho Fernandes azt hittem, hogy a zárójel és a behúzás együtt jár …
- nem feltétlenül. .. végezzen megfelelő behúzást a fentieken, majd véletlenszerűen váltson kapcsos stílusokat, ' ll úgy találja, hogy ez ' érthető.
- Valójában ezen gondolkodás motiválta a saját válaszomat erre a kérdésre.
- " A program hibáinak 95% -a származott nem megfelelő zárójelek " – csak értelmezett nyelveken, nem összeállítva.
Válasz
Személyes preferenciám az első módszer, valószínűleg azért, mert így tanultam meg először a PHP-t.
Egysoros if
állításoknál, Használom
if (you.hasAnswer()) you.postAnswer();
Ha nem you.postAnswer();
, hanem valami sokkal hosszabb ideig, például you.postAnswer(this.AnswerId, this.AnswerText, this.AnswerType);
I “valószínűleg visszatérek a fi-re első típus:
if (you.hasAnswer) { you.postAnswer(this.AnswerId, this.AnswerText, this.AnswerType); }
Soha nem használok sortörést, és soha nem fogom használni ezt a módszert, ha van else
állítás.
if (you.hasAnswer()) you.postAnswer(); else you.doSomething()
elméleti lehetőség, de soha nem használok ilyet. Ezt
if (you.hasAnswer()) { you.postAnswer(); } else { you.doSomething(); }
Válasz
Nem kellene; első módszer a számomra.
Amikor a másodikat nézem, a fel nem használt vonalak miatt (azok, amelyek csak a zárójelek vannak rajta, kivéve a legutolsó zárójelet), úgy érzi, hogy megtörik a folyamat folytonosságát. a kód. Nem tudom elolvasni olyan gyorsan, mert különös figyelmet kell fordítanom az üres sorokra, amelyek általában elválasztást jelentenek a kódban vagy ilyesmi, de semmiképpen sem “ez a sor egy göndör zárójelhez tartozik” (amely csak megismétli a jelentést
Mindenesetre, csakúgy, mint amikor szöveget írsz … egy bekezdés elejére behúzás hozzáadása felesleges, ha előtte van egy üres sor (a bekezdésváltozás kettős jele), ott nem kell pazarolni a merevítők számára a sorokat, ha megfelelően behúzódunk.
Ráadásul, amint már említettük, több kódot is elfér a képernyőn, ami egyébként egy kicsit kontraproduktív.
Válasz
Ez a platformtól / nyelvtől / konvenciótól függ
Java-ban:
void someMethod() { if (you.hasAnswer()) { you.postAnswer(); } else { you.doSomething(); } }
C # -ben
void someMethod() { if (you.hasAnswer()) { you.postAnswer(); } else { you.doSomething(); } }
C-ben:
void someMethod() { if (you_hasAnswer()) { you.postAnswer(); } else { you_doSomething(); } }
Utálom, amikor a Java srácok a stílusukat használják a C # kódban, és fordítva.
Megjegyzések
- A C stílus al módon bosszantottak. Legyen következetes!
Válasz
Csak annyit mondhatok, hogy ha rajong a 3. módszerért , a földön minden IDE kód-formázó üldözni fog.
Válasz
Az első módszert egyszerűen azért használom, mert tömörebb és több kódot enged a képernyőn. Jómagam még soha nem volt probléma a zárójel párosításával (mindig kiírom őket a if
utasítással együtt, mielőtt hozzáadom a feltételt , és a legtöbb környezet lehetővé teszi a megfelelő zárójelre ugrást).
Ha kellett vizuálisan párosítania a zárójeleket, akkor a második módszert részesíteném előnyben. Ez azonban kevesebb kódot engedélyez egyszerre, amihez többet kell görgetnie. És ez legalábbis számomra nagyobb hatással van a kód olvasására, mint a szépen igazított zárójelek. Utálom a görgetést. Akkor is, ha egyetlen if
utasításon kell átgörgetnie, akkor az valószínűleg túl nagy, és újra kell dolgozni.
De; mindennél a következetesség a legfontosabb. Használja az egyiket vagy a másikat – soha ne használja mindkettőt!
Válasz
Amikor először tanultam programozni 12 évesen, feltettem a zárójeleket a következő sor, mert a Microsoft kódolási oktatói ilyenek. Abban az időben behúztam a 4 szóközű TABS-t is.
Néhány év után megtanultam a Java-t és a JavaScript-et, és több kapcsos zárójelet láttam ugyanazon a vonalon, ezért megváltoztattam. Elkezdtem behúzni a két szóköz szóközöket is.
Megjegyzések
- +1, -1. Miért ne tenné a fülekkel behúzást, mivel bármely szerkesztő beállíthatja a fül hosszát az ön tetszőleges hosszához? Ellenkező esetben sok olyan embert vezetsz, aki kedveli az igazi behúzást 8-nál, hogy átkozd a kódodat.
Válasz
Van egy 4. lehetőség, amely a zárójeleket igazítva tartja, de nem pazarolja a teret:
if (you.hasAnswer()) { you.postAnswer(); i.readAnswer(); } else { you.doSomething(); }
A probléma csak az, hogy az IDE legtöbb autoformátora fojtogatja ezt.
Megjegyzések
- … akárcsak a legtöbb programozó, aki ezt megfulladná.
- Ez borzalmasnak tűnik. Gondoljon a extra erőfeszítéseket kell tennie, ha be akar illeszteni egy sort a tetejére, vagy eltávolítja a felső sort. ' nem csak törölheti a sort, és továbbléphet, emlékeznie kell rá hogy visszahelyezzük a göndör zárójelet.
- lol ez fantasztikus! 🙂 jobb, mint az első stílus!
- Nyilvánvalóan még neve is van. A Horstman Syyle szerepel a wikipédiában . Én ' olyan kódbázissal dolgoztam, mint ez ' nem igazán rossz használja.
Válasz
Mindez rajtad múlik, amíg nem olyan projekten dolgozik, ahol néhány kódolási korlátozásokat vagy néhány szabványt határozott meg a projektmenedzser, amelyet a programozáson részt vevő összes programozónak be kell tartania a kódolás során.
Én személy szerint az 1. módszert részesíteném előnyben.
És azt sem értem, amit a 3. módszerrel meg akarsz mutatni?
Ez nem rossz módszer? Vegyünk például egy helyzetet ..
if (you.hasAnswer()) you.postAnswer(); else you.doSomething();
Most mi van, ha valaki még néhány mondatot akar hozzáadni a ha blokkolva van?
Ebben az esetben, ha a 3. módszert használja, a fordító eldobja a szintaxis hibát.
if (you.hasAnswer()) you.postAnswer1(); you.postAnswer2(); else you.doSomething();
Megjegyzések
- Még rosszabb lenne, ha valaki jönne és megtenné: if (you.hasAnswer ()) you.postAnswer (); mást tennél.dobban (); te.doSomethingElse (); – ez ' olyan finom hibák receptje, amelyeken a szem könnyen átcsúszik, és a fordító nem fog segíteni ' sem
- @FinnNk: Pontosan!
- Ha valaki újabb állítást szeretne hozzáadni, maga is beteheti a zárójelet. Bármelyik sót megért programozónak képesnek kell lennie arra, hogy ezt kitalálja.
- Azt akartam mondani, hogy a 3. módszere hibás.
- @Robert Harvey, I ' láttuk, hogy a tapasztalt kódolók hiányolják a zárójeleket a meglévő kód módosításakor. Szerintem a probléma az, hogy a behúzás sokkal erősebb nyom a jelentéshez, mint a kapcsos zárójel (főleg mivel többféle zárójeles stílus létezik), így ' nagyon könnyű figyelmen kívül hagyni a hiányzó zárójelet a behúzás úgy néz ki, mint amire számíthat.
Vélemény, hozzászólás?