[Powered by Google Translate] [סעיף 8 - יותר נוח]
[רוב אודן - אוניברסיטת הרווארד]
[זה CS50. - CS50.TV]
>> הערות סעיף בשבוע הבא הולכות להיות די קצר,
אז אני פשוט הולך להמשיך לדבר, אתם הולכים להמשיך לשאול שאלות,
ואנו ננסה למלא את כל זמן שאפשר.
הרבה אנשים חושבים שpset זה לא בהכרח קשה, אבל זה מאוד ארוך.
Pset המפרט עצמו לוקח שעה לקרוא.
אנחנו נותנים לך הרבה SQL שאתה עשוי להזדקק לשימוש.
אנחנו ננחה אותך בהרבה ממנו, כך שזה לא צריך להיות כל כך רע.
האם מישהו התחיל או סיים?
זה pset האחרון. הו, אלוהים שלי.
בדרך כלל יש JavaScript אחת אחרי זה, אבל דברי שינוי הלוח
הופך את הכל 1 שבוע קצר יותר, ואנחנו כבר לא צריכים pset-JavaScript.
אני לא יודע איך זה משפיע על היכולת של JavaScript הולך להופיע בבחינה
או חידון 1.
אני מתאר לעצמי שזה יהיה משהו כמו שאתה צריך לדעת את הדברים ברמה גבוהה על JavaScript,
אבל אני בספק אם אנחנו רק רוצים לתת לך קוד JavaScript ישר
מאז לא היה לך pset בזה.
אבל זה יהיה חומר לבדיקת בוחן בשבוע הבא.
>> קטע של שאלות.
הרבה מהדברים האלה הוא קצת גרוע מנוסחים, אבל נדונונו למה.
שלא כמו C, PHP היא שפה "דינמית מודפסת". מה זה אומר, אתם שואלים?
ובכן, אומר שלום לכל, אלה לצוף char, int, ומילות מפתח אחרות אתה צריך להשתמש
כאשר הגדרה משתנית ופונקציות בג
ב-PHP, הסוג של משתנה נקבע על ידי הערך שהיא מחזיקה כיום.
אז לפני שאנחנו מקלידים את הקוד הזה לקובץ שנקרא dynamic.php,
PHP היא הקלדה באופן דינמי. זה נכון.
אני לא מסכים עם עובדה שזה אומר שאנחנו אומרים שלום לchar, float, int,
ומילות מפתח אחרות.
ההבדל המדויק בין דינמי מוקלד והחלופי,
אשר הקליד באופן סטטי, הוא שהוקלד באופן דינמי, כל הבדיקה וכל מיני הדברים מהסוג שלך
קורה בזמן ריצה, ואילו הקליד סטטי זה קורה בזמן הידור.
המילה סטטית באופן כללי נראה שהתכוונה לדברים זמן לקמפל.
אני מניח שיש שימושים אחרים לזה, אבל ב-C כאשר אתה מצהיר על משתנה סטטי,
האחסון מוקצה בזמן הידור.
כאן, הקליד באופן דינאמי רק אומר כי -
ב C אם אתה מנסה להוסיף מחרוזת ומספר שלם, כאשר אתה מהדר אותו,
זה הולך להתלונן כי זה יגיד שאתה לא יכול להוסיף int ומצביע.
זה פשוט לא פעולה חוקית.
זה עוד דבר שאנחנו נגיע לשניים.
אבל זה סוג של בדיקה, עובדה שהיא מתלוננת בזמן הידור,
היא סוג בדיקה סטטית.
יש שפות שבו אתה לא צריך לומר, לצוף char, int, וכל הדברים האלה,
אבל השפה יכולה לספר מההקשר של הדבר איזה סוג שהוא אמור להיות,
אבל זה עדיין הוקלד באופן סטטי.
אז אם אתה לוקח 51, OCaml, שלעולם לא תצטרכו להשתמש בכל אחד מסוגים אלה,
אבל זה עדיין בזמן ההידור אומר שאתה לא יכול לעשות את זה בגלל שאתה מערבב int ומחרוזת.
דינאמי הקליד רק אומר שמתישהו במהלך זמן ריצה שאתה הולך לקבל את תלונה.
אם גם אתם השתמשתם Java לפני, באופן כללי, כמעט כל סוג C-שפה
הולך להיות מוקלד באופן סטטי, כך C, C + +, ג'אווה, כל אלה בדרך מוקלדת באופן סטטי.
ב-Java כאשר אתה מהדר משהו ואתה אומר
מחרוזת של שווה משהו חדש שאינו מחרוזת,
זה הולך להתלונן כי סוגים אלה פשוט לא מתאימים.
זה הולך להתלונן בזמן הידור.
אבל יש לו גם קצת זמן דינמי דברים כמו אם אתה מנסה להטיל משהו
לסוג זה יותר ספציפי מסוגו הנוכחי,
אין שום דבר שהוא יכול לעשות בזמן הידור כדי לבדוק אם שחקנים שהוא הולך להצליח.
ג'אווה יש גם איזה סוג בדיקה דינמית שברגע שזה יגיע לשורת קוד
כשזה באמת ביצוע, זה הולך לעשות יצוק,
לבדוק אם השחקנים שהיו בתוקף במקום הראשון,
ואם זה לא הייתי, אז זה הולך להתלונן שיש לך סוג לא חוקי.
סוג הבדיקה דינמי.
הקלד את זה לקובץ שנקרא dynamic.php.
Dynamic.php.
אני לפתוח עיצוב.
יש לנו משתנה, אנחנו מגדירים את זה ל7 מספר השלמים,
אז אנחנו הולכים להדפיס אותו ו% s -
הו, אנחנו מדפיסים את הסוג זה, אז gettype הולך לחזור לסוג של המשתנה.
אנחנו פשוט מדפיסים את הסוג שוב ושוב.
אנחנו רק php.dynamic.php.
נראים שהיא משתנית ממספר שלם למחרוזת לוליאני כמו שאנחנו עוברים.
ב C אין טיפוס נתונים בוליאני, אין נתונים מסוג המחרוזת.
יש * char ובוליאני פשוט נוטה להיות int או char או משהו.
ב PHP הסוגים הללו אכן קיימים, וזה אחד היתרונות הגדולים של PHP מעל C -
פעולות שמחרוזת הן לאין ערוך יותר קלות מאשר ב-PHP C. הם פשוט עובדים.
>> אז אנחנו חוזרים לכאן.
רצנו dynamic.php.
זה אומר למתורגמן PHP, נקרא PHP, כדי להריץ את קוד PHP בdynamic.php.
אם יש לך שגיאות בקובץ, המתורגמן יגיד לך!
המתורגמן, זה עוד הבדל גדול בין PHP ו-C
ב C אתה צריך לקמפל משהו ואז אתה מפעיל אותו קובץ הידור.
ב PHP אתה לא לקמפל שום דבר.
אז מתורגמן PHP הוא בעצם רק קריאת שורה זו על ידי קו.
הוא פוגע var = 7 אז זה מכה printf אז זה מכה var אז זה מכה printf וכן הלאה.
יש שם קטע של עריכה שהיא עושה, והיא מעבירה למטמון את התוצאות
כך שאם אתה מפעיל את התסריט מאוחר יותר אתה יכול לעשות קצת,
אבל בעצם זה קו לפי קו של דבר.
זה אומר שהרבה באופטימיזציות שאנחנו מקבלים ב-C,
כמו קומפילציה, זה רק באופן כללי את המהדר יכול לעשות הרבה טריקים בשבילך.
זה יכול לקחת את משתנים שאינם בשימוש, זה יכול לעשות את כל דברים אלו,
הוא יכול לעשות רקורסיה זנב.
ב PHP אתה לא הולך לקבל את היתרון ש
כי זה פשוט הולך להתחיל בביצוע השורה אחרת שורה אחרת שורה,
וזה לא ממש מכיר את הדברים האלה בקלות
מאז זה לא עובר 1 גדול הידור על הדבר ולאחר מכן ביצוע;
זה רק שורה אחר שורה.
אז זה המתורגמן.
>> בחזרה להקלדה הדינמית שלנו: די מגניב, הא?
אתה בהחלט לא יכול לעשות את זה בשלישי!
עכשיו, תראה אם ​​אתה יכול להבין את הסוג של כל אחד מהערכים הבאים.
ראה זה לעיון.
אז 3.50. איזה סוג אתה חושב שזה הולך להיות?
להלן סוגים שיש לנו.
יש לנו bools, מספרים שלמים, נקודות צפות, מחרוזות, מערכים, אובייקטים,
ואז משאבים, שהוא סוג של מעורפל.
אני חושב שיש דווקא דוגמה כאן.
אז יש NULL. NULL הוא סוג מיוחד.
בניגוד לג בי NULL הוא רק מצביע עם כתובה 0,
ב-PHP, NULL הוא הסוג בפני עצמו שבו הדבר התקף רק מסוג זה הוא NULL.
זה הרבה יותר שימושי לבדיקת שגיאות.
ב C שבו הייתי הנושא שבו אם אתה חוזר NULL,
זה אומר שאתה חוזר מצביע NULL או באמצעות NULL כדי לסמן שגיאה
או כל הבלבול שהיו לנו בשלב מסוים.
כאן, חוזר NULL בדרך כלל אומר שגיאה.
הרבה דברים גם בתמורת שווא לטעויות.
אבל הנקודה היא סוג NULL, הדבר היחיד מסוג NULL הוא NULL.
אז איתות היא כמו שאתה יכול להגדיר כמה פונקציות אנונימיות.
אתה לא צריך לתת לפונקציה שם, אבל אתה לא צריך להתמודד עם זה כאן.
כאשר מסתכלים על הסוגים שהם מצפים מאתנו יודעים,
מה אתה חושב על הסוג של 3.50 הוא? >> [תלמיד] תהלוכה.
כן.
אז כאן, מה אתה חושב על הסוג זה? >> [תלמיד] מערך.
כן. הראשון היה מצוף, השני הוא מערך.
שימו לב שהמערך הזה הוא לא כמו מערך C
שם יש לך מדד 0 יש ערך, 1 במדד יש ערך כלשהו.
הנה את המדדים, B ו-C והערכים הם 1, 2, ו 3.
ב PHP אין הבדל בין מערך אסוציאטיבי ורק מערך רגיל
כפי שהיית חושב על זה בג
יש רק את זה, ומתחת למכסת מנוע מערך רגיל הוא פשוט מערך אסוציאטיבי
בי 0 מפות לשווי חלק אותו אופן מפות לשווי מסוים.
מסיבה זו, PHP יכול להיות די רע לדברים ממש מהר קוד / השוואות
מאז בC כאשר אתה משתמש מערך אתה יודע שגישת חברה היא זמן קבוע.
ב PHP גישת חבר הוא מי יודע כמה זמן?
זה כנראה קבוע אם זה hashes בצורה נכונה.
מי יודע מה באמת עושה מתחת למכסת המנוע?
אתה באמת צריך להסתכל על היישום כדי לראות איך זה הולך להתמודד עם זה.
אז fopen.
אני חושב שכאן בואו fopen מדריך פשוט PHP להסתכל על סוג התמורה.
אנו רואים כאן שאתה יכול להסתכל למעלה כמעט כל פונקציה בPHP הידני
וזה סוג של דף האיש של PHP.
סוג ההחזרה הולך להיות משאב.
בגלל זה אני נראה את זה, כי אנחנו לא באמת להגדיר משאבים.
הרעיון של משאב, בC אתה סוג של לי * קובץ או כל דבר אחר!
ב-PHP הוא המשאב * הקובץ שלך.
זה מה שאתה הולך להיות קריאה, זה מה שאתה הולך לכתוב אל.
זה בדרך כלל חיצוני, כך שזה משאב שיכול למשוך את דברים ומלזרוק דברים.
ולבסוף, מה הוא הסוג של NULL? >> [תלמיד] NULL.
כן. אז הדבר היחיד שהוא NULL הוא NULL.
NULL הוא NULL.
>> תכונה אחת של מערכת הסוג של PHP (לטוב ולרע) היא יכולתו לתמרן בין סוגים.
כשאתה כותב שורת קוד PHP שמשלב ערכים מסוגים שונים,
PHP ינסה לעשות את הדבר הנכון.
נסה את כל אחת מהשורות הבאות של קוד PHP. מה יודפס?
האם זה מה שציפית? למה או למה לא?
עובדה זו על PHP היא מה שעושה את מה שאנו מכנים בחולשה מוקלדת.
הקליד בחולשה והחזקה הקליד,
ישנם שימושים שונים למונחים אלה,
אבל רוב האנשים משתמשים הקליד בחולשה והחזקה הקליד לאומרים דברים מהסוג הזה
שם ("1" + 2); שעובד.
ב C זה לא יעבוד.
אתה יכול לדמיין את זה לא עובד.
הרבה אנשים מבלבל את ההקלדה דינמית והקלדה חלשה והקלדת סטטי והקלדה חזקה.
פייטון הוא דוגמה נוספת לשפה ההקלידה באופן דינמי.
אתה יכול לזרוק סביב סוגים במשתנים וזה הולך לקבוע בזמן הריצה
כל checkings שגיאה.
בפייתון זה הולך לבצע את זה וזה יהיה לראות ("1" + 2);
וזה ייכשל, כי זה אומר שאתה לא יכול להוסיף מחרוזת ומספר שלם.
ב-PHP, שהוא בדיוק כמו דינמי הקליד, זה לא להיכשל.
הקלדה חלשה קשורה לעובדה שהיא עושה דברים בסוגים
שלא באמת הגיוני בהכרח.
אז ("1" + 2); אני יכול לדמיין שלהיות מחרוזת 12, אני יכול לדמיין אותו להיות מחרוזת 3,
אני יכול לדמיין אותו להיות מספר השלם 3.
זה לא בהכרח מוגדר היטב, ואנחנו כנראה הולכים לראות כאן
כי כאשר אנו להדפיס ("1" + 2); זה כנראה הולך להיות בסופו שונה
מהדפסה (1 + "2").
וזה נוטה להיות, לדעתי, ליותר גרוע.
כאן אנו יכולים לנסות אלה.
טריק קטן נוסף על PHP הוא שאתה לא צריך ממש לכתוב את הקובץ.
אכן יש להפעיל מצב פקודה זו.
אז php-r, אז אנחנו יכולים לזרוק את הפקודה כאן:
"הדפסה ('1 '+ 2);" ואני אזרוק את קו חדש.
זה מודפס 3.
זה נראה כאילו זה מדפיס 3 וזה 3 מספר השלמים.
אז עכשיו בואו ננסה את הדרך ההפוכה:
"הדפסה (1 + '2 ');
אנחנו מקבלים 3, וזה גם הולך להיות 3 מספר שלם? אני באמת אין לי מושג.
זה נראה כמו שעולה בקנה אחד.
לעולם אין לכך שום סיכוי להיות 12 מחרוזת או משהו כזה
כי PHP, שלא כמו JavaScript ו-Java גם
יש מפעיל נפרד לשרשור.
שרשור ב PHP הוא נקודה.
אז הדפסה (1 '2 '.); הוא הולך לתת לנו 12.
זה נוטה לגרום לבלבול שבו אנשים מנסים לעשות משהו כמו str = +
איזה דבר אחר שהם רוצים להוסיף על לסוף המחרוזת שלהם, וזה הולך להיכשל.
אתה צריך לעשות את str. =
אז אל תשכחו בשרשור PHP הוא נקודה.
דברים נוספים שכדאי לנסות: להדפיס ("CS" + 50);
אמרתי לך שאין שום תקווה לכך וכתוצאה מכך CS50
מאז השרשור הוא לא +.
מה אתה חושב שזה הולך להיות בסופו?
אני באמת יש לי שום מושג.
זה נראה כאילו זה רק 50.
היא רואה את המחרוזת, ואני בטוחה שאם אנחנו שמים 123CS -
היא רואה את המחרוזת הראשונה, היא מנסה לקרוא ממנו שלמה או מספר ממנו.
במקרה זה רואה 123CS.
"זה לא הגיוני כמספר שלם, אז אני פשוט הולך לחשוב על 123."
אז 123 + 50 הולכים להיות 173.
והנה זה מתחיל לקרוא את זה כמספר שלם.
הוא לא רואה משהו, כך שרק מתייחס אליו כ 0. אז 0 + 50 הולכים להיות 50.
זה אני מניח שהוא הולך לעשות משהו דומה.
אני חושב 99.
כן, כי זה הולך לקחת 1 -
אז 99.
כאן (10/7), אם זה היה C, מה שיחזור?
[תלמיד] 1. >> כן, זה יהיה 1 כי 10/7 הוא חלוקת 2 מספרים שלמים.
שלם מחולק במספר שלם הולך להחזיר מספר שלם.
זה לא יכול לחזור כל 1 נקודה שיהיה, אז זה רק הולך לחזור 1.
הנה הדפסה (10/7); זה הולך בעצם לפרש את זה.
וזה אומר שאם אתה באמת רוצה לעשות את העיגול ודברים שלמים ככה,
אתה צריך לעשות הדפסה (רצפה (10/7));
ב C זה כנראה מוזר, כי אתה יכול לסמוך על עיצור שלם באופן קבוע,
אבל ב-PHP אתה לא יכול כי זה יהיה באופן אוטומטי להפוך אותו למספר עשרוני.
ולאחר מכן (7 + נכון); מה אתה חושב שזה הולך להיות?
אני מנחש 8 אם זה הולך לפרש כנכון 1.
זה נראה כמו שזה 8.
>> אז כל מה שעשינו ב 10 הדקות האחרונות אתה ממש לא צריך לעשות.
אתה תראה קוד שעושה את זה.
זה לא חייב להיות כך פשוט כמו שזה.
יכול להיות לך 2 משתנה, ומשתנה 1 קורה להיות מחרוזת
ומשתנה האחרים קורה להיות int, ואז אתה מוסיף המשתנים הללו יחד.
מאז PHP יוקלד באופן דינמי וזה לא יעשה שום בדיקת סוג בשבילך
ומכיוון שהקליד בחולשה ומאז זה יהיה באופן אוטומטי רק לזרוק הדברים האלה יחד
והכל יהיה פשוט לעבוד, זה קשה אפילו לדעת שמשתנה זה חייב להיות מחרוזת עכשיו,
אז אני לא צריך להוסיף אותו למשתנה זה, שהוא שלם.
התרגול הטוב ביותר הוא אם למשתנה היא מחרוזת, לשמור אותו כמחרוזת לנצח.
אם משתנה הוא int, לשמור אותו כint לנצח.
אם אתה רוצה להתמודד עם מספרים שלמים ומחרוזות,
אתה יכול להשתמש varsint - זה JavaScript.
Intval. אני עושה את זה כל הזמן. PHP ו-JavaScript אני מערבב את הכל.
אז intval הולך להחזיר את הערך השלם של משתנה.
אם אנחנו עוברים ב" הדפסה (intval (123 ')); אתה מקבל 123.
Intval עצמו היא לא הולך לעשות את הבדיקה עבורנו שזה אך ורק מספר שלם.
המדריך של PHP, יש כל כך הרבה פונקציות פשוט זמינות,
אז הנה מה שאני חושב שהייתי משתמש הוא is_numeric הראשון.
אני מנחש שחזרתי שווא.
זה עוד דבר שצריך לעבור עליו ===.
אז is_numeric ('123df '), לא היית חושב על זה כis_numeric.
ב C היית צריך לחזר על כל התווים
ולבדוק אם כל תו הוא ספרה או משהו כזה.
הנה is_numeric הולך לעשות את זה בשבילנו,
וזה חוזר שווא.
לכן, כאשר הדפסתי את אותו, אותו הדפיס דבר, אז הנה אני משווה אותו כדי לראות,
לא קורה לך להיות כוזב? ואז עכשיו זה הדפסת 1.
כנראה שזה מדפיס 1 כאמיתי במקום להדפיס נכון כנכון.
אני תוהה אם אני עושה print_r. לא, זה עדיין עושה 1.
>> חוזר ל===, == עדיין קיים,
ואם אתה מדבר עם טומי הוא יגיד == הוא בסדר גמור.
אני הולך להגיד את זה == הוא נורא ואתה לא צריך להשתמש ==.
ההבדל הוא ש== משווה דברים
איפה זה יכול להיות נכון גם אם הם לא מאותו הסוג,
בעוד === משווה דברים וראשונים שהיא בודקת האם הם מאותו הסוג?
כן. אוקיי, עכשיו אני הולך לראות אם הם באמת להשוות להיות שווים.
אתה מקבל דברים מוזרים כמו 10 שווים - בואו תראו מה זה אומר.
אז ('10 '== '1 E1');
זה מחזיר את האמת.
למישהו יש ניחושים למה זה מחזיר אמיתי?
זה לא רק על זה. אולי זה רמז.
אבל אם אני משנה את זה לו - לתקן את זה! אני שומר את השימוש במרכאות כפולות.
הסיבה למרכאות הכפולות הם צועקות עליי בגלל שאני שמתי את זה במרכאות כפולות.
כדי שאוכל להימלט מהמרכאות הכפולות בפה, אבל ציטוטים בודדים לעשות את זה יותר קל.
אז ('10 '== '1 F1'); לא מדפיס אמיתי. ('10 '== '1 E1'); מדפיס אמיתי.
[תלמיד] האם זה hex? >> זה לא קללה, אבל זה קרוב שזה כמו -
, סימון מדעי 1e1.
היא מכירה 1e1 כמו 1 * 10 ^ 1 או משהו כזה.
אלה הם מספרים שלמים שווים.
אם אנחנו עושים === אז זה הולך להיות כוזב.
אני באמת אין לי מושג אם נעשה == מה (10 ו'10abc ');? בסדר. אז זה נכון.
אז בדיוק כמו כאשר אתה עשית (10 + '10abc '), וזה יהיה 20,
כאן (10 == '10abc '); הוא נכון.
גרוע מכך הם דברים כמו (כוזב == NULL); נכון
או (false == 0); נכון, (שקר == []);
יש מקרים מוזרים של - זה אחד המקרים המוזרים האלה.
שים לב ש( false == []); הוא נכון.
('0 '== False); הוא נכון.
('0 '== []); הוא שקרי.
אז == הוא בשום אופן לא יוצא.
יכול להיות שווה ל ב ויכול להיות שווה לג,
אבל ב לא יכול להיות שווה לג.
זה תועבה אליי, ואתה תמיד צריך להשתמש ===.
[תלמיד] אנחנו יכולים לעשות! == גם? >> [אודן] כן.
השווה יהיה! = ו! ==.
זה הוא למעשה גדל בpset המפרט
שבו הרבה פונקציות תמורה -
המדריך של PHP הוא טוב לגבי זה.
זה מכניס בקופסה אדומה גדולה ", זה יחזיר כוזב אם יש שגיאה."
אבל 0 חוזרים הוא דבר הגיוני לחלוטין כדי לחזור.
תחשוב על כל פונקציה שצפויה להחזיר מספר שלם.
נניח שהפונקציה זו אמורה לספור את מספר השורות בקובץ או משהו.
בנסיבות רגילות, שאתה עובר בפונקציה זו קובץ
וזה הולך להחזיר מספר שלם שמייצג את מספר השורות.
אז 0 הם מספר הגיוני לחלוטין אם הקובץ הוא פשוט ריק.
אבל מה אם אתה עובר אותו קובץ לא חוקי והתפקוד קורה לתמורת שווא
אם אתה עובר אותו קובץ לא חוקי?
אם אתה פשוט עושה == אתה לא מבדיל בין מקרה קובץ לא חוקי וקובץ ריק.
השתמש תמיד ב===.
זה כל אלה.
>> ב-PHP, סוג המערך הוא שונה ממה שאתה רגיל לראות בג
ואכן, ייתכן שכבר שמת לב זה לעיל, כשראית שזה מסוג המערך.
התחביר הוא הסוגר חדש כמו של PHP 5.4, המהווה את הגרסה החדשה ביותר של PHP.
לפני זה תמיד היית צריך לכתוב מערך ('' -> 1, 'ב' -> 2.
זה היה הבנאי למערך.
עכשיו סוף סוף הגיע PHP בסביבה כדי התחביר הנחמד של סוגריים מרובעים בלבד,
שהוא פשוט כל כך הרבה יותר טוב ממערך.
אבל בהתחשב PHP 5.4 היא הגרסה החדשה ביותר,
ייתכן שתיתקל במקומות שאפילו אין לי PHP 5.3.
במהלך הקיץ נתקלנו בנושא הזה שבו PHP 5.3 היו מה שהיינו לנו על המכשיר,
אבל השרת שנפרסנו בכל הספר בכיתה שלנו ולשלוח וכל זה כדי
היה PHP 5.4.
בלי לדעת זאת, פתח ב5.3, דחף ל -5.4,
ועכשיו כל איש פתאומי של הקוד שלנו עובד
כי יש במקרה היה שינויים בין 5.3 ל 5.4
שאין תאימות לאחור,
ואנחנו צריכים ללכת ולתקן את כל הדברים שלנו שלא עובדים עבור PHP 5.4.
לכיתה זו, שכן המכשיר עושה לי PHP 5.4,
זה בסדר גמור להשתמש בסוגריים מרובעים.
אבל אם אתה מחפש את הדברים ברחבי האינטרנט,
אם אתה מחפש קצת סוג של חומר מערך, סביר להניח שאתה הולך לראות
הכישוף את תחביר בנאי מערך מאז שהיה פה מאז PHP נולד
ותחביר סוגר מרובע בסביבה כבר כמה את החודשים האחרונים
או בכל פעם שבאו סביב 5.4.
זה איך אתה מדד.
בדיוק כמו ב-C איך היית מדד בסוגריים מרובעים כמו מערך $ [0], $ מערך [1], מערך $ [2],
יצירת אינדקס באותו אופן, אם במקרה יש לך המדדים להיות מחרוזות.
אז מערך $ [''] ו$ מערך ['ב'].
מערך $ [ב]. למה שזה יהיה בסדר?
זה כנראה יפיק אזהרה אך עדיין עובד. PHP נוטה לעשות את זה.
הוא נוטה פשוט, "אני הולך להזהיר אותך על זה, אבל אני רק הולך להמשיך
"ולעשות כל מה שאני יכול."
זה כנראה יהיה לתרגם את זה למחרוזת,
אבל זה אפשרי, כי בשלב מסוים בעבר מישהו אמר
להגדיר ב להיות "שלום העולם".
אז עכשיו ב יכול להיות קבוע מערך ו$ [b] יהיה למעשה עושה "שלום העולם".
אני חושב שבשלב זה, או לפחות הגדרות PHP שלנו,
אם תנסה אינדקס לתוך מערך ומפתח שאינו קיים, הוא ייכשל.
אני לא חושב שזה רק יזהיר אותך.
או לפחות אתה יכול להגדיר אותו כך שהוא לא רק מזהיר אותך, זה פשוט ישר למעלה נכשל.
>> הדרך בה אתה בודק אם באמת יש מדד כזה היא isset.
אז isset ($ מערך ['שלום העולם']) יחזיר שקר.
isset (מערך $ ['ב']) יחזיר אמת.
אתה יכול לערבב תחביר אלה.
אני די בטוח שזה מה שמערך סופו של דבר הוא - אנחנו יכולים לבדוק את זה.
אה, אני צריך PHPWord.
זו היא ערבוב התחביר שבו אתה מציין מה הוא המפתח
ואינך מציין מה הוא המפתח.
אז 3 כאן הוא ערך.
לא באופן מפורש שאמרת את מה המפתח שלו הוא הולך להיות.
מה אתה חושב שהמפתח שלו הוא הולך להיות?
[תלמיד] 0. >> אני מנחש 0 רק בגלל שזה ראשון שלא צוין.
אנחנו באמת יכולים לעשות כמה מקרים אלה.
אז print_r הוא להדפיס רקורסיבית. זה יהיה להדפיס את כל המערך.
זה יהיה להדפיס subarrays של המערך אם היו כאלה.
php.test.php; אז print_r ($ מערך).
זה נראה כמו שזה נתן לו 0.
יש באמת משהו שכדאי לזכור כאן, אבל אנחנו נחזור אליה ברגע האחד.
אבל מה אם אני במקרה עושה מדד זה 1?
PHP לא להבדיל בין מדדי מייתרים ומדדים שלמים,
לכן בשלב זה אני כבר ממש הגדרתי עמוד 1 ואני יכול לעשות את שניהם מערך $ [1] ומערך $ ['1 ']
וזה יהיה אותו מדד ואותו מפתח.
אז עכשיו מה אתה חושב 3 הולך להיות? >> [תלמיד] 2. >> [אודן] אני מנחש 2.
כן. זה 2.
מה אם עשינו את זה הוא 10, זה 4? מה אתה חושב שהמדד של 3 הולך להיות?
אני חושב 11.
הניחוש שלי לגבי מה PHP עושה - ואני חושב שראיתי את זה קודם -
האם זה רק עוקב אחר מה שהמדד המספרי הגבוה ביותר שלו השתמש עד כה הוא.
זה אף פעם לא הולך למנות את ראשי מחרוזת עד 3. זה תמיד יהיה מדד מספרי.
אז זה עוקב אחר בגבוה זה הוקצה עד כה, אשר קורה להיות 10,
וזה הולך לתת 11-3.
מה שאמרתי קודם, שים לב לאופן בו הוא מדפיס מערך זה.
היא מדפיסה 10 מפתח, מפתח 4, 11 מפתח, המפתח ד.
או אפילו בואו נעשה -
אני מניח שאני לא לשים 0, אבל זה דפוס 1, 2, 3, 4.
מה, אם אני עובר כאן? או בואו בעצם לעבור 2 אלה.
עכשיו זה מדפיס 2, 1, 3, 4.
המערכים של PHP הם לא בדיוק כמו שולחן החשיש הרגיל שלך.
זה הגיוני לחלוטין כדי לחשוב עליהם כשולחנות hash 99% מהזמן.
אבל בטבלאות hash שלך אין שום תחושה של סדר בדברים שהוכנסו.
אז ברגע שאתה מכניס אותו לתוך שולחן החשיש,
תניח שאין רשימה מקושרת ואתה יכול לשפוט ברשימה מקושרת
שהוכנס ראשון.
אבל כאן הכנסנו 2 1 והוא יודע מתי זה להדפיס את המערך הזה ש2 מגיעים ראשון.
זה לא להדפיס אותו בסתם סדר.
מבנה הנתונים הטכני שהיא עושה שימוש הוא מפה מסודרת,
כך שזה ממפה את המפתחות לערכים והוא זוכר את הסדר שבו המפתחות האלה הוכנסו.
בעיקרון זה לסיבוכים מסוימים בם זה מעצבן ממש -
בואו נגיד שיש לך מערך 0, 1, 2, 3, 4, 5
ואתה רוצה לקחת את האינדקס 2.
דרך אחת לעשות את זה, בואו לראות מה שנראה כמו.
0, 2, 1, 3, 4.
בטל הגדרה קורית כדי לבטל את הגדרת שני משתנים ומדדי מערך.
כה מטלטלת (מערך [2] $);
עכשיו, מה זה הולך להיראות כמו? 2 הם פשוט נעלם, כך שזה בסדר גמור.
הדבר הכי מעצבן הוא שאם אתה רוצה שדברים יהיו ממש כמו מערך.
אני אשים את המספרים אקראיים.
עכשיו שם לב המדדים שלי.
אני רוצה שזה פשוט להיות כמו מערך C בו הוא עובר בין 0 ל אורך - 1
ואני יכול לחזר עליו ככזה.
אבל ברגע שאני unset המדד השני, מה שהיה ב3 מדד לא עכשיו להיות אינדקס 2.
במקום זאת, פשוט מסירה מדד ועכשיו אתה הולך 0, 1, 3, 4.
זה הגיוני לגמרי.
זה פשוט מעצבן ואתה צריך לעשות את דברים כמו אחו מערך. כן.
>> [תלמיד] מה היה קורה אם היה לך ללולאה
ושאתה רוצה ללכת על כל האלמנטים?
כאשר הוא פגע 2, הייתי עליה להניב אי פעם?
Iterating על מערך. ישנן 2 דרכים אתה יכול לעשות את זה.
אתה יכול להשתמש רגיל ללולאה.
זו מורכבות נוספת של PHP.
רוב השפות, הייתי אומר, יש לו איזה אורך או len או משהו
מציין את אורכו של מערך.
ב PHP זה ספירה.
אז ספירה ($ מערך); $ אני + +)
בואו רק הדפסה (מערך [i $] $);
שים לב: לא מוגדר קיזוז: 2.
זה רק הולך להיכשל.
זו הסיבה ש, על פי רוב, אתה לא צריך לחזר על מערך כזה.
זה יכול להיות הגזמה, אבל אתה אף פעם לא צריך לחזר על מערך כזה
כי PHP מספקת תחביר foreach foreach בה (מערך $ כפריט $).
עכשיו, אם להדפיס ($ פריט); - להכין מלדון בו בשנייה - זה עובד בסדר גמור.
האופן שבו הוא עובד foreach הוא הנימוק הראשון הוא המערך שאתה iterating נגמר.
והטענה השנייה, הפריט, דרך כל מעבר של ללולאה
זה הולך לקחת על הדבר הבא במערך. אז לזכור את המערך יש סדר.
הפעם הראשונה דרך ללולאה, הפריט הולכת להיות 123
ואז זה יהיה 12 אז זה יהיה 13 אז זה יהיה 23 ואז זה יהיה 213.
דברים מקבלים ממש מוזרים כשאתה עושה משהו כמו foreach.
בואו לראות מה קורה, כי אתה אף פעם לא צריך לעשות את זה.
מה אם אנחנו unset (מערך [1] $);
זה כנראה היה צפוי.
אתה iterating על מערך זה, ובכל פעם שאתה unsetting המדד הראשון.
אז למדד 0, הדבר, הפריט הראשון לוקח על ערך 0, אז זה הולך להיות 123.
אבל בתוך הלולאה עבורנו מטלטלת 1 מדד, כך אומר 12 נעלמו.
אז להדפיס. PHP_EOL.
PHP_EOL הוא רק שורה חדשה, אבל מהבחינה טכנית זה יותר ניידת
מאז השורה חדשה ב-Windows שונה משורה החדשה ב-Mac ו-UNIX.
ב-Windows הוא שורה חדשה \ r \ n, ואילו בכל מקום אחר שהוא נוטה להיות רק \ n.
PHP_EOL מוגדר כך שהוא משתמש בכל מה שהשורה החדשה של המערכת שלך.
אז לפרסם את זה. בואו לא print_r ($ מערך) בסוף.
לא היה לי מושג שזה יהיה ההתנהגות.
הפריט עדיין מקבל את הערך 12 למרות שאנחנו unset 12 עוד לפני שהגענו אליו מהמערך.
אל תיקח את המילה שלי על זה, אבל זה נראה כמו foreach יוצר עותק של המערך
ולאחר מכן הפריט לוקח על כל הערכים שלו עותק.
אז גם אם אתה משנה את המערך פנימי ללולאה,
זה לא אכפת לי. פריט ייקח על הערכים המקוריים.
בואו ננסה unsetting.
מה אם זה מערך $ [1] = "שלום";
למרות שאנחנו "שלום" הכנסנו לתוך המערך, הפריט לא לוקח על ערך זה.
יש תחביר אחר לforeach לולאות
איפה אתה שם 2 משתנה מופרד על ידי חץ.
המשתנה ראשון זה הולך להיות המפתח של ערך זה,
משתנה שני וזה הולך להיות אותו הפריט המדויק.
זה לא מעניין פה, אבל אם יחזור למקרה המקורי שלנו של '' -> 1,
'ב' -> 1,
כאן אם רק לחזר לכל מערך כפריט, הפריט הולך להיות 1 בכל פעם אחת.
אבל אם אנחנו רוצים גם לדעת המפתח מקושר לפריט
אז אנחנו עושים מקש ש$ -> פריט $.
אז עכשיו אנחנו יכולים לעשות הדפסת מפתח ($. ':'.
עכשיו זה iterating מעל והדפסה על כל מקש והערך הקשור שלה.
>> דבר נוסף שאנו יכולים לעשות בלולאות foreach הוא שאתה יכול לראות תחביר זה.
אמפרסנד לפני שמות משתנים נוטה להיות איך עושה הפניות PHP.
איפה הפניות דומות מאוד למצביעים,
אין לך מצביעים, כך שלעולם לא להתמודד עם זיכרון ישירות.
אבל יש לך הפניות שבו משתנה 1 מתייחסת לאותו הדבר כמו משתנה אחר.
בתוך כאן בואו לעשות $ פריט. בואו נחזור ל1, 10.
בואו לעשות $ פריט + +; זה עדיין קיים ב-PHP. אתה עדיין יכול לעשות + +.
php.test.php. אני צריך להדפיס אותו. print_r ($ array);
אנו מדפיסים 2, 11.
אם אני רק עשיתי foreach (מערך $ כפריט $) אז פריט יהיה הערך 1
בפעם הראשונה דרך הלולאה. זה יהיה להגדיל 1-2 וגמרנו.
ואז זה יהיה לעבור את המעבר השני של הלולאה ופריט שהוא 10.
זה פריט מרווחים עד 11, ולאחר מכן שפשוט נזרקו לפח.
אז אנחנו print_r ($ מערך), ובואו נראים שזה רק 1, 10.
אז התוספת שעשינו הייתה אבודה.
אבל foreach (מערך $ וכפריט $)
עכשיו סעיף זה את אותו הפריט שזכות זו כאן. זה אותו הדבר.
אז פריט $ + + הוא שינוי המערך 0.
בעיקרון, אתה יכול גם לעשות k $ - פריט> $ ואתה יכול לעשות $ מערך [יא $] + +;
>> אז דרך אחרת לעשות את זה, אנחנו חופשיים לשנות פריט,
אבל זה לא ישנה המערך המקורי שלנו.
אבל אם אנו משתמשים k, שהוא המפתח שלנו, אז אנחנו יכולים רק אינדקס לתוך המערך שלנו באמצעות שמפתח
ולהגדיל את זה.
זה יותר ישירות משנה המערך המקורי שלנו.
אתה אפילו יכול לעשות את זה, אם מסיבה כלשהי אתם רוצים את היכולת לשנות -
למעשה, זה הגיוני לגמרי.
אתה לא רוצה צריך לכתוב $ מערך [יא $] + +,
אתה רק רצית לכתוב $ פריט + +, אבל אתה עדיין רוצה להגיד אם (k $ === '")
אז להגדיל פריט ולאחר מכן להדפיס את המערך שלנו.
אז עכשיו מה אנחנו מצפים print_r לעשות? מה ערכים צריכים להיות מודפס?
[תלמיד] 2 ו 10. >> [אודן] רק אם המפתח היה '' נעשינו בפועל לפרסם את זה.
>> אתה כנראה מאוד נדיר, אם בכלל, יש צורך להגדיר פונקציות ב-PHP,
אבל אתה יכול לראות משהו דומה שבו אתה מגדיר בפונקציה כמו כל פונקציה.
בדרך כלל היית אומר (foo $, $ ברים) ולאחר מכן להגדיר את זה כדי להיות כל דבר אחר.
אבל אם אני עושה את זה, אז זה אומר שכל מה שקורא מה,
כל מה שקורא באז, ולכן הטיעון הראשון עבר לבאז יכול להיות שונים.
בואו נעשה foo $ + +;
ובתוך מכאן בואו נעשה את באז ($ פריט);
עכשיו אנחנו קוראים לפונקציה.
הוויכוח הוא נלקח על ידי הפניה, מה שאומר שאם לשנות אותו
אנחנו משנים את הדבר שעבר בו
והדפסה זו אנו מצפים - אלא אם כן אני פשלתי תחביר - יש לנו 2, 11,
אז זה בעצם מוגדל.
שימו לב שאנחנו צריכים הפניות ב2 מקומות.
מה אם עשיתי את זה? מה זה אומר?
[תלמיד] זה ישתנה. >> כן.
פריט הוא פשוט העתק של הערך במערך.
אז הפריט ישתנה ל 2, אבל המערך [''] עדיין יהיה 1.
או מה אם אני עושה את זה?
עכשיו פריט נשלח כהעתק לבאז.
אז העותק של הוויכוח יהיה מוגדל ל 2,
אבל הפריט עצמו מעולם לא מוגדל ל 2.
והפריט הוא אותו הדבר כמו סוגר מערך מה,
כך שהמערך היה מעולם מוגדל.
אז שני המקומות האלה צריכים את זה.
>> PHP היא בדרך כלל די חכמה בעניין הזה.
אתם אולי חושבים שאני רוצה להעביר על ידי התייחסות -
זו הייתה למעשה שאלה על אחד psets.
זה היה דבר questions.txt בו אמר,
למה אולי אתה רוצה לעבור struct זה על דרך הפניה?
מה הייתה תשובה לזה?
[תלמיד] אז אתה לא צריך להעתיק משהו גדול. >> כן.
Struct יכול להיות גדול באופן שרירותי, וכשאתה עובר בstruct כטיעון
זה צריך להעתיק את זה כל struct להעביר אותו לפונקציה,
בעוד שאם רק תעבור struct על ידי התייחסות
אז זה פשוט צריך להעתיק את כתובת 4-ייט כטיעון לפונקציה.
PHP היא קצת יותר חכמה מזה.
אם לי איזה תפקיד ואני עובר אליו מערך של 1000 דברים,
זה אומר שהוא יצטרך להעתיק את כל הדברים האלה של 1000
כדי להעביר אותו לפונקציה? זה לא חייב לעשות את זה מייד.
אם בתוך פונקציה זה לא באמת משנה foo,
כך שאם (foo $ === 'שלום') ההחזר אמיתי.
שים לב שאנו לא שונים בתוך הטיעון של פונקציה זו למעשה,
מה שאומר שכל מה שעבר כבfoo לא צריך להיות מועתק
כי זה לא משנה אותו.
אז דרך PHP עבודות הן הטיעונים תמיד מועברת על ידי הפניה
עד שאתה בעצם מנסה לשנות אותו.
עכשיו, אם אני אומר foo $ + +, זה יהיה עכשיו ליצור עותק של foo המקורי ולשנות את העותק.
זה חוסך קצת זמן.
אם אתה לא נוגע במגוון העצום הזה, אתה אף פעם לא באמת לשנות אותו,
זה לא צריך להפוך את העותק,
בעוד שאם אנחנו פשוט לשים אמפרסנד זה שאומר שזה אפילו לא להעתיק אותו
גם אם תשנה אותו.
התנהגות זו נקראת העתקה בעת כתיבה.
אתה תראה את זה במקומות אחרים, במיוחד אם אתה לוקח כמובן מערכת הפעלה.
העתקה בעת כתיבה היא דפוס די רגיל שבו אתה לא צריך ליצור עותק של משהו
אלא אם כן זה באמת משתנה. כן.
[תלמיד] מה אם היה לך את התוספת בתוך הבדיקה,
כך שרק האלמנט 1 מתוך 1000 היינו צריך להיות שונה?
אני לא בטוח.
אני חושב שזה יהיה להעתיק את כל הדבר הזה, אבל זה אפשרי זה מספיק חכם ש--
למעשה, מה שאני חושב שהיינו לנו הוא לדמיין את מערך שנראה כך: array2 $ = [
אז '' המדד הוא מערך של [1 2 3 4] 'ב', ומדד הוא מערך של כל דבר.
אני צריך פסיקים בין כל אלה. תאר לעצמכם שיש פסיקים.
אז 'ג'הוא 3 הערך.
אוקיי.
עכשיו אניח שאנחנו עושים באז $ (array2 $);
בי באז לא לקחת את זה על דרך הפניה.
אז $ foo ['ג'] + +;
זה כגון דוגמה שבה אנחנו עוברים array2 כטיעון
ואז זה שינוי מדד ספציפי של המערך ידי הגדלתו.
באמת שאין לי מושג מה PHP הוא הולך לעשות.
זה בקלות יכול ליצור עותק של כל הדבר, אבל אם זה חכם,
זה יהיה ליצור עותק של המפתחות הללו שבו זה יהיה הערך הייחודי שלו
אבל זה עדיין יכול להצביע לאותו המערך 1,2,3,4
וזה עדיין יכול להצביע לאותו המערך.
אני יהיה האייפד זה.
אנחנו עוברים במערך הזה שבו נקודתי הטיפוס הזה כדי 3, נקודתי הבחור הזה [1,2,3,4],
נקודתי הבחור הזה [34, ...]
עכשיו שאנחנו מעבירים אותו לאז, אנחנו משנים את זה.
אם PHP היא חכמה, הוא יכול פשוט לעשות -
היו לנו עדיין להעתיק כמה זיכרון, אבל אם היו subarrays המקונן העצום הללו
אנחנו לא צריכים להעתיק אותם.
אני לא יודע אם זה מה שהיא עושה, אבל אני יכול לדמיין אותו עושה את זה.
זהו גם יתרון די גדול של C מעל PHP.
>> PHP עושה את החיים הרבה יותר קלים להרבה דברים,
אבל אתה סוג של לי שום מושג כמה טוב זה יבצע
משום שאין לי מושג מתחת למכסת המנוע כשהוא יצירת עותקים אלה של דברים,
אה, אז זה הולך להיות עותק זמן קבוע,
האם זה רק הולך לשנות מצביע 1, זה הולך להיות עותק יניארי גיחוך קשה?
מה אם הוא לא יכול למצוא מקום?
האם זה אז צריך להפעיל את איסוף אשפה כדי לקבל קצת יותר מקום?
ואיסוף אשפה יכול לקחת שרירותי ארוך.
ב C אתה לא צריך לדאוג לדברים האלה.
כל שורה האחת אתה כותב שאתה יכול פחות או יותר סיבה על איך זה הולך לבצע.
>> הבה תביט לאחור באלה.
כמה נחמד זה שאתה לא צריך להתמודד עם פונקציות hash,
רשימות מקושרות, או משהו כזה?
מאז עבודה עם טבלאות hash היא כל כך קלה עכשיו, הנה חידת כיף לעבוד עליו.
פתח את הקובץ בשם unique.php ובו לכתוב תכנית PHP
(המכונה גם "סקריפט").
אנו נוטים לקרוא להם תסריטים אם הם דברים קצרים שאתה מפעיל בשורת הפקודה.
בעיקרון, כל שפה שאינך לקמפל אבל אתה הולך להפעיל את ההפעלה
בשורת הפקודה, אתה יכול לקרוא לזה תסריט הפעלה.
באותה מידה אני יכול לכתוב תכנית C שעושה את זה,
אבל אני לא קורא לזה תסריט מאז שהקומפילציה ראשונה ולאחר מכן להפעיל אותו בינארי.
אבל תכנית PHP זה אנחנו הולכים לקרוא את תסריט.
או אם כתבנו אותו בPython או Perl או Node.js או כל אחד מהדברים האלה,
היינו קורא להם כל התסריטים בגלל שאתה מריץ אותם בשורת הפקודה
אבל אנחנו לא לקמפל אותם.
אנחנו יכולים לעשות את זה די מהר.
אנחנו לא הולכים להשתמש argv. בואו פשוט לפוצץ את זה.
תקראו לזה ייחודי, כתיבת תכנית.
אתה יכול להניח שהקלט יכיל מילה אחת בכל שורה.
למעשה, argv יהיה די טריוויאלית לשימוש.
unique.php.
דבר הראשון ראשון, אנחנו רוצים לבדוק אם יש לנו כבר עברנו 1 טיעון של שורת פקודה.
בדיוק כמו שהיית מצפה וargv argc ב-C, עדיין יש לנו אלה ב-PHP.
אז אם (תכנית + $! == 2) אז אני לא אעסוק בהדפסת הודעה או משהו.
אני רק יוצא, קוד שגיאה של 1.
גם אני יכול לחזור 1.
לעיתים נדיר ב-PHP אתה במצב הזה שבו אנחנו ב--
בדרך כלל אתה נמצא בפונקציה שנקראת על ידי פונקציה שנקראת על ידי פונקציה שנקראת על ידי פונקציה.
ואם משהו משתבש ואתה רק רוצה לצאת מכל מה שלחלוטין,
יציאה פשוט נגמרת התכנית.
זו קיימת גם בג
אם אתה בתפקיד בפונקציה בפונקציה בפונקציה
ואתה רוצה רק להרוג את התכנית, אתה יכול לקרוא ליציאה וזה יהיה פשוט לצאת.
אבל ב-PHP שזה אפילו יותר נדיר, כי אנו נמצאים ברמה העליונה זו.
בדרך כלל אנחנו נמצאים בתוך איזה פונקציה, ולכן אנחנו קוראים ליציאה
כך שאין לנו כדי להחזיר את הדבר 1 שאז מבין שיש שגיאה
כדי שיחזיר את אם שמכיר הייתה שגיאה.
אנחנו לא רוצים להתעסק בזה, כל כך לצאת (1);
תמורה (1), במקרה זה תהיה שווה.
>> אז מה שאנחנו רוצים לפתוח אנחנו רוצים fopen.
הטיעונים הולכים להסתכל די דומה.
אנחנו רוצים fopen ($ argv [1], ואנחנו רוצים לפתוח אותו לקריאה.
המחזיר את משאבים שאנחנו הולכים לקרוא ו.
זה נראה די דומה לאופן שC עושה את זה, אלא רק שלא צריך לומר * קובץ.
במקום שאנחנו פשוט אומרים f $. אוקיי.
למעשה, אני חושב שזה אפילו נותן לנו רמז לפונקצית PHP בשם קובץ. קובץ PHP.
מה זה הולך לעשות הוא לקרוא את כל קובץ לתוך מערך.
אתה אפילו לא צריך fopen זה. זה הולך לעשות את זה בשבילך.
אז קווי $ = קובץ ($ argv [1]);
עכשיו כל הקווים של הקובץ הם בקווים. עכשיו אנחנו רוצים לסדר את השורות.
איך אנחנו יכולים למיין את הקווים?
אנחנו נמיין את הקווים.
ועכשיו אנחנו יכולים להדפיס אותם או משהו כזה.
כנראה הדרך הקלה ביותר היא foreach ($ שורות כמו $ קו) מהדהדים $ קו;
[תלמיד] לא היית אפילו לחצות קווים על ידי התייחסות למשהו כזה?
זה המקום בו היה מוגדר כמין סוג הפונקציה (ומערך $).
כשאתה קורא לפונקציה שלא תעבור אותו על דרך הפניה.
זה הפונקציה שמגדירה אותו כלוקח את זה כנקודת התייחסות.
זהו למעשה מה בדיוק השתבשתי
כאשר אנחנו שמים את הכל לשרתים שלנו כשנכנסנו 5.3-5.4.
עד 5.4, זה היה הגיוני לגמרי.
פונקציה לא מצפה לקחת את זה כנקודת התייחסות, אבל אתה יכול להעביר אותו כנקודת התייחסות
כך שאם הפונקציה קורית כדי לשנות את זה, זה עדיין שונה.
כשל 5.4, אתה לא אמור לעשות את זה.
אז עכשיו הדרך היחידה שאתה עובר על ידי התייחסות היא אם הפונקציה עושה את זה באופן מפורש.
אם אתה לא רוצה אותו כדי לשנות את זה, אז אתה צריך לעשות עותק $ = $ קווים והעתק עובר.
אז עכשיו קווים יישמרו והעותק יהיה שונה.
php.unique.php. אולי הייתי פשלתי משהו.
'איכשהו' לא צפוי.
יש הולך להיות משהו שעושה את זה בשבילנו.
זה אפילו לא שם.
שים לב, כאשר אתה קורא את המדריך שהטענה הראשונה צפויה להיות מערך
וזה נלקח על ידי הפניה.
למה זה אליי בטענות? כי יש לי סוג פונקציה זו עדיין כאן כי אני לא רוצה.
אוקיי, php.unique.php. אני לא עברתי אותו טיעון, כי אין לי קובץ.
זה php.unique.php על test.php.
הנה test.php הדפיס בכל סדר מיון נחמד.
שימו לב שסדר מיון הוא קצת מוזר לקובץ קוד
מכיוון שכל השורות הריקות שלנו הולכים למקום ראשון
אז תתחילו לבוא כל 1 החריצים ברמה שלנו
אז לבוא כל החריצים לא שלנו.
כן. >> [תלמיד] אז לקוד המקור שלא עבר התייחסות?
האם שעבר בדרך כלל על ידי ערך?
[אודן] כשאתה קורא לפונקציה, זה לא קובע אם זה הועבר על ידי הפניה.
זה הגדרת הפונקציה שקובעת אם זה הועבר על ידי הפניה.
ומסתכל על הגדרת הפונקציה של מיון או פשוט מסתכל על זה,
זה לוקח את הוויכוח על דרך הפניה.
אז בין אם אתה רוצה שזה ייקח את זה על ידי הפניה, זה לוקח את זה על דרך הפניה.
זה משנה את המערך במקום.
זה פשוט לא מותר. אסור לך לעשות את זה. >> [תלמיד] אה, בסדר.
[אודן] זה, סוג הולך לקחת קווים על ידי הפניה ולשנות אותו.
ושוב, אם אתה לא רוצה את זה כדי לעשות את זה, אתה יכול ליצור עותק של מיון.
גם במקרה זה, העתק אינו למעשה העתק של קווים.
זה פשוט מצביע על אותו הדבר עד שהוא מקבל 1 שונה,
איפה זה הולך ראשון שמקבל שונה בפונקצית המיון,
שם, כי זה של העתקה בעת כתיבה, עכשיו עותק של עותק הולך להתבצע.
אתה יכול גם לעשות את זה. זה המקום האחר אתה יכול לראות אמפרסנד.
אתה רואה את זה בלולאות foreach, אתה רואה את זה בהצהרות פונקציות,
ואתה רואה את זה כשרק הקצאה משתנית.
עכשיו יש לנו להשיג דבר על ידי עושה את זה
בגלל העתקה וקווים ממש אותו הדבר.
ניתן להשתמש בקווים ולהעתיק לסירוגין.
אתה יכול לעשות unset (עותק $), ושאינו קווים מוגדרים,
אתה פשוט מאבד את ההתייחסות שלך לאותו הדבר.
אז כמו בשלב זה, עכשיו קווים הוא הדרך היחידה שאתה יכול לגשת לקווים.
>> שאלות?
כן.
[תלמיד] לחלוטין מן הנושא, אבל אין לך לסגור את PHP - >> אתם לא צריכים.
אוקיי.
[אודן] הייתי מרחיק לכת ולומר שזה מעשה רע כדי לסגור אותם.
זה כנראה הגזמה, במיוחד בתסריט,
אבל בואו נראה מה קורה אם אני עושה את זה.
שלא עשה דבר. מה אם אני רוצה - [נאנח]
אני צריך לעבור ויכוח.
לירות. קראתי את זה לא נכון.
אז php.unique.php עם טיעון.
עכשיו אני אפילו לא צריך את זה.
אני אעביר את זה טיעון תקף.
זה כל מה שזה מודפס בהדפסה.
אני מדפיס עותק ועותק לא קיים. אז קווים.
הוא הדפיס את הכל, ואז הבחין בכל הזבל הזה כאן למטה,
כי בכל דבר PHP שהוא מחוץ לתגי PHP
פשוט הולך להיות מודפסים, פשוטו כמשמעו.
לכן ה-HTML, זה כל כך נחמד שאני יכול לעשות div בלה, בלה, בלה כיתה או משהו כזה,
בלה, בלה, בלה ולאחר מכן לעשות קצת קוד PHP ואז לעשות div הסוף.
ועכשיו אני מקבל את זה מדפיס div הנחמד שלי למעלה, כל מה שPHP המודפס, div בתחתית.
אסון כשמשהו כזה קורה, וזה די נפוץ,
רק שורה חדשה תועה בתחתית קובץ.
אתה לא חושב שזה יהיה כל כך גדול של עסקה
עד שאתה מחשיב את העובדה כי עם דפדפנים -
>> איך מפנה עבודה או בעצם כל עבודת כותרות,
כשאתה עושה את החיבור שלך לאתר והוא שולח בחזרה את כל הכותרות והדברים האלה
כמו תגובה 200 או להפנות תגובה או כל דבר אחר,
הכותרות תקפות רק עד לבית הראשון של נתונים נשלחים.
אתה יכול להפנות אותו אלף פעמים, אבל ברגע שהבית הראשון של נתונים נשלחים
אתה לא אמור להפנות שוב.
>> אם יש לך שורה חדשה תועה בתחתית קובץ
ונניח שאתה משתמש בפונקציה זו, ואז אתה רוצה -
בואו נגיד שזה קובץ אחר זה index.php ואתה require_once משהו -
אני לא יכול לחשוב על דוגמה טובה לזה.
הבעיה מתרחשת כאשר קו זה בתחתית מקבל הדהד.
אתה לא רוצה שום דבר כבר הדהד עדיין.
למרות שאתה לא מתכוון על כל דבר מקבל הד, משהו אכן מקבל הדהד
ואז עכשיו אתה לא אמור לשלוח כל עוד כותרות
ואתה הולך לקבל תלונות.
אתה פשוט לא צריך תגיות סגירה אלה.
אם אתה מתכנן לעשות משהו עם HTML -
וזה לגמרי סביר לעשות כאן מה div
ואז בשלב הזה אתה יכול או אינך יכול לכלול אותן.
זה לא ממש משנה.
אבל בהסקריפטים PHP זה נדיר כדי לסגור אותו.
כשהכל זה PHP, ממש הכול,
אתה לא באמת צריך לסגור אותו / אתה לא צריך לסגור אותו.
>> התמודדות עם מחרוזות היא הרבה יותר נחמדה מאשר בג
ב PHP ניתן לציין מחרוזת עם מרכאות בודדות או כפולות.
עם מרכאות בודדות אתה לא יכול להשתמש רצפים "בריחה".
כל זמן לברוח, בלה, בלה, בלה.
אז printf הוא נדיר מאוד ב-PHP.
אני מניח שהייתי משתמש printf אם אני רוצה לעשות דברים כאלה - בpset 5 השתמשת sprintf או משהו כזה.
אבל אתה רוצה לעשות ו001.jpg 002.jpg.
אז בשביל זה סוג הדברים שאני באמת רוצה לעצב את הטקסט הייתי משתמש printf.
אבל חוץ מזה הייתי פשוט להשתמש בחיבור מחרוזות.
אני לא באמת משתמש printf.
אנחנו רק מבדילים את הפרטים בין גרשיים בודדים ומרכאות כפולות.
ההבדל הגדול ביותר הוא שגרשיים בודדים, שהוא יודפס באופן מילולי.
אין סוג הנתונים char ב-PHP, בניגוד C, אז זה שווה את זה.
הם שתי המחרוזות.
והדבר נחמד על מייתרי ציטוט יחידים הוא שאני יכול לומר "שלום העולם!" בלה, בלה, בלה,
wooo $ $.
מה קורה כאשר אני מדפיס את זה הוא שזה יהיה להדפיס אותו, פשוטו כמשמעו.
בואו להיפטר מכל הדברים שלנו.
אז הד str1 $;
הוא הדפיס את כל הדברים האלה, פשוטו כמשמעו: סימני דולר,
קו הנטוי n, שהיית חושב שיהיה שורה חדשה -
את כל הדברים האלה הוא מדפיס באופן מילולי.
הדבר היחיד שאתה צריך לברוח הם ציטוטים בודדים
כי אחר זה הייתי חושב שזה סוגר את הגרשיים הבודדים.
מרכאות כפולות, שונות לחלוטין.
אנחנו כבר רואים את הדגשת התחביר היא cluing על מה שעומד להשתבש לגמרי.
php.unique. לא מוגדר משתנה: wooo כי זה יפורש כמשתנה הנקראת wooo.
מרכאות כפולות מאפשרות לך להכניס את משתנים ל--
בואו נגיד את שם $ = "רוב";
אז הד "היי, השם שלי הוא שם $!";
היא מכירה בזה כמשתנה.
כאשר אני מפעיל את זה - ואני אוסיף שורה חדשה - היי, השם שלי הוא רוב! ושלום עולם!
זאת משום שמעולם לא הסירה את ההדפסה של wooo לעיל.
יש צעד נוסף שאתה יכול לעשות 1.
מערך $ = [1, 2, 3];
מה אם אני רוצה להדפיס את האינדקס הראשון של מערך?
אתה עושה מערך $ [0].
את הדגשת התחביר היא רמז. מה זה יעשה?
php.unique.
היי, השם שלי הוא 1! וזה לא מה שרציתי.
הדגשת תחביר שייקרה לי.
בואו ננסה '"-> 1,' ב '-> 2.
ככה הייתי צריך לכתוב את זה.
ציטוט אחד בלתי צפוי (T_ENCAPSED בלה, בלה, בלה, בלה, בלה).
הרעיון הוא שזה לא מזהה את זה כחלק מהמערך.
זה לא הכרה בכך מערך אינדקס של מכתב.
אתה רוצה לעשות את זה מוקף בסוגריים מסולסלים,
ועכשיו כל מה שהוא בסד מתולתל זה יהיה אינטרפולציה,
שהמילה שאנחנו משתמשים להוספת קסם המשתנים הללו למקומות הנכונים.
עכשיו עושה את זה, php.unique, והיי, השם שלי הוא 1! כצפוי
או היי, השם שלי הוא רוב!
דבר אחד שהוא סוג של נחמד על גרש יחיד הוא ש--
יש כמה עלות לביון.
אם אתה משתמש במרכאות כפולות, המתורגמן יש לעבור על מחרוזת זו,
לוודא כי, "הו, הנה משתנה. עכשיו אני צריך ללכת להביא את המשתנה ושלהכניס אותו לכאן."
גם אם אתה לא משתמש בכל משתנים,
דבר בתוך המרכאות הכפולות הללו צריך להיות אינטרפולציה,
אבל זה עדיין יהיה איטי יותר משום שהוא צריך ללכת על המרכאות הכפולות
מחפש דברים שצריכים אינטרפולציה.
ציטוטים בודדים אז יכולים להיות קצת יותר מהר אם דבר צריך להיות באינטרפולציה,
ואני נוטה גם להשתמש בגרש יחיד ל, "היי, קורא לי '. מערך $ [''] בכל מקרה.
זה הולך להיות שווה ערך למה שהיינו לפני.
אבל זה עניין של העדפה.
אם אתה משתמש ב-PHP, אתה כנראה לא אכפת לי הבדל במהירות.
אין מספיק לחשוב בהיגיון אותם מלכתחילה.
>> איזה שאלות?
>> אנחנו למעשה אפילו לא לעבור את כל זה, אבל הדבר הזה היה משעמם.
הדבר האחרון שדי נחמד בPHP הוא כאשר אתה מתעסק עם HTML,
תוכל להשתמש בו קצת, ולכן תחביר הקיצור הנחמד להדפסה משתנית.
בלי לשים PHP כאן, זה נקרא תגים קצרים.
באופן רשמי כשל PHP 5.4, זו כבר אינה בתוקף.
אתה מומלץ לשים PHP.
זה עדיין נתמך, תגים כל כך קצרים עם <? = הם עדיין בסדר גמורים.
זה נתמך כברירת המחדל, כך שאתה יכול להשתמש באלו כרצונך, והם די נוחים.
>> יש שאלות?
בסדר.
>> הישאר קלאסה, סן דייגו.
[מגחך]
ביי. [צוחק]
[מחיאות כפות] [צוחק]
>> [CS50.TV]