[Powered by Google Translate] בסרטון הזה, נדבר על סגנון קוד, שזה משהו
שהוא קרוב ויקר ללבי.
סגנון מתאר כיצד הקוד שלך מאותחל, שהוא
עצמאי ממה הקוד עושה בפועל.
לא רק שסגנון טוב לך ציון טוב יותר בCS50,
אבל זה גם יעזור לך לכתוב קוד שהוא הרבה יותר
קריא וקל לתחזוקה, אשר, בסופו של היום,
הוא הולך להפוך את החיים שלך הרבה יותר קלים.
>> את השלושה המרכיבים העיקריים של סגנון קוד שנדברנו
סרטון זה הוא הערות, עיצוב,
ומשתנה שמות.
בואו נתחיל עם הערות.
זכרו, הערות אין השפעה על
הפונקציונליות של הקוד שלך.
הם משמשים רק כרמזים מועילים לנו כמתכנתים.
הערות טובות צריכות לענות על אחת משתי שאלות.
>> ראשית, מה זה בלוק של קוד לעשות?
זהו תיאור קצר וקולע של התכלית
הקווים שפעלו.
לדוגמה, ייתכן שתצטרך למצוא את המקום שבך
מיושם תכונה מסוימת כדי לתקן
באג או שמשהו משתנה.
בלי הערות, ייתכן שתצטרך להתעמק בקווים רבים של
קוד מנסה להבין היכן בדיוק תכונה שהיא.
או אם זה היה כמה ימים מאז שהסתכלת באחד
התוכניות שלך, אולי אתה לא זוכרים מה מסוים
פונקציה או לולאה עושה.
אז הערות תעשינה את עצמך עם reacquainting
קוד ישן, או היכרות עם עצמך מישהו אחר
קוד, הרבה יותר חלק.
השאלה השנייה עונה תגובה טובה היא מה הייתי
ליישם הבלוק הזה בדרך זו?
כפי שאתה כותב קוד, אתה לעתים קרובות צריך
כדי לקבל החלטות עיצוב.
האם עליי להשתמש בלולאה בזמן או ללולאה כאן?
האם אני צריכה ליצור הבלוק הזה של קוד לתוך פונקציה נפרדת?
שימוש בהערות, תוכל לתעד את העיצוב שלך
החלטות, אשר יהפוך את הקוד שלך קל יותר להבין
לאחרים, שאולי ישאל את עצמם בדיוק את אותו
שאלות עיצוב כפי שהם קוראים את הקוד שלך.
או אפילו את עצמך, אם אתה חוזר לבלוק של קוד לאחר
איזה תקופה של זמן.
>> ב C, והשפות האחרות שנראים בCS50, יש
שתי דרכים להוספת הערות לקוד שלך, הערות בשורה
והערות מרובות שורות.
הערות בשורה נהדרות עבור מתעד פיסות הקוד
בתוך פונקציות.
לדוגמה, תגובה באונליין יכולה לתאר
מטרה ללולאה או מקרה פינה שמחייב
מצב.
ההערות מרובות שורות נהדרות לתיעוד פונקציות.
בכל פעם שאתה כותב פונקציה, אתה צריך תמיד, תמיד,
תמיד לתעד את מה שהיא עושה עם תגובה.
זה כולל את מה התשומות לפונקציה, מה
פלט של הפונקציה הוא, ואולי זו הסיבה שהיא הפונקציה
יושם באופן שבו הוא.
בכל פעם שאתה משנה את החתימה של פונקציה, לחזור
ערך, או יישום, חשוב גם לעדכן
תגובת תיעוד מתאימה.
חוסר התאמה בין התגובה ושל פונקציה
יישום יכול להיות ממש מבלבל עבור קוראים.
בדומה לכך, יוצר תגובה רבה קווים בראש
של. כל c או. קובץ h שאתה כותב, ותארת את מה
קובץ זה, זה גם רעיון טוב מאוד.
>> כפי שאתה מעיר את הקוד שלך, אחת השאלות הראשונות שאתה
אולי הוא, ובכן, כמה אני צריך להעיר את הקוד שלי?
זה לעתים קרובות מיותר לתעד כל
שורה אחת של קוד.
לדוגמה, שורה שאומרת int x = 5 לא צריכה
להגיב על זה שאומר "להגדיר x עד 5".
לא להעיר מספיק, אם כי, כפי שראינו, יכול לעשות
הבנת הקוד שלך קשה מאוד.
אז כלל אצבע טובה הוא להגיב בלוקים מעניינים
קוד, שבו בלוק מורכב מכמה שורות בנושא.
>> אז בואו נסתכל על דוגמה.
הנה פונקצית C uncommented.
אוקיי, מכיוון שזה תפקיד, הדבר הראשון שאנחנו צריכים להוסיף
הוא מסביר מה תגובת התשומות של הפונקציה
הם ומה הוא עושה.
אז בואו להוסיף הערה מרובה שורות.
גדול.
עכשיו אנחנו יודעים בדיוק מה התפקיד שלנו עושה.
בואו נוסיף כמה הערות בשורה עכשיו.
אנו יכולים לחלק את הקוד שלנו לשני בלוקים של קווים דומים.
קווי 4 ו 5 מחרוזות לבנות מבוססים על הקלט ו
קווי 6 עד 9 פלט אלה
מחרוזות בתוך מילות שיר.
אז בואו לתעד את זה עם הערות.
מדהים.
עכשיו התפקיד שלנו הגיב.
>> שים לב שההערות שלנו בשורה לא צריכות להשתמש מלא
משפטים או להסתיים בתקופה.
זה חשוב שיש רווח בין הלוכסן 2
ותחילתה של התגובה.
זו התדירות של הערות בתוך התוכניות שלך
כי אתה צריך להיות יורה על.
שימו לב איך אנחנו כאן הפרדנו בין שני בלוקים של קוד קשור
בתוך פונקצית המקהלה שלנו עם חזרת גררה נוספת.
>> זה מביא אותנו למרכיב הבא של סגנון קוד,
עיצוב.
כשהתחלתי תכנות הראשון, אני מכה על Enter
מפתח לעתים רחוקות מאוד, אשר הביא ענק, בלתי קריא
בועות של קוד.
אני חושב שממש נעלבתי בחור ההוראה שלי, שכן היא
לא היה מאושר איתי.
חזותי קיבוץ בלוקים של קוד קשור, באמצעות עגלה
חוזר, יכול להפוך את הקוד שלך יותר קל לרפרף וברור
להתוות קווים שקוד של ההערות שלך להסביר.
עם זאת, פורש את הקוד שלך יותר מדי, כמו עם
שניים או יותר קווים בין גושי קוד או פונקציות, יכולים
גם לעשות את זה הרבה פחות קריא.
>> כניסה היא חשובה נוסף
היבט של פורמט קוד.
תמיד, תמיד, תמיד כניסת הגוף של פונקציה, הלולאה,
או מצב.
זה עושה את זה ברור אילו שורות הקוד נמצאות בתוך
לולאה, למשל, ובו שורות של קוד
מחוץ לזה.
CS50 ממליץ כניסה עם ארבעה מקומות, אבל
אם אתם בוחרים משהו אחר, כדי להיות בטוח להיות עקבי
לאורך כל הקוד שלך.
ובנימה זו, CS50 ממליץ למקם את הפלטות
על הקו שלהם.
בדרך זו, פלטות תהיינה בשורה חזותית באותו השמאל
שולים, כך שזה גביש ברור לאן בלוק מתחיל ונגמר.
עם זאת, זה גם בסדר להציב גשר על אותו הקו
מצב, למשל, כדי לחסוך מקום.
אם אתה עושה את זה, אם כי, הקפד לכלול רווח
לפני הסד המתולתל כך שזה לא מחוצות הבאה לסגירה
סוגר או מילה.
>> כל אפשרות שתבחר, הדבר החשוב ביותר הוא להיות
עקבי לאורך הקוד שלך.
מה שאנחנו לא רוצים לראות, אם כי, הוא
מסוכסך סוגריים מסולסלים.
אם יעשה זאת, הופכת את הפלטה נראית מנותקת מ
תנאי, לולאה או פונקציה שהם תחמו, מה שהופכים
הקוד הקשה לקריאה.
ב C והשפות האחרות שנראה, סוגריים מסולסלים הם
אופציונלי לתנאי קו בודדים או לולאות.
זה בסדר להשמיט סוגריים מסולסלים במקרה הזה, אבל אם
שתנהג כך, יהיה בטוח שיהיו עקבי
לאורך כל הקוד שלך.
>> כאשר מגדירים פונקציות, CS50 ממליץ לך לכתוב
להחזיר סוג של הפונקציה באותה השורה כמו השם של
הפונקציה.
עם זאת, זה גם בסדר לכתוב סוג התשואה עליה
קו, שיכול להפוך את ההגדרות של פונקציות קלות יותר למצוא ב
ישנם עורכי טקסט.
>> לבסוף, הקפד לכלול מרחבים מסביב
מילות מפתח ומפעילים.
לדוגמה, שורה שאומרת int x = 5 הוא הרבה יותר קל
לקרוא אם יש שטחים ברחבי סימן השוויון.
כמו כן, ודא שיש לך רווח אחרי מילות מפתח כמו אם,
ל, ובזמן.
ללא רווח, אלה יכולים להיראות כמו קריאות פונקציה,
שהם לא.
>> אז בואו נסתכל על דוגמה של החלת סגנון טוב
לגוש קשה מעוצב של קוד.
אוקיי, בואו נתחיל מההתחלה.
אנחנו יכולים לראות שסד הפתיחה העיקרית הוא על אותו
קו כשם של הפונקציה.
אם אנחנו הולכים לעשות את זה, צריך להיות חלל שבין
סוגר סגירה וסד, כמו זה.
עם זאת, CS50 ממליץ פלטות לעמוד
על הקו שלהם.
אז בואו נעשה את זה.
עכשיו שאנחנו בגוף של הפונקציה העיקרית, נצטרך
כדי להתחיל indenting קוד, יצטרך להשתמש
מומלץ ארבעה חללים.
בשלב בא, אנו רואים שאין חלל סביב סימן השוויון
כאן, אז בואו נוסיף את זה.
כאן, אנו רואים שאין מקום בין אם ו
סוגר פתוח, אז בוא נוסיף, כי, יחד עם מרווח כלשהו סביב
גדול משלט.
שוב, אנו רואים שאין רווח בין הסוגריים והסגירה
סד הפתיחה כאן.
אם אנחנו הולכים לשים אותם באותה השורה, יש צורך
להיות רווח לפני הסד המתולתל.
עם זאת, זה נראה כמו הגוף שלנו
מצב הוא רק קו אחד.
אז אנחנו לא צריכים לכלול את הפלטה בכל.
עכשיו אנחנו צריכים להיות בטוחים לכניסה בגופו של כל אחד מ
התנאים שלנו.
אנחנו בהחלט לא רוצים השורה האחרונה רק כדי להיות באותו
להיט קו כאחר, אז בואו והזן את הכניסה.
לבסוף, הסד המתולתל הסגירה לצרכימים עיקריים יהיה על
הקו שלו.
>> אנחנו יכולים לראות שיש לנו כאן שתי שונים
בלוקים של קוד בנושא.
4 עד 6 שורות לבקש ממשתמש קלט ו
קווים נותרים להציג קלט שלמשתמש.
אז זה הגיוני לשים קצת רווח בין שני הרחובות האלה
לבהירות.
ויש לנו ללכת, עכשיו הקוד הזה הוא הרבה יותר קל לקריאה עם
סגנון טוב.
>> לבסוף, בואו נדבר על המרכיב השלישי שלנו של סגנון טוב:
שמות משתנים.
שמות המשתנים, צריכים לתאר
ערך שהם מייצגים.
בואו לבקר בדוגמא הקודמת.
בקבוקים הם שם תיאורים טובים למשתנה ש
מייצג כמה בקבוקים נותרו על הקיר.
שמות כמו X או numBots לא מאוד תיאורים והם
לא טוב לקריאות של הקוד שלך.
בעוד משתנים שכונו על ידי אות אחת נפוצים ב
מתמטיקה ובתחומים אחרים, הם יכולים להפוך את הקוד שלך קשה מאוד
כדי להבין.
יוצאים מכלל זה הוא איטרטור
משתנה בתוך לולאות.
בלולאות, למשל, זה בסדר להשתמש במשתנה
שמות כמו i, j, ו-k לאיטרציה.
בעת יצירה משתנית איטרטור בתוך לולאות, זה
מוצע שתעשו זאת בתוך הלולאה עוצמה, אלא
מ מחוץ ללולאה, כך שנוכל לשמור משתנים כמו
חוזקה scoped ככל האפשר.
>> מצד השני, שם משתנה כמו מספר הבקבוקים
השאיר על הקיר, ואילו תיאורים, מדי מפורטת
ולא הכרחי.
בכל מקרה אתה רוצה ליצור משתנה עם
מילים מרובות, הפרד את המילים האלה בקו תחתון.
לדוגמה, is_ready הוא הרבה יותר קריא מisReady.
זה בסדר להצהיר על משתנים מרובים על אותו הקו.
עם זאת, אם אתה עושה זאת, לא לאתחל משתנים מסוימים אבל
לא לאחרים.
זה אומר משהו כמו מטבעות, מטבעים int
פסיק, הוא אישור.
אבל int ערכן = 0, פרוטות
פסיק הוא לא.
>> לבסוף, כאשר הכרזת מצביעים, מומלץ
שאתה ממקם את הכוכבית לצד הסוג של המצביע, לא
השם המשתנה.
אז * p מומלץ int ולא int
חלל * p.
וואו!
אז זה נראה כמו הרבה חוקים ל
זוכר, אבל אל תדאגו.
אם אי פעם בספק, אל תהססו לפנות לCS50 של
מדריך סגנון באינטרנט.
>> הבה תסכמו החשוב במהירות
נקודות של סגנון קוד.
ראשית, להגיב הקוד שלך.
תמיד, תמיד, תמיד מתאר את מה פונקציות עושות
עם הערת קו רב ולהגיב כל כמה שורות של
קוד באופן מקוון.
שני.
להיות עקבי עם עיצוב הקוד שלך.
שים לב למיקום והשימוש שלך של פלטות
כמו גם מרווח סביב מילות מפתח ולמפעילים.
לבסוף, לבחור שמות משתנים תאוריות.
משתנים צריכים לתאר את הערך שהם מייצגים, אבל
לא צריך לקחת אותך לנצח להקליד.
>> וזהו זה.
כל זה יהפוך מהרה לטבע שנייה כמו שאתה
לכתוב יותר ויותר קוד, ואתה תהיה קידוד
עם סגנון בתוך זמן קצר.
השמי הוא טומי, וזה CS50.