Share
Code ruikt en hun refactorings kan heel ontmoedigend en intimiderend zijn voor beginners. Dus in deze serie heb ik geprobeerd ze gemakkelijk te begrijpen te maken, zowel voor enigszins ervaren Ruby-ontwikkelaars als voor starters.
Dit laatste artikel noemt nog een paar geuren waar je op moet letten en vat samen wat deze kleine serie wilde bereiken. Een laatste groet, als je wilt ...
Het laatste artikel in deze serie is zoiets als een bonusronde. Ik wilde je nog een paar andere geuren voorstellen die snel en zonder veel gedoe kunnen worden aangepakt. Een voor de weg, om zo te zeggen. Ik denk dat met de kennis die je hebt verzameld uit de vorige artikelen, de meeste van hen zelfs geen codevoorbeelden nodig hebben om je hoofd rond te winden.
Wanneer je een boek over refactoring opent, zul je gemakkelijk meer geuren vinden dan we hebben besproken. Echter, met deze grote degenen onder uw riem, bent u goed voorbereid om met een van hen af te rekenen.
Royaal toegepaste opmerkingen zijn zelden een goed idee - waarschijnlijk nooit. Waarom niet? Omdat het kan suggereren dat je ontwerp niet voor zichzelf spreekt. Dat betekent dat uw code waarschijnlijk zo ingewikkeld is om te begrijpen dat er letterlijke uitleg voor nodig is.
Allereerst, wie wil er een hoop tekst doorlopen in je code - of erger, door code die moeilijk te begrijpen is. Jackpot als beide een veel voorkomend verschijnsel zijn. Dat is gewoon een slechte vorm en niet erg attent van mensen die achter je aan komen - geen aanstoot, masochisten, je toekomstige zelf martelen alles wat je wilt.
Je wilt code schrijven die op zichzelf al expressief genoeg is. Maak klassen en methoden die voor zichzelf spreken. In het beste scenario vertellen ze een verhaal dat gemakkelijk te volgen is. Dat is waarschijnlijk een van de redenen conventies over configuraties werd zo invloedrijk. Het wiel opnieuw uitvinden is in sommige gevallen een goede gewoonte om je begrip aan te scherpen en nieuwe gebieden te verkennen, maar in snelle ontwikkelingsomgevingen zoeken je collega's naar duidelijkheid en snelle navigatie - niet alleen binnen je bestanden maar ook binnen de mentale kaart die je maakt in uw code.
Ik wil niet afdalen in een heel nieuw onderwerp, maar de naamgeving speelt daarin een grote rol. En overmatig commentaar binnen je code is enigszins in tegenspraak met goede benamingspraktijken en conventies. Begrijp me niet verkeerd, het is goed om opmerkingen toe te voegen - blijf gewoon op het pad dat je code 'verlicht' in plaats van er af te leiden. Opmerkingen mogen zeker geen instructies zijn voor slimme code die je meestal kunt ontcijferen omdat je wilde pronken. Als je je methoden simpel houdt - zoals je zou moeten - en alles met aandacht benoemt, dan heb je weinig behoefte om hele romans te schrijven tussen je code.
Blijf uit de buurt van het volgende:
Het is ook handig om delen van methoden via te splitsen extract methode en dit deel van een methode een naam geven die ons vertelt over zijn verantwoordelijkheid - in plaats van dat alle details een hoog begrip van wat er gaande is in het lichaam van de methode overbodig maken.
def create_new_agent ... end ... # maak nieuw agentbezoek root_path click_on 'Create Agent' fill_in 'Agent Name', met: 'Jinx' fill_in 'Email', met: '[email protected]' fill_in 'Password', met: 'secretphrase 'click_button' Verzenden '...
Wat is gemakkelijker te lezen? A geen brainer natuurlijk! Gebruik de gratis kilometerstand die u krijgt door dingen op de juiste manier te benoemen via geëxtraheerde methoden. Het maakt uw code zo veel slimmer en gemakkelijker te verteren-plus de voordelen van refactoring op één plaats als het opnieuw wordt gebruikt, natuurlijk. Ik wed dat dit je opmerkingen aanzienlijk zal helpen verminderen.
Dit is een simpele. Gebruik geen callbacks die geen verband houden met persistentielogica! Uw objecten hebben een permanente levenscyclus die objecten maakt, opslaat en verwijdert, om zo te zeggen, en u wilt die logica niet "vervuilen" met ander gedrag zoals de bedrijfslogica van uw klassen.
Houd het eenvoudig, weet je nog? Typische voorbeelden van wat te vermijden zijn het verzenden van e-mails, het verwerken van betalingen enzo. Waarom? Omdat het debuggen en herschrijven van uw code zo eenvoudig mogelijk moet zijn, en rommelige callbacks hebben de reputatie zich met deze plannen te bemoeien. Callbacks maken het een beetje te gemakkelijk om het water te modderigen en om meerdere keren in de voet te schieten.
Een ander probleempunt over callbacks is dat ze de implementatie van bedrijfslogica kunnen verbergen in methoden zoals #opslaan of #create. Dus wees niet lui en misbruik ze alleen maar omdat het handig lijkt!
De grootste zorg is uiteraard het koppelen van zorgen. Waarom de maakmethode van toestaan SpectreAgent, bijvoorbeeld omgaan met de levering van een #mission_assignment of zoiets? Zoals zo vaak, alleen omdat we het gemakkelijk kunnen doen, betekent niet dat we het zouden moeten doen. Het is een gegarandeerde beet in de ezel die wacht om te gebeuren. De oplossing is eigenlijk vrij eenvoudig. Als het gedrag van een callback niets te maken heeft met persistentie, maakt u gewoon een andere methode hiervoor en bent u klaar.
Slechte naamgevingskeuzes hebben ernstige gevolgen. In feite verspilt u de tijd van anderen, of beter nog die van uzelf, als u dat stukje code in de toekomst opnieuw moet bezoeken. De code die je schrijft is een reeks instructies die door jou en andere mensen moet worden gelezen, dus een puur logische, super prozaïsche, overdreven slimme of slechter, een eenvoudige luie benadering van het benoemen van dingen is een van de ergste dingen die je achter kunt laten. Probeer uw code beter te begrijpen door betere namen te geven.
Duidelijkheid overtreft valse slimheid of onnodige beknoptheid elke dag van de week! Werk hard aan naamgevingsmethoden, variabelen en klassen die het gemakkelijk maken om een soort van thread te volgen.
Ik wil niet zo ver gaan om te zeggen dat je moet proberen om een verhaal te vertellen, maar als je kunt, ga ervoor! Machines zijn niet degenen die jouw code moeten "lezen" - hij wordt natuurlijk door hen bestuurd. Misschien is dat een reden waarom de term 'Software Writer' de laatste tijd op mij is gegroeid. Ik zeg niet dat het technische aspect moet worden verminderd, maar schrijven van software is meer dan het schrijven van zielloze instructies voor machines - in ieder geval software die elegant is en plezier schept om mee te werken.
Wees niet bang als dit een stuk moeilijker blijkt te zijn dan je dacht. Naamgeving is notoir moeilijk!
Mixins zijn een geur? Laten we zeggen dat ze stinken. Meerdere overerving via Mixins kan nuttig zijn, maar er zijn een aantal dingen die ze minder bruikbaar maken dan je misschien had gedacht toen je begon met OOP:
Ik stel voor dat je een beetje leest over "Compositie over overname". De kern hiervan is dat u meer moet vertrouwen op hergebruik van uw eigen, afzonderlijk samengestelde klassen dan op overerving of subclassering. Mixins zijn een vorm van overerving die goed kan worden gebruikt, maar ook iets waar je een beetje achterdochtig voor moet zijn.
Pas op voor herhaaldelijk doorgeven van dezelfde meerdere argumenten in uw methoden. Dat suggereert vaak dat ze een relatie hebben die kan worden geëxtraheerd in een klasse apart - wat op zijn beurt vaak drastisch vereenvoudigt dat deze methoden worden gevoed met gegevens door de argumenten te verkleinen. Of het de moeite waard is om een nieuwe afhankelijkheid te introduceren, is het ding dat je moet wegen.
Deze geur is een andere vorm van subtiele duplicatie die we beter aankunnen. Een goed voorbeeld is het doorgeven van een lange lijst met argumenten waaruit een adres en creditcardinformatie bestaat. Waarom zou u dit niet in een bestaande klasse verpakken of eerst een nieuwe klasse uitpakken en de adres- en creditcardobjecten doorgeven in plaats daarvan? Een andere manier om erover na te denken, is een bereikobject in plaats van een begin en een einde. Als u instantievariabelen hebt die vallen voor die geur, dan is het extraheren van een klasse het overwegen waard. In andere gevallen, a parameter object kan dezelfde kwaliteit van abstractie bieden.
U weet dat u een kleine overwinning hebt behaald als uw systeem gemakkelijker te begrijpen is en u een nieuwe conceptachtige creditcard hebt gevonden, die u in een object kunt inkapselen.
Gefeliciteerd! Je hebt je OOP-vaardigheden aanzienlijk verhoogd! Boss level status nadert. Nee, serieus, geweldig werk als dit hele onderwerp nogal nieuw voor je was!
Als laatste aanbeveling wil ik dat je één ding weghaalt. Vergeet niet dat er geen recept is dat altijd zal werken. U moet elk probleem anders wegen en vaak verschillende technieken combineren om aan uw behoeften te voldoen. Ook voor de rest van je carrière is dit waarschijnlijk iets waar je nooit mee zult worstelen, maar ik denk dat het een goede strijd is, een creatieve en uitdagende strijd..
Dit is een beetje gissen, maar ik denk dat als je de meeste onderwerpen begrijpt die we hebben behandeld, je goed op weg bent om code te schrijven die andere ontwikkelaars leuk vinden om te ontdekken. Bedankt voor je tijd om deze kleine serie te lezen, en veel succes om een gelukkige hacker te worden!
Accentsconagua