עצות פֿאַר שרייבן וישאַלטבאַר קאָד
שרייבן קאוד איז נישט נאר וועגן באקומען א פראגראם צו "לויפן". אין פראקטיק, א באדייטנדיקער טייל פון ווייכווארג אנטוויקלונג צייט ווערט פארבראכט צו לייענען, פארבעסערן און אנטוויקלען עקזיסטירנדיקן קאוד - צי אייער אייגענעם אדער עמעצן אנדערש'ס. דעריבער, די מעגלעכקייט צו שרייבן אויפהאלטבארן קאוד איז א קריטישע סקיל פאר יעדן פראגראמירער. אויפהאלטבארן קאוד פארקלענערט אויפהאלטונג קאסטן, פארשנעלערט אייגנשאפט צוגאבן, מינימיזירט באגס, און מאכט גרופע קאלאבאראציע פיל מער עפעקטיוו. דא זענען עטלעכע פראקטישע עצות פאר שרייבן ריינעם, קלארן און דויערהאפטיקן קאוד.
1. געבן פֿאָרטייל צו ליינעוודיקייט איבער "קלוגקייט"
קאָד וואָס איז צו "קלוג" איז אָפט שווער צו פֿאַרשטיין. למשל, שרייבן אַ זייער קורצע שורה קאָד קען אויסזען עלעגאַנט, אָבער עס קען זיין פֿאַרווירענדיק ווען מען לייענט עס איבער. קלייַבט אַ קלאָרע לייזונג, אפילו אויב עס איז אַ ביסל לענגער. לייענבאַרקייט איז אַן אינוועסטירונג: איר מעגט נאָר שרייבן דעם קאָד איין מאָל, אָבער איר וועט עס לייענען פיל מאָל.
למשל, אנשטאט איינצונעמען קייפל אפעראציעס אין איין אויסדרוק, טיילט זיי אפ אין טריט מיט באדייטנדיקע וועריאַבלע נעמען. דאס העלפט דעם לייענער פארשטיין די פּראָגראַם'ס כוונה אָן צו דאַרפֿן טרעפן.
2. ניצט קלאָרע און קאָנסיסטענטע נעמען
וואַריאַבלע, פֿונקציע, און קלאַס נעמען זענען די "ערשטע שורה פֿון דאָקומענטאַציע" פֿאַר אײַער קאָד. גוטע נעמען זאָלן באַשרײַבן זייער ראָלע אָדער צוועק, נישט נאָר דעם פֿאָרמאַט פֿון זייערע דאַטן. למשל, `userList` איז מער אינפֿאָרמאַטיוו ווי `ul`, און `calculateTotalPrice()` איז קלאָרער ווי `ctp()`.
אין צוגאב צו קלארקייט, זאל נעמען אויך זיין קאנסיסטענט. אויב איר ניצט camelCase פאר וועריאַבלען, האלט זיך דערביי איבער אייער פראיעקט. פאר קלאסן, ניצט PascalCase אויב דאס איז אייער בילכער שפראך קאנווענשאן. קאנסיסטענץ מאכט קאוד פילן איינהייטלעך און פארקלענערט גייסטישע לאסט ביים לייענען.
3. אָנווענדן דעם פּרינציפּ פון "איינציקע פֿאַראַנטוואָרטלעכקייט"
איינע פון די הויפּט סיבות פון שווער-צו-אויפהאלטן קאָד איז פונקציעס אדער קלאַסן וואָס טוען צו פיל זאכן. דער איינציקער פֿאַראַנטוואָרטלעכקייט פּרינציפּ פֿאָרשלאָגט אַז אַ קאָד איינהייט זאָל האָבן בלויז איין הויפּט פֿאַראַנטוואָרטלעכקייט. אַן צו לאַנגע פונקציע איז געוויינטלעך אַ צייכן אַז עס דאַרף ווערן צעבראָכן.
למשל, א "טשעקאַוט פּראָצעס" פונקציע וואָס סיימאַלטייניאַסלי וואַלידירט אַרייַנשרייַב, רעכנט פּרייזן, קאָנטאַקטירט אַ צאָלונג גייטוויי, און שיקט אימעילס וואָלט זיין שווער צו טעסטן און שווער צו ענדערן. דורך צעטיילן עס אין באַזונדערע פונקציעס (וואַלידאַציע, קאַלקולאַציע, צאָלונג, אָנזאָג), קענט איר מאַכן ענדערונגען צו איין טייל אָן צו ברעכן די אנדערע.
4. פֿאַרמײַדט דופּליקאַציע (DRY), אָבער איבערטרײַבט עס נישט.
טרוקן (Don't Repeat Yourself) איז א וויכטיגער פרינציפ: אויב איר קאפירט דעם זעלבן בלאק קאוד קייפל מאל, וועט א קליינע ענדערונג פארלאנגען אז איר זאלט אלעס רעדאקטירן. דאס איז פראנע צו מאכן טעותים. די לייזונג איז ארויסצונעמען די איבערגעחזרטע לאגיק אין א פונקציע אדער מאדול.
אבער, ס'איז וויכטיג צו געדענקען אז אויסמיידן איבעריגע דופליקאציע קען אויך שאטן די ליינעבארקייט. אויב צוויי שטיקלעך קאוד זעען אויס ענלעך אבער האבן אין פאקט אנדערע קאנטעקסטן, קען צווינגען "אבסטראקציע" מאכן דעם קאוד מער קאמפליצירט. געפינט א באלאנס: רעפאקטארירן ווען דופליקאציע איז באמת באדייטנדיק און האט דעם פאטענציאל זיך צו ענדערן צוזאמען.
5. שאַפֿן אַ אָרדנטלעכע פּראָיעקט סטרוקטור
א קלאָרע טעקע סטרוקטור ווירקט אויף גרינגקייט פון אויפהאלטונג. גרופּירט טעקעס לויט פֿונקציע אדער מאָדול, נישט נאָר לויט טעקע טיפּ, ספּעציעל פֿאַר גרויסע פּראָיעקטן. א גוטע סטרוקטור מאַכט עס גרינגער פֿאַר נײַע אָנפֿענגער צו פֿאַרשטיין די פּראָיעקט אַרכיטעקטור.
למשל, אנשטאט צו לייגן אלע אייערע UI קאמפאנענטן אין איין גרויסן טעקע, קענט איר זיי צעטיילן לויט אייגנשאפט: `auth/`, `profile/`, `checkout/`, און אזוי ווייטער. די צוגאנג העלפט אייער פראיעקט וואקסן ווען עס וואקסט.
6. באגרענעצן קאָמפּלעקסיטעט און מאַכן די לאָגיק פלוס גרינג צו נאָכפאָלגן.
קאָד פול מיט איינגענעסטטע "אויב-עלטער" סטעיטמענטס, פילע באדינגונגען, און ספּעציעלע אויסנעמען איז אָפט שווער צו אויפהאלטן. פּרוּווט צו פאַרפּשוטערן אייער לאָגיק. איר קענט נוצן טעכניקן ווי "פֿרי צוריקקער" צו רעדוצירן אייננעסטן, אדער אריבערפירן קאָמפּלעקסע לאָגיק אין קליינע פונקציעס וואָס קענען באַקומען אַ פּאַסיקן נאָמען.
אויב אַ פֿונקציע האָט צו פֿיל פּאַראַמעטערס, סיגנאַלירט עס אויך קאָמפּלעקסיטעט. באַטראַכט צו נוצן אַ קאָנפֿיגוראַציע אָביעקט (אָדער דאַטן סטרוקטור) צו בעסער אָרגאַניזירן פּאַראַמעטערס און מאַכן זיי גרינגער צו פֿאַרברייטערן.
7. שרייב קאמענטארן וואס זענען פונקטליך
קאמענטארן זענען נישט קיין ערזאץ פאר קלארן קאוד. אויב איר דארפט מסביר זיין "וואס דער קאוד טוט," דארף עס מסתמא געמאכט ווערן מער ליינעוודיק. אבער, קאמענטארן זענען נאך אלץ נוצלעך צו מסביר זיין "פארוואס" עפעס ווערט געטאן, ספעציעל אויב עס זענען דא דיזיין באשלוסן, סיסטעם באגרענעצונגען, אדער ספעציפישע ביזנעס סיבות.
ביישפילן פון גוטע באַמערקונגען זענען דערקלערן פארוואס א באַזונדערער אַלגעריטם ווערט גענוצט צוליב פאָרשטעלונג לימיטאַציעס, אדער פארוואס א וואַלידאַציע הערשן קוקט מאָדנע ווייל עס גייט נאך א רעגולאַציע. אויף דעם וועג וועלן אנדערע נישט "אויפרייניקן" דעם קאָד און צעברעכן וויכטיקע לאָגיק.
8. ניצט קאָד פֿאָרמאַטינג און סטיל גיידס
קאָנסיסטענט פֿאָרמאַטירן מאַכט קאָד אויסזען פּראָפֿעסיאָנעל און גרינג צו לייענען. ניצט אויטאָמאַטישע לינטערס און פֿאָרמאַטירער אויב פֿאַראַן (למשל, ESLint + Prettier פֿאַר דזשאַוואַסקריפּט, Black פֿאַר פּיטהאָן, אָדער gofmt פֿאַר Go). מיט די מכשירים, דאַרפֿן טימז נישט זאָרגן וועגן ספּייסינג און אינדענטאַציע, ווײַל אַלץ ווערט געהאַנדלט אויטאָמאַטיש.
סטיל גיידס העלפן אויך: צי צו ניצן איינציקע אדער טאָפּלטע קוואָטעס, ווי צו געבן נעמען צו טעקעס, ווען צו ברעכן לאַנגע שורות, און אַזוי ווייטער. קליינע סטאַנדאַרדן ווי די קענען מאַכן אַ גרויסן חילוק אויף לאַנגע טערמין.
9. שרייב טעסטן צו האַלטן בטחון ביים רעפאַקטאָרינג.
אויפהאלטבאַר קאָד איז נישט נאָר ריין, נאָר אויך זיכער צו ענדערן. אויטאָמאַטישע טעסץ (יוניט טעסץ, אינטעגראַציע טעסץ) גאַראַנטירן אַז אייערע ענדערונגען ברעכן נישט דעם איינגעשטעלטן נאַטור. אָן טעסץ, האָבן מענטשן אַ טענדענץ צו מורא האָבן צו פֿאַרבעסערן קאָד צוליב דעם ריזיקאָ פֿון נישט-דעטעקטירטע באַגז.
הייבט אן מיט די קריטישע סעקציעס: פרייז קאַלקולאַציע פונקציעס, אַראָפּרעכענונג כּללים, וואַלידאַציע, אָדער אָפט געביטן מאָדולן. מיט דער צייט וועט די טעסט קאַווערידזש וואַקסן און צושטעלן שטאַרקע שוץ קעגן רעגרעסיעס.
10. דורכפירן רעפאַקטאָרינג רעגולער און מעסטלעך
אויפהאלטונג איז אן אנגייענדע פראצעדור. רעפאקטארירן מיינט נישט "איבערשרייבן אלעס," נאר קליינע פארבעסערונגען וואס פארבעסערן די קוואליטעט פון קאוד אן ענדערן זיין אויפפירונג. פלאנירט א רעפאקטאר ווען איר רירט אן א סעקציע פון קאוד: אביסל אויפרייניגן, פאררעכטן נעמען, צוברעכן אן צו לאנגע פונקציע, אדער אראפנעמען טויטן קאוד.
קליינע, רעגולערע רעפאַקטאָרינגען זענען זיכערער ווי גרויסע, זעלטענע רעפאַקטאָרינגען. און שטענדיק זיכער מאַכן גענוג טעסטן, אָדער לפּחות קאָנטראָלירן, איידער און נאָך ענדערונגען.
11. דאָקומענטירן וויכטיקע באַשלוסן
אין צוגאב צו קאוד קאמענטארן, גוטע פראיעקטן האבן טיפיש קורצע דאקומענטאציע: ווי אזוי צו לויפן די אפליקאציע, ווי אזוי עס צו בויען, ווי אזוי צו קאנפיגורירן די סביבה, און א הויך-לעוועל ארכיטעקטורישע דערקלערונג. די דאקומענטאציע דארף נישט זיין ברייט, אבער עס זאל זיין גענוי און גרינג צו געפינען. א גוט-געהאלטענע טעקע ווי א `README.md` קען שפארן אסאך צייט ביי איינפירן נייע מיטגלידער.
אויב עס איז דא א וויכטיגע טעכנישע באשלוס (למשל, אויסקלויבן א באשטימטע דאטאבאזע, ארכיטעקטורישע מוסטער, אדער אינטעגראציע באגרענעצונג), דאקומענטירט די סיבה. דאס העלפט דעם טיעם פארשטיין דעם קאנטעקסט און פארמיידט איבערחזרן די זעלבע דיסקוסיע.
קלאָוזינג
אויפהאלטבאַרער קאָד איז דער רעזולטאַט פון גוטע געוווינהייטן: שרייבן קלאָר, צעטיילן פֿאַראַנטוואָרטלעכקייטן, אויפהאלטן קאָנסיסטענסי, רעדוצירן קאָמפּלעקסיטעט, און באַשיצן ענדערונגען מיט טעסטן. קיין קאָד איז נישט פּערפעקט, אָבער יעדער פּראָיעקט קען זיך קעסיידער פֿאַרבעסערן אויב די מאַנשאַפֿט איז פֿאַרפֿליכטעט צו קוואַליטעט. דורך ימפּלעמענטירן די עצות אויבן, וועט איר זיין בעסער אויסגעשטאַט צו בליען - ניט נאָר הייַנט, אָבער אויך אין די חדשים און יאָרן צו קומען.
