Share
Två gånger i månaden besöker vi några av våra läsares favoritinlägg från hela Nettuts historia+.
Kodläsbarhet är ett universellt ämne i datorprogrammeringen. Det är en av de första sakerna vi lär oss som utvecklare. I den här artikeln beskrivs de femton viktigaste bästa metoderna när du skriver läsbar kod.
IDEs (Integrated Development Environment) har kommit långt under de senaste åren. Detta gjorde att din kod var mer användbar än någonsin. Efter vissa standarder i dina kommentarer tillåter IDEs och andra verktyg att använda dem på olika sätt.
Tänk på detta exempel:
De kommentarer jag lagt till i funktionsdefinitionen kan förhandsgranskas när jag använder den funktionen, även från andra filer.
Här är ett annat exempel där jag ringer en funktion från ett tredje part bibliotek:
I dessa speciella exempel är typen av kommenterande (eller dokumentation) som används baseras på PHPDoc och IDE är Aptana.
Jag antar att du redan vet att du ska ange din kod. Det är dock också värt att notera att det är en bra idé att hålla din indragstil stil konsekvent.
Det finns mer än ett sätt att koppla in kod.
funktion foo () om ($ kanske) do_it_now (); igen(); annat abort_mission (); slutföra ();
funktion foo () om ($ kanske) do_it_now (); igen(); annat abort_mission (); slutföra ();
funktion foo () om ($ kanske) do_it_now (); igen(); annat abort_mission (); slutföra ();
Jag brukade koda i stil # 2 men senast bytte till # 1. Men det är bara en fråga om preferens. Det finns ingen "bästa" stil som alla borde följa. Egentligen är den bästa stilen en konsekvent stil. Om du ingår i ett lag eller om du bidrar till ett projekt, bör du följa den befintliga stilen som används i det projektet.
Intoneringsstilarna är inte alltid helt olika från varandra. Ibland blandar de olika regler. Till exempel, i PEAR-kodningsstandarder, öppningsfästet "" går i samma linje som kontrollstrukturer, men de går till nästa rad efter funktionsdefinitioner.
PEAR-stil:
funktion foo () // placerad på nästa rad om ($ kanske) // placeras på samma rad do_it_now (); igen(); annat abort_mission (); slutföra ();
Observera också att de använder fyra mellanslag istället för flikar för indragningar.
Här är en Wikipedia-artikel med exempel på olika inslagstyper.
Kommentera din kod är fantastisk; Det kan dock överdrivas eller bara vara överflödigt. Ta detta exempel:
// få landskoden $ country_code = get_country_code ($ _ SERVER ['REMOTE_ADDR']); // om landskoden är USA om ($ country_code == 'US') // visa formulärinsignalen för statens echo form_input_state ();
När texten är så uppenbar är det verkligen inte produktivt att upprepa det inom kommentarer.
Om du måste kommentera den koden kan du helt enkelt kombinera den med en enda rad istället:
// visningsstatus för amerikanska användare $ country_code = get_country_code ($ _ SERVER ['REMOTE_ADDR']); om ($ country_code == 'US') echo form_input_state ();
Ofta kräver inte vissa uppgifter några rader av kod. Det är en bra idé att behålla dessa uppgifter inom separata block av kod, med vissa mellanslag mellan dem.
Här är ett förenklat exempel:
Accentsconagua
// få lista över forum $ forums = array (); $ r = mysql_query ("VÄLJ ID, namn, beskrivning FRÅN forum"); medan ($ d = mysql_fetch_assoc ($ r)) $ forums [] = $ d; // ladda mallarna load_template ('header'); load_template (forum_list ", $ forum); load_template ( 'sidfot'); Lägga till en kommentar i början av varje kodblock betonar också den visuella separationen.
PHP själv är ibland skyldig att inte följa konsekventa namngivningssystem:
Först och främst bör namnen ha ordgränser. Det finns två populära alternativ:
Att ha olika alternativ skapar en situation som liknar indragstilarna, som jag nämnde tidigare. Om ett befintligt projekt följer en viss konvention, borde du gå med det. Dessutom brukar vissa språkplattformar använda ett visst namngivningssystem. Till exempel, i Java, använder de flesta kodnamn kamelCase, medan i PHP understryker majoriteten av användningarna.
Dessa kan också blandas. Vissa utvecklare föredrar att använda understreck för procedurfunktioner och klassnamn, men använd camelCase för klassmetodnamn:
klass Foo_Bar public function someDummyMethod () funktion procedural_function_name ()
Så igen finns det ingen uppenbar "bäst" stil. Bara att vara konsekvent.
DRY står för Repetera inte dig själv. Även känd som DIE: Duplication är ond.
Principen säger:
"Varje del av kunskapen måste ha en enda, entydig, auktoritativ representation inom ett system."
Syftet med de flesta applikationer (eller datorer i allmänhet) är att automatisera upprepade uppgifter. Denna princip bör bibehållas i all kod, även webbapplikationer. Samma kod bör inte upprepas om och om igen.
Till exempel består de flesta webbapplikationer av många sidor. Det är högst troligt att dessa sidor kommer att innehålla vanliga element. Headers och footers är vanligtvis bäst kandidater för detta. Det är inte en bra idé att behålla kopia klistra in dessa rubriker och sidfot på varje sida. Här är Jeffrey Way förklarar hur man skapar mallar i CodeIgniter.
$ This-> last> vy ( 'includes / header'); $ This-> last> vy ($ main_content); $ This-> last> vy ( 'includes / sidfot');
För många nivåer av häckning kan göra koden svårare att läsa och följa.
funktion do_stuff () //? om is_writable ($ folder)) if ($ fp = fopen ($ file_path, 'w')) if ($ stuff = get_some_stuff ()) if (fwrite ($ fp, $ stuff)) //? annars return false; annars return false; annars return false; annars return false;
För läsbarhetens skull är det vanligtvis möjligt att göra ändringar i din kod för att minska nestningsnivån:
funktion do_stuff () //? om (! is_writable ($ mapp)) return false; om (! $ fp = fopen ($ file_path, 'w')) return false; om (! $ stuff = get_some_stuff ()) return false; om (skriva ($ fp, $ stuff)) //? annars return false;
Våra ögon är bekvämare när vi läser långa och smala kolumner av text. Det är just därför orsaken till att tidningsartiklar ser ut så här:
Det är en bra övning att undvika att skriva horisontellt långa rader av kod.
// bad $ my_email-> set_from ('[email protected] ') -> add_to ('[email protected]') -> set_subject ('Methods Chained') -> set_body ('Några långa meddelanden') -> skicka(); // good $ my_email -> set_from ('[email protected] ') -> add_to ('[email protected]') -> set_subject ('Methods Chained') -> set_body ('Några långa meddelanden') -> skicka(); // bad $ query = "VÄLJ ID, användarnamn, förnamn, efternamn, status FRÅN användare LEFT JOIN user_posts ANVÄNDNING (users.id, user_posts.user_id) VAR post_id = '123'"; // good $ query = "VÄLJ ID, användarnamn, förnamn, efternamn, status FRÅN användare LEFT JOIN user_posts ANVÄNDNING (users.id, user_posts.user_id) VAR post_id = '123'"; Om någon också vill läsa koden från ett terminalfönster, som Vim-användare, är det också en bra idé att begränsa linjelängden till cirka 80 tecken.
Tekniskt kan du skriva en hel applikationskod inom en enda fil. Men det skulle visa sig vara en mardröm att läsa och underhålla.
Under mina första programmeringsprojekt visste jag om tanken på att skapa "inkludera filer". Men jag var ännu inte ens organiserad på distans. Jag skapade en "inc" -mapp med två filer i den: db.php och functions.php. När applikationerna växte blev funktionsfilen också stor och oövervinnlig.
En av de bästa metoderna är att antingen använda en ram eller efterlikna deras mappstruktur. Så här ser CodeIgniter ut:
Normalt bör variablerna vara beskrivande och innehålla ett eller flera ord. Men detta gäller inte nödvändigtvis för temporära variabler. De kan vara lika korta som en enda karaktär.
Det är en bra metod att använda konsekventa namn för dina temporära variabler som har samma typ av roll. Här är några exempel som jag brukar använda i min kod:
// $ i för slingräknare för ($ i = 0; $ i < 100; $i++) // $j for the nested loop counters for ($j = 0; $j < 100; $j++) // $ret for return variables function foo() $ret['bar'] = get_bar(); $ret['stuff'] = get_stuff(); return $ret; // $k and $v in foreach foreach ($some_array as $k => $ v) // $ q, $ r och $ d för mysql $ q = "SELECT * FROM table"; $ r = mysql_query ($ q); medan ($ d = mysql_fetch_assocr ($ r)) // $ fp för filpekare $ fp = fopen ('file.txt', 'w'); Databasinteraktion är en stor del av de flesta webbapplikationer. Om du skriver råa SQL-frågor är det en bra idé att hålla dem läsbara också.
Trots att SQL-specialord och funktionsnamn är okänsliga är det vanligt att kapitalisera dem för att skilja dem från ditt bord och kolumnnamn.
VÄLJ ID, användarnamn FROM användare; UPDATE användaren SET last_login = NU () Vart id = '123' VÄLJ ID, användarnamn FRÅN användare du VÄNSTER JOIN user_address ua ON (u.id = ua.user_id) VAR ua.state = 'NY' GRUPP AV u.id BESTÄLL BY us.username LIMIT 0,20
Detta är en annan princip som gäller för nästan alla programmeringsspråk i alla miljöer. I fråga om webbutveckling innebär "data" vanligtvis HTML-utmatning.
När PHP släpptes för första gången för många år sedan, sågs det främst som en mallmotor. Det var vanligt att ha stora HTML-filer med några rader av PHP-kod däremellan. Men sakerna har förändrats genom åren och webbplatser blev mer och mer dynamiska och funktionella. Koden är nu en stor del av webbapplikationer, och det är inte längre en bra övning att kombinera den med HTML.
Du kan antingen tillämpa principen för din ansökan själv, eller du kan använda ett tredjepartsverktyg (mallmotorer, ramverk eller CMS) och följa deras konventioner.
Populära PHP-ramar:
Populära Mall Motorer:
Populära Content Management Systems
Du kan välja att inte använda en snygg mallmotor, och istället gå med vanligt inline-PHP i dina mallfiler. Detta bryter inte nödvändigtvis "Separering av kod och data", så länge som inline-koden är direkt relaterad till utmatningen och kan läsas. I det här fallet bör du överväga att använda den alternativa syntaxen för kontrollstrukturer.
Här är ett exempel:
Hej, Användarnamn; ?>
|Mitt meddelande styrelse
titel; ?>
Forum som $ forum):?>id, $ forum-> titel)?> (Threads-> count (); ?> trådar)
beskrivning; ?>
Detta gör att du kan undvika massor av lockiga hängslen. Koden ser också ut och känns som hur HTML är strukturerad och indragad.
Objektorienterad programmering kan hjälpa dig att skapa välstrukturerad kod. Men det betyder inte att du måste överge procedurprogrammering helt. Att skapa en mix av båda stilar kan faktiskt vara bra.
Objekt ska användas för att representera data, vanligtvis bosatt i en databas.
klass användare public $ användarnamn; allmänhet $ first_name; offentlig $ last_name; offentlig $ email; allmän funktion __construct () //? allmän funktion skapa () //? allmän funktion spara () //? public function delete () //?
Procedurfunktioner kan användas för specifika uppgifter som kan utföras självständigt.
funktionen capitalize ($ string) $ ret = strtoupper ($ string [0]); $ ret. = strtolower (substr ($ sträng, 1)); returnera $ ret;
Open Source-projekt är byggda med input från många utvecklare. Dessa projekt måste behålla en hög nivå av kodläsbarhet så att laget kan arbeta så effektivt som möjligt. Därför är det en bra idé att bläddra igenom källkoden för dessa projekt för att observera vad dessa utvecklare gör.
När du "refactor" ändrar du koden utan att ändra dess funktionalitet. Du kan tänka på det som en "städa upp" för att förbättra läsbarheten och kvaliteten.
Detta inkluderar inte buggfixar eller tillägg av någon ny funktionalitet. Det kan hända att du har skrivit koden som du skrivit dagen innan, medan den fortfarande är fräsch i ditt huvud, så att den är mer läsbar och återanvändbar när du kanske kan titta på den två månader från nu. Som mottot säger: "Refactor tidigt, refactor ofta."
Du kan använda någon av de "bästa metoderna" för kodläsbarhet under refactoringprocessen.
Jag hoppas att du haft den här artikeln! Något som jag saknade? Låt mig veta via kommentarerna. Och om du vill förbättra kodningen finns det många skript och appar tillgängliga för att hjälpa dig på Envato Market. Se vad som är mest populärt den här veckan.
