Moeten accolades op hun eigen lijn verschijnen? [gesloten]
Geplaatst op februari 14, 2021 door adminReacties
- Ik vind de " == true " meer afleidend dan de keuze voor de plaatsing van de beugel.
- @Dan: Ik denk dat het altijd duidelijk maken van de voorwaardelijke uitdrukking enorm helpt.
- De enige reden waarom dit zou kwestie zou zijn als je IDE / editor ondersteunt ' t geen overeenkomende accoladeherkenning.
- @ leeand00: sommigen van ons printen nog steeds complexe / onbekende code om het te bestuderen / annoteren. Een goede mooie printer verzacht echter de meeste problemen.
- Helaas is de vraag gesloten. Na enige tijd van op inspringen gebaseerd syntaxisgebruik schakelde ik over naar (misschien raar) een andere beugelstructuur. Zoals je eerste maar sluitende accolade in de laatste regel van het blok. (na coderegel)
Answer
Toen ik een student was, zette ik accolades op hetzelfde regel, zodat er minder regels zijn en de code op minder paginas wordt afgedrukt. Het is vervelend om naar een enkel haakje te kijken dat als het enige op een regel staat afgedrukt. (milieu, papierverspilling)
Maar bij het coderen van grote applicaties, is het toestaan van sommige regels met alleen accolades erin betaalbaar, gezien het “groeperingsgevoel” dat het geeft.
Welke stijl je ook kiest , wees consistent zodat het geen overhead voor uw eigen brein wordt om meerdere stijlen te verwerken in gerelateerde stukjes code . In verschillende scenarios (zoals hierboven) zou ik zeggen dat het oké is om verschillende stijlen te gebruiken, het is gemakkelijker om “context te wisselen” op een hoog niveau.
Reacties
- Aan de andere kant is de accolade op de nieuwe regel een ANSI STANDARD, K & R is dat niet. Maar het mooie van standaarden is dat er zoveel zijn verschillende (zie ook uncyclopedia.wikia.com/wiki/AAAAAAAAA ! op uncyclopedia).
- " er zijn minder regels " Ik heb terabytes aan ruimte en veel pixels. Waarom zou ik me druk maken om meer regels te gebruiken?
- @ 12431234123412341234123: I denk dat hij bedoelt omdat sommige mensen de code afdrukken voor codebeoordeling. En elke niet absoluut noodzakelijke nieuwe regel is verspild papier, of een km ² bos verspild op grote schaal. don ' print het niet uit (ik doe het zeker niet ' t) dan is ANSI een stuk beter dan K & R. Ook zou iedereen die van plan is om af te drukken waarschijnlijk een geautomatiseerde code-opmaak moeten gebruiken – dus dit zou een kwestie van tooling moeten zijn, niet een van codeerstijl.
- Ik ben het ermee eens dat je consistent moet blijven, ik ' Ik gebruik al jaren accolades op nieuwe regels, maar ik moet mijn code andersom mengen, zoals bij het aanroepen van functies, anonieme functies, objectliteratuur enz. Alle op expressies gebaseerde talen / anonymous code maakt haakjes op dezelfde regel veel gemakkelijker
Answer
Je zou nooit de derde methode moeten doen.
Als je op beugels beknibbelt, kun je de eerste keer een paar toetsaanslagen besparen, maar de volgende coder die komt mee, voegt iets toe aan je else-clausule zonder op te merken dat het blok ontbreekt, beugels zullen veel pijn krijgen.
Schrijf uw code voor andere mensen.
Opmerkingen
- Ik wou dat ik wist waar dat beetje wijsheid vandaan kwam. Omdat het schrijven van je code voor mensen die ' niet de moeite hebben genomen om het te lezen, ongeveer net zo zinloos is als je kunt krijgen …
- De tweede programmeur kan zijn eigen code toevoegen accolades als hij iets toevoegt. Hij ' is niet dom, en in een coderingsconventie die het weglaten van accolades aanmoedigt voor eenvoudige dingen als deze, zal hij ' weten te kijken.
- Optionele accolades zijn niet optioneel. Er zijn weinig slechtere ontwerpbeslissingen die zijn genomen in C en zijn overgedragen aan zijn nakomelingen. Dat het voortleeft in een taal zo recent als C # maakt me woedend.
- Het maakt niet ' uit hoe slim je bent of hoe ingebakken de coderingsstandaard rond enkele regel weggelaten curlies is: als je ' als u een probleem of bug wilt oplossen, zult u waarschijnlijk missen dat de curlies zijn weggelaten. En voor een totaal van 2 seconden werk, is het echt zo erg om expliciet te zijn?
- Er is ' een voordeel van stijl # 3 dat je ' re ontbreken allemaal: je krijgt meer code tegelijk op je scherm.
Antwoord
Lange tijd heb ik betoogd dat ze van gelijke waarde waren, of zo heel dicht bij gelijk dat de mogelijke winst door het maken van de juiste keuze lag ver, ver, onder de kosten van het erover discussiëren .
consistent zijn is echter belangrijk . Dus ik zei: laten we een muntje omdraaien en code gaan schrijven.
Ik heb gezien dat programmeurs zich eerder verzetten tegen dit soort veranderingen. Kom er overheen! Ik ben in mijn carrière vaak veranderd. Ik gebruik zelfs andere stijlen in mijn C # dan in mijn PowerShell.
Een paar jaar geleden werkte ik in een team (~ 20 ontwikkelaars) dat besloot om te vragen naar invoer, en dan een beslissing nemen, en die vervolgens afdwingen in de hele codebasis. We “hadden 1 week om te beslissen.
Veel gekreun & eye -rollen. Veel van “Ik vind mijn manier leuk, omdat het” beter “is, maar geen inhoud.
Terwijl we de details van de vraag bestudeerden, vroeg iemand hoe we dit probleem moesten aanpakken. -same-line style:
void MyFunction( int parameterOne, int parameterTwo) { int localOne, int localTwo }
Merk op dat het niet meteen duidelijk is waar de parameterlijst eindigt en de body begint. Vergelijk met:
void MyFunction( int parameterOne, int parameterTwo) { int localOne, int localTwo }
We hebben wat gelezen over hoe mensen over de hele wereld met dit probleem waren omgegaan, en ontdekten het patroon van het toevoegen van een lege regel na de open brace:
void MyFunction( int parameterOne, int parameterTwo) { int localOne, int localTwo }
Als u “een visuele onderbreking gaat maken, kunt u dit net zo goed doen met een steun. Dan worden uw visuele onderbrekingen ook consistent .
Bewerken : twee alternatieven voor de “extra lege regel” -oplossing bij gebruik van K & R:
1 / Laat de functieargumenten anders inspringen dan de hoofdtekst van de functie
2 / Zet het eerste argument op dezelfde regel als de functienaam en lijn verdere argumenten op nieuwe regels uit met dat eerste argument.
Voorbeelden:
1 /
void MyFunction( int parameterOne, int parameterTwo) { int localOne, int localTwo }
2 /
void MyFunction(int parameterOne, int parameterTwo) { int localOne, int localTwo }
/ Bewerken
Ik beweer nog steeds dat consistentie belangrijker is dan andere overwegingen, maar als we geen geschapen precedent , dan is brace-on-next-line de juiste keuze.
Reacties
- Ter info, ik klink misschien als een redelijk persoon, maar ik ' ben eigenlijk een gek. Voor eenvoudige blokken van één regel gebruik ik geen accolades of nieuwe regels, waardoor ' if (foo) bar () ' allemaal één is lijn. Ik streef ernaar om mijn code zo eenvoudig te maken dat het ' geen probleem is.
- Kwam hier om precies dit te posten. Talloze mensen die het accolade openen op dezelfde regel, volgen het op met een lege regel (vooral aan het begin van klassen en methoden) omdat het anders ' s is moeilijk te scheiden van de class / method-header van de body. Welnu, als je ' toch een extra regel gaat gebruiken, kun je net zo goed de beugel daar plaatsen en het extra voordeel krijgen dat de inspringing gemakkelijker te zien is.
- Ik ' heb de lege regel niet gezien – ik ' ben meer bekend met het dubbel inspringen van de parameters voor MyFunction () wanneer ze dwalen af op een andere regel.
- Het op deze manier uitsplitsen van de parameters naar meerdere regels is gekmakend.
- De " functieparameter " argument is een rode haring. Het is duidelijk dat de argumenten dubbel bedoeld moeten zijn. Geen enkel probleem om het te onderscheiden van de volgende code.
Antwoord
De hoofdregels zijn:
- Volg de bestaande coderingsstandaard van het project.
- Als er geen coderingsstandaard is en u bewerkt een bestaande codebasis die eigendom is van iemand anders, wees dan consistent met de stijl van de bestaande code, ongeacht hoeveel je er wel / niet van houdt.
- Als je aan een groen-veldproject werkt, bespreek dit dan met andere teamleden en kom tot een consensus over een formele of informele coderingsstandaard.
- Als je als enige ontwikkelaar aan een green-field-project werkt, neem dan een besluit en wees meedogenloos consistent .
Zelfs als je geen externe beperkingen op je hebt, is het (IMO) het beste om te zoeken naar een bestaande (veelgebruikte) coderingsstandaard of stijlrichtlijn, en probeer die te volgen. Als je je eigen stijl kiest, is de kans groot dat je er binnen een paar jaar spijt van krijgt.
Ten slotte is een stijl die geïmplementeerd / implementeerbaar is met bestaande stijlcheckers en code-opmaakprogrammas beter dan een die handmatig “afgedwongen” moet worden.
Reacties
- Dit antwoord verdient meer stemmen.
- consistentie is key
Answer
Het voordeel van de eerste methode is dat deze verticaal compacter is , zodat u meer code op uw scherm kunt plaatsen, en daarom geef ik er de voorkeur aan. Het enige argument dat ik hoorde ten gunste van de tweede methode is dat het gemakkelijker wordt om haakjes openen en sluiten te koppelen, maar de meeste IDEs hebben een sneltoets daarvoor, en het is eigenlijk een valse verklaring – in plaats van een haakje openen aan een haakje sluiten, kun je een haakje sluiten koppelen aan de uitdrukking begin van blok (if, else, for, while) op hetzelfde inspringingsniveau, dus het is net zo gemakkelijk te bepalen waar het begin van het blok is.
Ik zie geen reden om een hele regel te verspillen alleen voor een haakje als de voorgaande for / while / if-constructie al visueel het begin van een blok aangeeft.
Dat gezegd hebbende, ben ik van mening dat de sluitende haak op een eigen regel moet staan, omdat we iets nodig hebben om het einde van een blok en de inspringingsstructuur op een zichtbare manier aan te geven.
Reacties
- Nee … Ik ' m zeg waarom de hoeveelheid code die kan op uw scherm passen door iets te doen dat ' niet aan de code ' s duidelijkheid toevoegt?
- Wanneer ik was begonnen met coderen Ik vond elke brace op zijn eigen regel leuk, nu geef ik de voorkeur aan de eerste methode
- Er is een enorme hoeveelheid onderzoek die helemaal teruggaat tot het vroege Steam-tijdperk (Weinberg, " Psychologie van computerprogrammering "), waaruit blijkt dat het begrip van programmeur DRAMATISCH afneemt wanneer de hoeveelheid code die moet worden bekeken, meer is dan op één keer (dat wil zeggen, één schermpagina, één printerpagina). Dit fenomeen pleit STERKE voor het zien van verticale ruimte als een waardevolle bron, niet om onnodig te verspillen, en daarom heeft de eerste methode de voorkeur.
- LOL @ " verspillen van een GEHELE regel ". OMG! Niet dat!! = P
- @Julio Op de universiteit had ik een sterke voorkeur voor methode 1, en kon ' niet staan om methode 2 te lezen. Nadat ik ging werken bij een bedrijf dat C # gebruikt , waar de standaard methode 2 is, ben ik ' dat net zo goed gaan waarderen. Ik kan nu beide lezen of gebruiken; geen van beiden stoort mij. Mensen die sterk afkerig op de een of de ander reageren, reageren over het algemeen overdreven op iets waarmee ze niet vertrouwd zijn.
Antwoord
Ik geef de voorkeur
if (you.hasAnswer()) { you.postAnswer(); } else { you.doSomething(); }
boven
if (you.hasAnswer()) { you.postAnswer(); } else { you.doSomething(); }
omdat de regel you.postAnswer();
is op het eerste gezicht veel gemakkelijker te lezen en te vinden. Op de tweede manier wordt het vermengd met de regel erboven (you.hasAnswer()
) waardoor mijn ogen meer moeten focussen om het te kunnen lezen.
Reacties
- Dit is waar totdat je programma de hoogte van je scherm overschrijdt. 😉
- @ weberc2 Ik denk dat wanneer je programma de hoogte van het scherm overschrijdt, twee regels minder ' niet veel veranderen.
- 10 jaar geleden zou ik het eens zijn geweest over schermruimte. Tegenwoordig gebruik ik een scherm van 1920 * 1200. Het paste VEEL code, meer dan mijn hersenen tegelijk kunnen verwerken. Met de eerste methode kan ik me terugtrekken en de verschillende scope openen / sluiten zien zonder het te hoeven lezen.
- Ik kon nooit begrijpen waarom ik de voorkeur gaf aan deze methode, maar het is ' s voor precies dit.
- @Mageek Dit is laat, maar het ' bevat geen 2 regels, het is ' s 2 regels voor elke scope. Dat ' is O (N), niet O (1). Ik heb er geen ' zo sterk gevoel bij; het ' is belangrijker dat je een stijl kiest die lange parameterlijsten leesbaar maakt.
Antwoord
Ik geef de voorkeur aan de eerste methode. Bretels zijn totaal geen aparte lijn waard.
Het punt is dat beugels niet belangrijk zijn. Ze “zijn gewoon syntactische prullenbak , wat absoluut niet nodig is om te begrijpen waar code voor is, van het doel en de manier waarop het is geïmplementeerd. Ze zijn slechts een eerbetoon aan oude C-achtige talen waar visuele groepering van operators onmogelijk was vanwege de geringe beschikbare schermruimte.
Er zijn talen (Python, Haskell, Ruby) die helemaal oké zijn zonder accolades. Dit bevestigt alleen maar dat accolades prullenbak zijn en waar mogelijk geen regel voor zouden moeten verdienen:
if (you.hasAnswer()){ you.postAnswer(); }else{ you.doSomething(); }
Reacties
- Ik ' weet niets van Haskell of Ruby, maar Python is gevoelig voor witruimte, daarom is ' niet vereist accolades of andere scheidingstekens om blokken aan te duiden. De accolades zijn niet alleen syntactische ruis; ze dienen een echt doel.
- @Robert, In C moet je zowel witruimte als accolades doen. In Python zou je alleen witruimte moeten doen. Wat is beter?
- @Pavel, in C ' hoef je ' geen whitepace te doen.
- @KenBloom C-programmas zonder witruimte zijn onmogelijk te lezen. Dus je moet ze toch doen.
- Ongeacht of accolades een goed idee zijn of niet, het loutere bestaan van talen die ze niet ' gebruiken, ' t lijkt een argument voor of tegen hen te zijn. Het suggereert alleen dat het mogelijk is om een taal te hebben zonder deze talen, niet dat het een goed of slecht taalontwerp is.
Antwoord
Gebruik Python en omzeil het argument volledig.
Reacties
- +1
SyntaxError: not a chance
- Dit is gewoon geen optie voor de overgrote meerderheid van de projecten. Bovendien heeft inspringen-voor-groeperen het ' s aandeel in de problemen.
- @Bryan, ik realiseer me dat dit niet ' t erg praktisch. Ik dacht gewoon dat het een standpunt was dat daarbuiten moest komen, sterker dan alleen een opmerking. En ik ' ben nooit de problemen tegengekomen die worden veroorzaakt door inspringen die u suggereert, waarschijnlijk omdat ik ' geen tabbladen en spaties combineer.
- Gebruik Go en omzeil het argument volledig (plus statisch typen, snelheid en een compiler!) 🙂
- Druk dan een keer te vaak op de spatiebalk en kijk hoe de compiler / tolk lacht bij u. Dat is niet ' gebeurd in de meeste braced-talen.
Answer
De positie van accolades moet
metadata
configureerbaar zijn in de IDE door de programmeur. Op die manier zien die vervelende accolades in alle code, ongeacht de auteur, er hetzelfde uit.
Opmerkingen
- Helemaal mee eens. Het is de presentatie van ' en geen gegevens.
- Het probleem is dat als je iedereen zijn eigen dingen laat instellen, de dingen erg snel rommelig worden als de commits worden gedaan.
- @Andy: Dat ' precies het punt is, de IDE zal veranderen hoe ze eruit zien, maar alleen in de IDE! De daadwerkelijke bron wordt niet aangeraakt. Voor versiebeheer kun je hooks toevoegen die, wat de instelling voor accolades ook was, vertalen naar een algemene situatie, zodat iedereen de code op dezelfde manier controleert.
- @klaar Elke moderne IDE i ' ve gebruikt zal tabs veranderen in spaties en accolades verplaatsen naar hun eigen regel of het einde van de " opening " lijn; Ik ' weet niet zeker waarom je denkt dat de bron in deze gevallen niet ' is aangeraakt, en dat is de reden voor mijn opmerking. Het IS normaal gesproken veranderd door de IDEs, afhankelijk van de instellingen van de ontwikkelaar, wat betekent dat ik tijdens een commit ' veel veranderingen zal zien die slechts ruis zijn toen de accolades naar hun eigen regel werden verplaatst, waardoor de WERKELIJKE verandering die iemand heeft aangebracht wordt verborgen.
- @Andy: Isn ' t is er de mogelijkheid om haken te gebruiken die die verschillen met betrekking tot witruimte en accolades omzetten in een uniforme standaard uppon commit, om het geluidsprobleem dat je hebt beschreven te omzeilen? Hoe dan ook, een goed versiebeheersysteem zou kleine dingen zoals witruimte of andere onzinnige dingen moeten overstijgen.
Antwoord
Ik geef de voorkeur aan de eerste omdat het voor mij moeilijker is om de fout in dit voorbeeld te zien.
if (value > maximum); { dosomething(); }
dan in dit voorbeeld
if (value > maximum); { dosomething(); }
De ; {
ziet er gewoon meer verkeerd uit dan een regel die eindigt op ;
dus ik merk het eerder.
Opmerkingen
- Je maakt een goed argument, maar persoonlijk heeft dit alleen is me een keer overkomen in mijn 5 jaar programmeren. Ik kon ' niet achterhalen waarom het niet ' niet uitvoerde, plaatste het op SO en iemand wees me snel op de puntkomma. Maar elke keer dat het wordt gecomprimeerd om die ene regel minder te gebruiken, vind ik het moeilijker te lezen.
- De "; {" ziet eruit als een soort knipogend chagrijnig gezicht of misschien een persoon met een snor.
- +1 Geweldig voorbeeld in antwoord: zeer subtiele fout, gemakkelijk over het hoofd gezien. Dacht ook provocerend bij de lay-out die dit laat zien.
- Natuurlijk zal elke fatsoenlijke IDE de lege controlverklaring markeren en elke fatsoenlijke compiler zal een waarschuwing geven.
- @Dunk De enige fout in je argument (waar ik het helemaal mee eens ben) is dat zoveel mensen tegenwoordig geïnterpreteerde talen gebruiken (JavaScript, PHP, et al) dat veel " programmeurs " zou ' geen compiler kennen van een dubbele latte.
Antwoord
Het hangt ervan af.
Als ik codeer in Javascript of jQuery, gebruik ik de eerste vorm:
jQuery(function($) { if ($ instanceOf jQuery) { alert("$ is the jQuery object!"); } });
Maar als ik codeer in C #, gebruik ik de tweede vorm, omdat dat de canonieke manier is om het in C # te doen.
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; }
Merk op dat uw voorbeeld kan worden geschreven
if (you.hasAnswer()) you.postAnswer(); else you.doSomething();
in C #.
Opmerkingen
- Het kan op die manier in veel talen worden geschreven, omdat het een block-statement is is een statement. Toevoegen! 🙂
- Volgens de " Framework Design Guidelines " de " canonieke manier " is om de openingsaccolade op dezelfde regel te plaatsen (dwz de eerste vorm). Zeg gewoon ' …
- @Uwe: misschien. Maar Microsoft heeft de " uitgelijnde accolades " -benadering overgenomen voor al zijn MSDN C # -voorbeelden, en deze ' is ingebakken in Visual Studio, dus …
- @Uwe: That ' s Cwalina ' s boek en het ' is vreselijk genoemd omdat het veel meer is dan dat. De FDG op MSDN heeft daar niets over te zeggen. Ook vraag ik me af, waarom zouden de Framework Design richtlijnen iets zeggen over de C # codering praktijk?
- Je zou in feite accolades op dezelfde regel in Javascript moeten zetten. U kunt fouten veroorzaken als accolades op hun eigen lijn staan. Zie bijvoorbeeld encosia.com/…
Antwoord
Ik geef de voorkeur aan een kleine variant van 1)
if (you.hasAnswer()) { you.postAnswer(); } // note the break here else { you.doSomething(); }
Waarom?
-
Ik denk dat altijd accolades op hun eigen regel zetten de leesbaarheid vermindert. Ik kan maar een bepaalde hoeveelheid broncode op mijn scherm plaatsen. Bracket-stijl 2) maakt zware algoritmen met veel geneste lussen en conditionals pijnlijk lang.
-
Ik wil echter dat
else
start op een nieuwe regel omdatif
enelse
visueel bij elkaar horen. Als er een haakje voor deelse
staat, is het veel moeilijker om te zien wat bij wat hoort. -
3 ) diskwalificeert zichzelf. We weten allemaal welke slechte dingen er kunnen gebeuren als je de haakjes weglaat en het vergeet.
Opmerkingen
- Ik heb deze gezien waar ik werk. Het ' is interessant.
- Ik vind deze stijl ook leuker, omdat ik hierdoor commentaar boven de
else
regel indien nodig, en / of plaats een lege regel tussen het if-blok en het else-blok om het er minder vol uit te laten zien. Beugelstijl # 2 doet niets anders dan de acties te distantiëren van de omstandigheden. Met dat gezegd, is mijn favoriet absoluut python ' s geen haakjesstijl 🙂 - Als het maximaliseren van het aantal coderegels op het scherm belangrijk is, doe dan gewoon weg met geheel nieuwe regels. U ' zult in staat zijn om veel regels op één scherm te krijgen. Ik geef er de voorkeur aan om niets te hebben waardoor ik pauzeer en nadenk tijdens het lezen, dwz. mijn definitie van beter leesbaar. Met de beugel negeert mijn geest ze. Zonder de beugel moet mijn geest pauzeren en de controleblokken op één lijn brengen. Geen lange pauze, maar toch een pauze.
- Ja, als en anders bij elkaar horen, MAAR dat wel doen {en} en as} staat op een aparte regel, {moet op een aparte regel staan lijn, ook. " Ik kan maar een bepaalde hoeveelheid broncode op mijn scherm plaatsen " En dat ' Dit is precies waarom het zeggen van de 3) " zou zijn om zichzelf te diskwalificeren " is helemaal geen optie. Na een decennium van werken met 3) ben ik nooit vergeten haakjes toe te voegen bij het toevoegen van een nieuwe regel code, en ik ken ook niemand die dat ooit heeft gedaan. Als ik code moet aanpassen aan mensen, wie kan ' dan niet goed lezen, waar houdt het dan op? Het gebruik van bepaalde taalfuncties stoppen, omdat sommige codelezers ze misschien niet begrijpen?
Antwoord
Ik heb ergens gelezen dat de auteurs van een boek wilden dat hun code als volgt werd opgemaakt:
if (you.hasAnswer()) { you.postAnswer(); } else { you.doSomething(); }
Maar ruimtebeperkingen van hun uitgever betekenden dat ze dit moesten gebruiken:
if (you.hasAnswer()) { you.postAnswer(); } else { you.doSomething(); }
Nu weet ik niet of dat waar is (aangezien ik het niet meer kan vinden), maar de laatste stijl komt veel voor in boeken.
Op persoonlijk vlak geef ik de voorkeur aan de haakjes op een aparte regel als:
a) ze geven een nieuwe scope aan
b) het is gemakkelijker te herkennen wanneer je een mismatch hebt (hoewel dit minder een probleem is in een IDE die fouten markeert voor jou).
Opmerkingen
- … De tweede optie vergemakkelijkt ook je beide punten (waarbij alleen inspringen het doel van de beugel / indentation combo). 🙂
Antwoord
Ah, de One True Brace Style .
Het heeft alles wat nodig is voor een Holy W ay – zelfs een profeet (Richard “mijn weg of de snelweg” Stallman).
De man had het zo mis in zoveel dingen, maar GNU is perfect als het gaat om beugels.
[Update] Ik heb het licht gezien en aanbid nu Allman
Reacties
- Ik ' zie het punt van de GNU-stijl niet, anders dan het modelleert de lisp-code. Het lijkt veel werk voor weinig voordeel.
- Ik ken niemand die de GNU-stijl gebruikt. 1TBS helemaal.
- Je kunt ' niet slechter doen dan twee inspringingsniveaus per blok, behalve de lisp-stijl natuurlijk, dat spreekt voor zich.
- +1 voor de link over accolades. Het laat zien dat, wat je stijl ook is, veel geweldige mensen het niet met je eens zijn.
- @RobertHarvey Er is geen extra werk, als dat zo is, gebruik je ' de juiste tool om code te schrijven of om het goed te configureren. Het voordeel is veel beter leesbare code, je ziet elke fout in de haakjes erg snel en je kunt gemakkelijk alleen de code lezen terwijl je subblokken negeert.
Antwoord
Tweede voorbeeld, ik “ben erg goed in leesbaarheid. Ik kan” er niet tegen kijken of blokkeert op een andere manier = (
Reacties
- Onderzoek wijst uit dat het ' gemakkelijker te lezen compacte code is zodra een codebasis de hoogte van het scherm overschrijdt.
- @ weberc2 , zou je DOIs kunnen geven aan die research paper?
Answer
Eenvoudig antwoord: wat is gemakkelijker te debuggen?
// 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
In welk geval heeft u het probleem eerst gediagnosticeerd?
Ik geef niet veel om persoonlijke voorkeuren (er zijn veel andere stijlen, inclusief whitesmith en al.) en het kan me niet veel schelen … zolang het mijn vermogen om de code te lezen en debuggen het.
A s aan het “afvalruimte” -argument, ik geloof het niet: ik heb de neiging om toch lege regels toe te voegen tussen logische groepen om het programma duidelijker te maken …
Opmerkingen
- Ze zijn beide even gemakkelijk te debuggen, voornamelijk omdat het ' een kort codeblok is. De inspringing is consistent waardoor het gemakkelijk is om de daadwerkelijke codeblokken te visualiseren.
- @Htbaa: inderdaad 🙂 Dus waarom zou je je druk maken?
- @MatthieuM. Het eerste blok is logischer voor mij, omdat de nieuwe regels (in het tweede blok) tussen de functiehandtekening, het for-statement en het if-statement me doen geloven dat ze geen verband houden, maar het is duidelijk dat ze t. Lege regels zijn bedoeld om niet-gerelateerde stukjes code te scheiden; code die ' dicht bij andere regels code staat, betekent dat ze in feite verwant zijn. Dit is allemaal ' imo ' natuurlijk, maar ik vroeg me af wat je punt was. BEWERK: ook elke juiste IDE zal opmerken dat een accolade ontbreekt en u een paar fouten geven bij het interpreteren van uw code.
- Ik zou erop willen wijzen dat deze twee codesecties totaal verschillend zijn. Je zou compilerfouten hebben op verschillende punten in de code. De eerste zou een compileerfout hebben op " anders " en de laatste curly. De tweede zou alleen een compileerfout hebben op de laatste krul.
Answer
Niet dat iemand het zal merken, maar daarom horen accolades op de dezelfde regel als de conditionele (behalve voor zeer lange conditionals, maar dat is een rand case):
In C is dit een geldige constructie:
while(true); { char c; getchar(); //Wait for input }
Snel! Wat doet deze code? Als je antwoordde ” oneindige lus vraagt om invoer “, je hebt het mis! Het komt niet eens bij de invoer. Het wordt opgevangen op while(true)
. Let op die puntkomma aan het einde.Dit patroon komt eigenlijk vaker voor dan het lijkt alsof het zou moeten zijn; C vereist dat u uw variabelen aan het begin van een blok declareert, daarom is er een nieuwe gestart.
Een regel code is een gedachte. Bretels maken deel uit van de gedachte die de voorwaardelijke of lus bevat. Daarom horen ze thuis op de dezelfde regel.
Reacties
- Dit is verreweg het beste argument voor K & R-stijl die ik heb gezien, de rest is lachwekkend met vandaag ' s IDE-systemen met ondersteuning voor het opvouwen van codes. Dit is alleen van toepassing op C-stijltalen die
;
block ends ondersteunen. Dit is ook de reden waarom ik dit block-ending-systeem veracht dat IMHO verouderd is en de Go-taal het bewijst. Ik heb dit probleem vaak gezien, hoewel niet in dit scenario. Het gebeurt meestal waar ze iets aan de verklaring willen toevoegen en vergeten.
Antwoord
Ik vind de eerste methode. Het lijkt netter IMO, en het is compacter, wat ik leuk vind.
EDIT: Ah, een derde. Ik vind dat het leukst wanneer mogelijk, omdat het nog kleiner / netter is.
Antwoord
Je zou het kunnen schrijven:
you.hasAnswer() ? you.postAnswer() : you.doSomething();
Aan beantwoord de vraag; Ik gaf de voorkeur aan accolades op hun eigen regel, maar om te voorkomen dat ik moest nadenken over bugs door het automatisch invoegen van puntkommas in browsers, begon ik de Egyptische stijl te gebruiken voor javascript. En bij het coderen van java in eclipse had ik geen interesse in het bestrijden (of configureren) van de standaard brace-stijl, dus ging ik in dat geval ook met Egyptian. Nu “ben ik in orde met beide.
Opmerkingen
- om zo te worden gebruikt,
postAnswer()
endoSomething()
zou waarde voor ternaire operator moeten retourneren, wat vaak niet het geval is: ze kunnen heel goed leegte (geen waarde) retourneren. en ook (tenminste in c #) resultaat van?:
moet aan een bepaalde variabele worden toegewezen
Antwoord
Bijna alle antwoorden hier is een variatie op “Wat je ook doet, blijf bij een of twee”.
Dus ik dacht er even over na en moest toegeven dat ik het gewoon niet zo belangrijk vind . Kan iemand me eerlijk vertellen dat het volgende moeilijk te volgen is?
int foo(int a, Bar b) { int c = 0; while(a != c) { if(b.value[a] == c) { c = CONST_A; } c++; } return c; }
Ik weet het niet zeker over iemand anders … maar ik heb absoluut geen mentale problemen heen en weer schakelen tussen stijlen. Het kostte me even tijd om erachter te komen wat de code deed, maar dat is het resultaat van het willekeurig typen van een C-achtige syntaxis. 🙂
Naar mijn niet zo bescheiden mening zijn accolades openen bijna volledig irrelevant voor de leesbaarheid van de code. Er zijn hierboven een paar hoekgevallen waar de ene of de andere stijl een verschil maakt, maar voor het grootste deel ruimt oordeelkundig gebruik van lege regels dat op.
FWIW, onze coderingsstijlen op het werk gebruiken een beetje meer gestructureerde vorm 1 en een aangepaste vorm 3. (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
Ik ben benieuwd of degenen die sterk de voorkeur geven aan vorm 2 deze versie van formulier 1 zouden vinden beter, alleen omdat de lege regel een sterkere visuele scheiding geeft.
Opmerkingen
- Zoals je voorbeeld laat zien, is inspringen zoveel belangrijker dan accolades voor leesbare code. Sommige talen maken zelfs inspringen de enige manier om uitspraken te nesten!
- Ok, ik vind je inconsistent voorbeeld echt moeilijk te lezen. Niet ECHT moeilijk, maar moeilijker dan wanneer het was consistent.
- Ik ben het met Almo eens. Het is geen geval van " is het echt moeilijk " . Het is een geval van " het is beslist moeilijker ", ook al is het niet moeilijk. Dus waarom zou je het moeilijker maken? In de " speelgoed " voorbeelden die mensen geven, is er natuurlijk weinig verschil. In mijn ervaring, wanneer ik vervelende code van iemand anders erf en zij methode 1 gebruikten, wordt het vrij vaak nodig om door te gaan en deze in methode 2 te veranderen om de logica te kunnen volgen. Vanwege het feit dat het vaak nodig wordt; het beantwoordt automatisch de vraag welke methode beter en gemakkelijker te begrijpen is.
- @Dunk: ik kan geen code doorgronden die merkbaar verbeterd zou worden door dergelijke irrelevante details om te wisselen.
- @jkerian -Blijkbaar heb je ' t veel code geërfd van anderen die het project of bedrijf al lang hebben verlaten. Ik kan ' niet doorgronden dat niemand met enige jaren ervaring in die situatie zou komen. Maar nogmaals, de werksituatie van iedereen ' is anders. En als je " formele " codebeoordelingen moet doen, maakt opmaak nogal een verschil. Het natuurlijk kunnen lezen van de code is erg belangrijk.Natuurlijk kan ik pauzeren en denken om beugels te matchen, maar dat vertraagt het proces. De ene manier vereist geen pauze, de andere wel. Dat ' is waarom ik niet ' begrijp waarom een andere keuze zou kunnen worden aanbevolen.
Antwoord
Het verbaast me dat dit nog niet naar voren is gebracht. Ik geef de voorkeur aan de tweede benadering, omdat je hierdoor het blok gemakkelijker kunt selecteren.
Wanneer de accolades beginnen en eindigen op dezelfde kolom en op hun eigen regel, kunt u selecteren vanuit de marge of met de cursor op kolom 0. Dit komt over het algemeen neer op een genereuzer gebied met muisselectie of minder toetsaanslagen met toetsenbordselectie.
Ik werkte oorspronkelijk met beugels op dezelfde lijn als de conditionele, maar toen ik overstapte, merkte ik dat het de snelheid waarmee ik werkte, versnelde. Het is natuurlijk niet dag en nacht, maar het is iets dat je enigszins vertraagt bij het werken met beugels naast je conditionele middelen.
Opmerkingen
- Oldtimers zoals ik gebruiken drie toetsaanslagen om het blok te selecteren, ongeacht waar de verdomde accolades zijn.
Antwoord
Persoonlijk vind ik de tweede manier leuk.
De manier waarop ik ga demonstreren is echter naar mijn mening het beste omdat het de grootste werkzekerheid oplevert! Een medestudent van mijn universiteit vroeg me om hulp bij zijn huiswerk en zo zag zijn code eruit. Het hele programma zag eruit als een enkel blok. Het interessante is dat 95% van de bugs in het programma dat hij maakte, afkomstig was van niet-overeenkomende beugels. De andere 5% waren duidelijk zodra de accolades waren gekoppeld.
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);
Reacties
- Slecht, slecht , Ik bedoel een vreselijk, vreselijk voorbeeld. Het probleem zijn niet de beugels! Het ' is de gekke inspringing!
- @Martinho Fernandes Ik dacht dat het plaatsen van accolades en inspringingen samengaan …
- niet noodzakelijk. .. doe de juiste inspringing op het bovenstaande en wissel dan willekeurig tussen accolades, je ' zult merken dat het ' begrijpelijk is.
- In feite motiveerde het nadenken over dit mijn eigen antwoord op deze vraag.
- " 95% van de bugs in het programma dat hij maakte kwam van niet-overeenkomende accolades " – alleen in geïnterpreteerde talen, niet gecompileerd.
Antwoord
Mijn persoonlijke voorkeur gaat uit naar de eerste methode, waarschijnlijk omdat dit de manier is waarop ik PHP voor het eerst leerde.
Voor enkellijns if
statements, Ik gebruik
if (you.hasAnswer()) you.postAnswer();
Als het niet you.postAnswer();
is maar iets een veel langer, zoals you.postAnswer(this.AnswerId, this.AnswerText, this.AnswerType);
Ik zal waarschijnlijk terugkeren naar de fi eerste type:
if (you.hasAnswer) { you.postAnswer(this.AnswerId, this.AnswerText, this.AnswerType); }
Ik zal nooit een regeleinde gebruiken, en ik “zal deze methode nooit gebruiken als er ook een statement.
if (you.hasAnswer()) you.postAnswer(); else you.doSomething()
is een theoretische mogelijkheid, maar niet een die ik ooit zou gebruiken. Dit zou moeten worden omgezet in
if (you.hasAnswer()) { you.postAnswer(); } else { you.doSomething(); }
Antwoord
Ze zouden niet moeten; eerste methode voor mij.
Als ik naar de tweede kijk, vanwege de ongebruikte lijnen (die alleen een beugel hebben, behalve de allerlaatste sluitende beugel), voelt het alsof het de continuïteit van de code. Ik kan het “niet zo snel lezen omdat ik speciale aandacht moet besteden aan lege regels die meestal een scheiding in codedoel of iets dergelijks betekenen, maar in geen geval” deze regel behoort tot een accolade “(die alleen de betekenis herhaalt van inspringing).
Hoe dan ook, net als wanneer u tekst schrijft … een inspringing toevoegen aan het begin van een alinea is overbodig als er een lege regel voor staat (dubbelteken bij alineawijziging), het is niet nodig om regels te verspillen voor accolades als we correct inspringen.
Plus, zoals eerder vermeld, staat het toe om meer code op het scherm te passen, wat anders een beetje contraproductief is.
Answer
Het hangt af van het platform / de taal / conventies
In Java:
void someMethod() { if (you.hasAnswer()) { you.postAnswer(); } else { you.doSomething(); } }
In C #
void someMethod() { if (you.hasAnswer()) { you.postAnswer(); } else { you.doSomething(); } }
In C:
void someMethod() { if (you_hasAnswer()) { you.postAnswer(); } else { you_doSomething(); } }
Ik haat het als Java-jongens hun stijl gebruiken in C # -code en vice versa.
Reacties
- De C-stijl al manieren irriteerden me. Wees consistent!
Antwoord
Alles wat ik kan zeggen is dat als je een fan bent van methode # 3 , je gaat worden vervolgd door elke IDE-code-formatter op aarde.
Answer
Ik gebruik de eerste methode simpelweg omdat het is compacter en laat meer code op het scherm toe. Ik heb zelf nooit een probleem gehad met het koppelen van accolades (ik schrijf ze altijd op, samen met de if
-instructie voordat ik de voorwaarde toevoeg , en in de meeste omgevingen kun je naar de bijpassende accolade springen).
Als je wel beugels visueel moest koppelen, dan zou ik de tweede methode verkiezen. Hierdoor is er echter minder code tegelijk mogelijk, waardoor u meer moet scrollen. En dat heeft voor mij in ieder geval een grotere impact op het lezen van code dan het hebben van netjes uitgelijnde accolades. Ik haat scrollen. Aan de andere kant, als u over een enkele if
-instructie moet scrollen, is deze waarschijnlijk te groot en moet deze worden geherstructureerd.
Maar; het allerbelangrijkste is consistentie. Gebruik het een of het ander – nooit beide!
Answer
Toen ik voor het eerst programmeren op 12-jarige leeftijd leerde ik de beugel om de volgende regel omdat de programmeertutorials van Microsoft zo zijn. Ik heb die keer ook ingesprongen met TABS met 4 spaties.
Na een paar jaar leerde ik Java en JavaScript, en zag ik meer code met accolades op dezelfde regel, dus ik veranderde. Ik begon ook te laten inspringen met 2-spaties SPACES.
Reacties
- +1, -1. Waarom zou u NIET inspringen met tabs, aangezien elke editor de tablengte kan aanpassen aan uw willekeurige lengte? Anders leidt u velen van ons die van echte inspringingen op 8 houden om uw code te vervloeken.
Antwoord
Er is een vierde optie die de accolades uitgelijnd houdt, maar geen ruimte verspilt:
if (you.hasAnswer()) { you.postAnswer(); i.readAnswer(); } else { you.doSomething(); }
Het enige probleem is dat de meeste IDEs autoformatters hierin stikken.
Reacties
- … net als de meeste programmeurs die zich hierin zouden verslikken.
- Dat lijkt verschrikkelijk. Denk aan de extra moeite die u moet doen als u een regel bovenaan wilt invoegen, of de bovenste regel wilt verwijderen. U kunt ' niet gewoon de regel verwijderen en verder gaan, u moet onthouden om de accolade opnieuw in te voegen.
- lol dit is geweldig! 🙂 beter dan de eerste stijl!
- Blijkbaar heeft het zelfs een naam. The Horstman Syyle wordt genoemd in wikipedia . Ik ' heb gewerkt met een codebase zoals dit is ' echt niet slecht gebruiken.
Answer
Het hangt allemaal van jou af, zolang je niet aan een project werkt waar sommige coderingsbeperkingen of sommige standaarden zijn ingesteld door de projectmanager die alle programmeurs die aan dat project werken moeten volgen tijdens het coderen.
Persoonlijk zou ik de eerste methode verkiezen.
Ook heb ik niet begrepen wat je wilt laten zien met de derde methode?
Is dat niet een verkeerde manier? Beschouw een situatie bijvoorbeeld als ..
if (you.hasAnswer()) you.postAnswer(); else you.doSomething();
Wat moet er gebeuren als iemand nog meer uitspraken wil toevoegen in de if block?
In dat geval, als je de 3e methode gebruikt, zal de compiler de syntaxisfout genereren.
if (you.hasAnswer()) you.postAnswer1(); you.postAnswer2(); else you.doSomething();
Reacties
- Het zou nog erger zijn als iemand langs zou komen en dat deed: if (you.hasAnswer ()) you.postAnswer (); anders you.doSomething (); you.doSomethingElse (); – het ' is een recept voor subtiele bugs waar het oog gemakkelijk overheen kan glippen en de compiler won ' ook niet
- @FinnNk: Precies!
- Als iemand nog een statement wil toevoegen, kan hij of zij zelf de accolades plaatsen. Elke programmeur die zijn zout waard is, zou dat echt moeten kunnen uitzoeken.
- Ik wilde zeggen dat zijn derde methode verkeerd is.
- @Robert Harvey, ik ' heb gezien dat zeer ervaren codeerders het toevoegen van accolades missen bij het aanpassen van bestaande code. Ik denk dat het probleem is dat inspringen een veel sterkere aanwijzing is voor de betekenis dan accolades (vooral omdat er meerdere stijlen accolades zijn), dus het ' is vrij gemakkelijk om de ontbrekende accolade over het hoofd te zien als de inspringen ziet eruit zoals u verwacht.
Geef een reactie