====== התחלת עבודה עם PHP ======
== ברק בלוך ==

^ היסטוריית גירסאות ^^^
^ גירסה 1.0 ^ 15-04-2007 ^ **כתריאל טראום**  ^ 
| הומר לפורמט ויקי |||
^ גירסה 1.0 ^ 10-02-2003 ^ **ברק בלוך** ^
| גירסה ראשונה |||

==== זכויות יוצרים ורשיון ====
כל הזכויות שמורות (c) 2007, **ברק בלוך**, הרשות ניתנת להעתיק, לשנות ולהפיץ מדריך זה תחת התנאים של רשיון ה-GFDL \\
Linux הוא סימן מסחרי רשום של Linus Torvalds.

==== הסרת אחריות ====
הכותב אינו נושא באחריות עבור שימוש ברעיונות, דוגמאות ומידע שבמדריך. השימוש הוא באחריות הקורא בלבד. המדריך עשוי להחיל טעויות ופרטים לא נכונים, שהשימוש בהם עשוי להיות מזיק למחשבך. למרות הסבירות הנמוכה, הכותב אינו לוקח כל אחריות

==== מבוא ====
מדריך זה נועד לשמש כמבוא לשימוש ב PHP. לא נדרשת היכרות עם PHP, אך היכרות עם שפות סקריפט / תכנות אחרות, רצויה בהחלט. \\
כמו כן ידע סביר ב HTML היכרחי.

===== לפני הכל =====
=== מטרת המדריך ===
מדריך זה, ינסה לעזור לך, להכנס לעולם של PHP בקלות ובמהירות. \\
המדריך לא מתיימר להיות מדריך מעמיק לנושא של PHP אלא רק לשמש כמבוא, ולתת לך לטעום משפת סקריפט טובה זאת, כדי שתוכל להחליט במהירות האם שפה זאת רלוונטית עבורך. \\
המדריך יכסה בקצרה את מכלול הנושאים, כולל שלבי ההתקנה, כשביסומו אני מאמין שיהיו בידך ידע שימושי בהחלט ב PHP !

=== מה זה PHP ? ===
PHP היא שפת סקריפט. ר"ת של המונח PHP הם: PHP Hypertext Preprocessor \\
התחביר של PHP מבוסס על c / java / perl והוא קל מאוד לשימוש ולימוד. השפה היא שפה המשולבת בעמודי HTML (דומה מאוד ל ASP ו JSP) ולכן היא נוחה מאוד לשימוש בעמודי WEB ליצירת אתרי אינטרנט דינמיים. כשאנחנו אומרים ש PHP מתאימה לבניית עמודי אינטרנט דינמיים, אנחנו מתכוונים לכך שהשימוש ב PHP נעשה בצד השרת, כלומר בשרת המארח יש מערכת PHP) ובעזרת PHP אפשר להוסיף לעמודי ה HTML שלנו יכולות מגוונות, כגון:
  * פניה והוספת תכנים היישר ממסד הנתונים
  * בניית מערכת ניהול תוכן שלמה
  * הוספת מונים
  * הרצת יישומים על השרת בעזרת PHP ועוד דברים מגוונים רבים אחרים, כשהכל נעשה בצד השרת.

הלקוח מקבל את העמוד HTML אחרי ש PHP עיבדה אותו (לעיתים השרת ייצור בעזרת PHP גם תמונות, למשל גרפים, או עמודי PDF וכו', הכל בזמן אמת, לפי דרישת הלקוח ובצורה דינמית). \\
לסיכום: אתר אינטרנט רציני, בד"כ ידרש לשפה כלשהי שתעבד את העמודים עוד בצד השרת, כדי להתאים את התכנים בהתאם לגולש, ולאפשר לו אינטראקטיביות (השארת תגובות למשל), ובמקרים כאלה, PHP היא אפשרות מאוד מעניינת. עוד נציין כי ל PHP יכולות מעולות גם בתחום של שפת סקריפט ב SHELL (מונח שמוכר בעיקר לאנשי היוניקס שביננו).

אם נרצה להסביר את זה יותר לעומק, נאמר שיש ל PHP חיים גם מחוץ ל server וניתן להריץ באמצעותה סקריפטים שימושיים מאוד (להתקנת תוכנות, לקינפוג מערכות ולכל מטרה אחרת שדורשת סקריפט).

=== קניית / השגת PHP ===
PHP אינה עולה כסף ! \\
זה נראה מוזר לעיתים, שמוצר איכותי, שנמצא במיליוני מחשבים בעולם, ובשימוש חברות מסחריות מובילות, אינו עולה כסף. אבל PHP בדומה למוצרים אחרים שקשורים בקשר הדוק לעולם היוניקס (ובעיקר בעולם הלינוקס), זמינה בחינם, כולל קוד המקור (שזה בד"כ סוד שמור של חברות רבות בעולם הקוד הסגור).

כדי להבין את הסיבות לכך, יש להכנס לתחומים שהם מחוץ למסגרת מדריך זה, רק נאמר שבכללית מודל הקוד הפתוח מאפשר לתת ללקוח את החופש (לשנות ולצפות בקוד המקור) ולחברה המפתחת את היכולת לקבל פיתוח מהיר, כשאלפי עיניים בוחנות ומסייעות בשיפור הקוד, בעלויות נמוכות יחסית. כדי שפרוייקטים כמו PHP גם ישתלמו כלכלית, במקרים רבים במקביל אליהם, ישנם פרוייקטים מסחריים, כדוגמאת ZEND הישראלית, שהיא חברה מסחרית בבעלות של שני ישראלים אשר משמשים גם כמפתחים הראשיים של פרוייקט PHP. כדי לדעת יותר על תנאי הרשיון של PHP אפשר להכנס לכתובת http://php.net/license

כדי להשיג את PHP צריך להוריד את קוד המקור, או את החבילות הבינאריות (המוכנות לשימוש, צריך לבחור בחבילה המתאימה למערכת ההפעלה שברשותינו) מהאתר של PHP, הכתובת הישירה לעמוד ההורדות היא http://www.php.net/downloads.php

**זכור**: שימוש בקוד המקור ידרוש ממך קצת יותר עבודה, וכן דורש שיהיו ברשותך הכלים המתאימים (קומפיילר עם הספריות הדרושות להידור PHP) אבל יאפשר לך גמישות רבה יותר בשימוש. לעומת זאת שימוש בבינאריים המוכנים יאפשר לך להתקין את PHP בקלות רבה יותר, במהירות רבה. אנחנו ממליצים להשתמש במכונת יוניקס/לינוקס לשימוש ב PHP, שכן שפה זו נועדה במקור ליוניקס לסוגיו.

אם ברשותך מערכת לינוקס, בהפצות רבות (למשל [[http://www.red-hat.com|ראד האט]] / [[http://www.linux-mandrake.com|מנדריבה]] / סלאקוואר) יש חבילות מוכנות עם ההפצה לשימוש ב PHP כמודול בשרת ה WEB אפצ'י וכן לשימוש ב PHP כ "מפרש פקודות" עצמאי (שאינו תלוי בשרת זה או אחר).

=== מודול או כ CGI ? ===
PHP זמינה הן כמודול לשרת ואין כמפרש פקודות עצמאי. \\
במילים אחרות, אפשר להתקין את PHP כחלק מהשרת WEB (בתור מודול של השרת) או כמפרש פקודות עצמאי (למי שמכיר, אז השימוש דומה לשימוש בשפות סקריפט מסוגן של פייטון / פרל וכו'). השימוש כמודול בשרת ה WEB אמור להבטיח ביצועים טובים יותר, ואינטגרציה טובה עם שרת ה WEB. מצד שני יש מקרים שבהם רוצים להשתמש ב PHP כשפת SHELL רגילה, או שהשרת אינו תומך ב PHP, ובמקרים אלו ניתן להשתמש בה בצורה עצמאית, כלומר להפעיל אותה עצמאית.  כשנרצה לפנות אליה בשרת, נפעיל את עמודי ה PHP כ cgi.

====  PHP מול המתחרים ===
נהוג להשוות בין PHP לבין ASP אבל למעשה יש עוד מספר אפשרויות, כגון JSP. \\
ל PHP מספר ייתרונות, למשל היותה חינמית וחופשית (קוד פתוח), מה שמבטיח את כל היתרונות של עולם הקוד הפתוח. כמו כן יתרון גדול נוסף של PHP היא היותה מערכת "Cross platform" או בעברית פשוטה, מערכת שרצה על מגוון נרחב של פלטפורמות (שרתי יוניקס, לינוקס, mac, חלונות על גרסאותיה וכו'). ייתרון זה הוא מהותי, שכן אם נשווה ל ASP שרץ בצורה טבעית רק על חלונות, נבין מה היתרון הגדול: אין מכריחים את המשתמש לעבוד עם פלטפורמה מסויימת.

אם נבנה אתר גדול ב ASP ומחר נרצה לעבור לפלטפורמת יוניקס, מסיבות כאלה ואחרות (עלות, אבטחה או סיבות אחרות), נהיה בבעיה, ומהעבר יהיה "כואב".  לו בחרנו ב PHP אנחנו איננו כבולים לפלטפורמה זו או אחרת. עוד יתרונות שיש ל PHP היא הקהילה הגדולה והמגובשת, של המשתמשים, ואפשר למצוא בשפע אתרים בנושא, קודים של כל דבר שרק נרצה - מערכות פורום שלמות, מערכות שלמות לניהול פורטלים וכו', והכל בסוגי רישוי שונים, רק לבחור מה רוצים ולהמשיך הלאה. 

כמובן שהיותה של PHP בקוד פתוח, מאפשר לנו, להתאים את קוד המקור לדרישתנו (במידה ויש לנו את הידע הטכני הדרוש, בתכנות בשפת C שהיא השפה בא כתובה PHP). כמובן שישנם גם חסרונות, אם למשל ברשותנו שרת IIS אז ה ASP כבר בפנים, לעומת זאת, את PHP נאלץ להתקין (לא מסובך מדי בכל מקרה...). ל JSP את היתרונות שלה (יש מבחנים שמדברים על ביצועים טובים יותר יחסית למתחרים), אלא שההתקנה והשימוש מסובכים יחסית (מדובר בשפת java  אם זה לא ברור). כמו כן אסור לשכוח שבשוק עדיין נהוג להשתמש לעיתים ב CGI תוך שימוש בשפות סקריפט מהסוג של פרל, מדובר באפשרות סבירה, אך בעיות הביצועים של CGI בנוסף לסירבול היחסי, גורמים ל CGI אט אט להעלם מהשטח, ולפנות את מקומו למודולים שרצים בשרת, בדומה ל PHP שהם נוחות יותר לפיתוח ובעלות ביצועים טובים יותר.

=== התקנת PHP בלינוקס ===
ישנן מספר דרכים להתקין את PHP במערכת הלינוקס. הדרך הפשוטה והמהירה ביותר, ואשר קיימת בהפצות המיינסטרים, מסוגן של [[http://www.red-hat.com|ראד האט]] , היא שימוש ב rpm / חבילה בינארית מוכנה. בד"כ, PHP כבר מותקן במערכת. כדי לבדוק את זה, במערכת [[http://www.red-hat.com|ראד האט]] או [[http://www.linux-mandrake.com|מנדריבה]] ניתן להריץ:
<code>
[barak@localhost barak]$ rpm -qa | grep php
php-4.1.2-7
[barak@localhost barak]$
</code>
בדוגמא אצלי, php מותקן (ישנן עוד חבילות שניתן להתקין, כדי לספק תמיכה בדברים אחרים, שעליהם ידובר בהמשך המדריך). במידה ולא היה מותקן אצלי php הייתי רוצה לבדוק אם מותקן בכלל שרת ה web אפצ'י:
<code>
[barak@localhost barak]$ rpm -qa | grep apache
apache-1.3.23-14
[barak@localhost barak]$
</code>
כמובן שאצלי השרת מותקן. במידה ואצלכם המצב שונה, זה הזמן להכניס את דיסק ההתקנה, ולהתקין את php ואת apache, מה rpm. אחרי ההתקנה, כל מה שנותר זה להשתמש במערכת. ראשית, יש להפעיל את שרת ה web:
<code>
su -
service httpd start
</code>
בדוגמא הנחתי שאתם משתמשים במשתמש רגיל (ולא root) . נכנסים כ root ומפעילים את אפצ'י. יש אפשרות לגרום ל אפצ'י לעלות עם המערכת לאחר האיתחול (כשירות). אפשר לנסות את :
<code>
ntsysv
</code>
שוב, כמשתמש root, ולסמן שם את httpd. אחרי שהאפצ'י עובד, צריך להכניס את עמודי ה php לשרת ה web. בד"כ המסמכים יישבו תחת
<code>
/var/www/html
</code>
והסיומת שלהם תהיה php . משתמשי מערכת הג'נטו גנו/לינוקס יכולים להתקין את PHP באופן הבא:
<code>
emerge mod_php
</code>
אם זה לא ברור, המערכת תתקין את PHP כמודול של שרת ה WEB (אפצ'י) ותפתור תלויות במידת הצורך.  אם בחרנו להתקין מקוד המקור, נצטרך לקמפל הן את האפצ'י והן את php ביחד. זו פעולה ארוכה והיא חורגת ממסגרת המדריך הזה. לעוד מידע, ניתן להציץ בקובץ INSTALL שבא עם קוד המקור של PHP.

כמו כן מידע על התקנה על שרתים שונים (במערכות הפעלה שונות, כולל לינוקס / יוניקס) אפשר לקבל בכתובת http://www.php.net/manual/en/installation.php

** הערה:** ברוב ההפצות מחלקים את php לכמה חבילות, כשישנן חבילות שנועדו לספק תמיכה בדברים מיוחדים, למשל תמיכה ב gd (ספריה גרפית ליצירת תמונות דינמיות, פיצ'ר מאוד מדליק אגב, בעזרת ה API הרלוונטי של php בנושא). כמו כן, לעיתים ה php מחולק לחבילה אחת של המודול וחבילה נפרדת להרצה של PHP כ"מפרש פקודות עצמי". היות ואנחנו רוצים להריץ את PHP דרך שרת ה WEB, הביצועים המייטבים הם בעזרת שימוש ב PHP כמודול של השרת, ולפיכך, נבחר בהתקנה של mod-php או איך שההפצה שלנו קוראת לחבילה של המודלים... (במקרים אחרים ישנה חבילה אחת בשם php שכוללת גם את המודול לשרת וגם את קובץ ההרצה העצמאי).

=== התקנת PHP בחלונות ===
"כבר שנים" שלא ייצא לי לבצע את התהליך הזה, אז רק אפנה אתכם למקורות רלוונטים: http://www.tldp.org/HOWTO/PHP-HOWTO-3.html#ss3.1 \\
וכמובן באתר הרשמי של PHP:  http://www.php.net/manual/en/installation.php

אבל תעשו לעצמכם טובה, גלו את האור, עברו ללינוקס, החיים שלכם יהיו קלים בהרבה.  אין מה לעשות לינוקס קלה ונוחה יותר לשימוש, לפחות כמשדובר בתחום של שרתים (בעיקר שרתי WEB)

==== שימוש ראשוני ב PHP ====

=== איך אני בודק שה php עובד ? ===
היות ומדריך זה מתמקד ב PHP כשפת תכנות לצד השרת (ולא כשפת SHELL) נבצע בדיקה בעזרת השרת ש PHP עובד כראוי. נבנה עמוד בשם test.php ובתוכו נכניס את הערכים הבאים:
<code>
<?php phpinfo(); ?>
</code>

את הקובץ, נשים בשרת, למשל ב apache במערכות לינוקס, זה בד"כ תחת: /var/www/html. \\
ניגש לעמוד בעזרת הדפדפן.  מה שעמוד זה עושה הוא פלט על המסך של המון מידע על השרת, על גרסאת ה PHP וכו'... השורה המעניינת היא שורה מס' 2 : שבה רשום phpinfo() . לכל מי שתיכנת בעבר בשפות כמו c יזהה שמדובר בהפעלת פונקציה בשם phpinfo.  פונקציה כהגדרה, היא קטע שקוד שמבצע מטלות כלשהן, כפי שמוגדר בגוף הפונקציה.

במקרה שלנו, ביצענו **קריאה ** לפונקציה בשם phpinfo.  פונקציה זו, ** מוגדרת** (כלומר אופן פעולתה מוגדר) בתוך php עצמה (בקוד מקור של php כפונקציה שמוציאה על המסך פלט של נתונים רבים אודות השרת.  אם על המסך נקבל פלט פשוט מהסוג:
<code>
phpinfo()
</code>
ברור שהשרת לא ידע לפנות לעמוד כעמוד php ויש לבדוק בהגדרות של השרת, שמוגדר לו לעבוד עם php בעמודים עם סיומת .php אם נקבל על המסך שגיאה מסוג 500 או הודעת שגיאה אחרת, יש לבדוק ש PHP הותקן כהלכה.

 **הערה: ** למי שלא יודע לעבוד עם השרת - הכניסה לעמודים של השרת מתבצעת על ידי כניסה לכתובת של השרת (בד"כ IP של השרת כשעושים בדיקה במערכת בייתית ממוצעת). אם למשל שמנו את test.php בתקיית ה ServerRoot של האפצ'י, בד"כ כמו שאמרתי /var/www/html אז כדי לבדוק את הסקריפט, מהמחשב המקומי ניתן להקליד ב URL של הדפדפן:
<code>
127.0.0.1/test.php
</code>
ה IP שמספרו 127.0.0.1 מתאר את localhost או השרת המקומי בעברית פשוטה. אם עובדים עם מחשב אחר ברשת מקומית / או ברשת אחרת, פשוט להקליד את ה IP או הכתובת דומיין שמוקצאת לשרת.

** הערה 2:** אם רוצים לבדוק שהשרת עובד, רוב השרתים נותנים הודעה שמבשרת שהשרת עובד, בעמוד הראשי של המערכת, כלומר בתגובה לכניסה אל הדומיין / IP של השרת.  לצורך העניין, אם נקליד בשורת URL של הדפדפדן:
<code>
127.0.0.1
</code>
מהמחשב המקומי שבו מריצים שרת WEB כלשהו, אנחנו אמורים לקבל את עמוד ברירת המחדל של השרת, בד"כ הודעה שאומרת שהמחשב מריץ שרת מסוג א', שהשרת הותקן בהצלחה, ואף הפניה לתיעוד של השרת...  אם לא מקבלים את העמוד של השרת, יש לבדוק שהשרת מאזין לפורט 80 (בד"כ זה המצב הרצוי) ושהוא רץ (במערכות לינוקס, האפצ'י שולח לוגים אל syslog.d, ככה שאפשר להציץ שם אם יש בעיות).

=== התוכנית הראשונה השימושית שלי ===
במדריך זה נדלג על התוכנית המסורתית של "שלום עולם" ובמקום זה, בגלל ש php כל כך פשוטה, נבנה תוכנית קצרה וחביבה, שכל מטרתה, לסייע לנו להפוך עברית.  אנחנו נשתמש בפונקציה hebrevc המובנית ב PHP למטרה זו, ונכתבה על ידי זאב סורסקי.  פונקציה זו נועדה לאפשר לבנות עמודים בעברית ויזואלית בצורה דינמית נוחה. בתוכנית זאת לא נתעכב על כל הפרטים, התוכנית נועדה לתת לנו תחושה על "איך עובדים עם PHP" אם לא הבנת פרטים מסויימים, אין טעם להתייאש ! \\
התוכנית הדגמה שלנו תראה ככה::
<code>
<?
// This is our first progrem: all we do is reverse the Hebrew
?>
<html>
<head>
<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso8859-8">
<title>Log-->Visual</title>
</head>
<body>
<div align=right>
<?
$text=$_POST["text"];
echo hebrevc($text,20);
?>
<form method=post action="">
<textarea name=text dir=rtl><?echo $text?></textarea>
<input type=submit>
</form>
</div>
</body>
</html>
</code>
הרץ את הדוגמא הנ"ל, ושחק מעט עם הפלט. עכשיו נסביר בקצרה מה קורה כאן (הדגש יהיה על צורת העבודה עם PHP כשפה משולבת HTML ולא הצורך להבין במדוייק את כלל התוכנית הקצרצרה הזו). ראשית, נסביר שה PHP בנויה כשפה משולבת ה HTML מה שאומר שאנחנו מכניסים קטעי PHP בתוך מסמך HTML רגיל. המודול של PHP יבצע עיבוד לקטעים שנמצאים בין <? ?> ויתעלם מהשאר, ולכן , כל מה שמחוץ לתגיות הנ"ל, יישלח לדפדפן כמו שהוא. במקרה שלנו, השורות הראשונות הן:

<code>
<?
// This is our first progrem: all we do is reverse the Hebrew
?> 
</code>

כלומר כבר בשורה הראשונה ה PHP מקבל הוראה לפרש את מה שכתוב, בשורה 2 ישנה הערה (בסגנון C++). המפרש של php מזהה שזו הערה על פי צמד התווים <nowiki>"//"</nowiki> שכשהם באים ברציפות מורים שהחל מהם ועד לסוף השורה, כל מה שיהיה זו הערה. הערה זהו קטע קוד שנועד לסייע למתכנת, או למישהו אחר שמציץ בקוד, להבין את הקוד, מעבר לזה אין לו שום משמעות, ומפרש הפקודות ממשיך הלאה בלי לעשות איתו כלום. שורה שלישית אומרת ל PHP להפסיק לפרש (ביינתים) את התוכן בהמשך. בשלב, זה מפרש הפקודות של PHP יתעלם מההמשך, אבל "יחכה" למפגש הבא עם <? , עד אז שרת ה WEB ישלח את תוכן ה HTML כמו שהוא, לדפדפן. הקטע הבא שמעניין אותנו הוא:
<code>
<?
$text=$_POST["text"];
echo hebrevc($text,20);
?> 
</code>
שוב, PHP מקבל את התגית שמורה לו לבדוק ולפרש את המשך התוכנית, שורה לאחר מכן אנחנו יוצרים משתנה בשם text$ שמקבל לתוכו את הערך של
<code>
$_POST["text"]
</code>

אנחנו לא נתעמק בשלב זה בהסבר רק נאמר שאנחנו למעשה מכניסים לתוך טקסט את הערך של משתנה מסוג post (זה סוג אחד מתוך שניים של משתנים שאפשר לקבל מתוך קלט של FORM (טופס HTML). שורה לאחר מכן אנחנו מציגים, בעזרת הפקודה echo את:
<code>
hebrevc($text,20)
</code>
מה שעשינו כאן זה השתמשתנו בפונקציה hebrevc כדי להפוך את הטקסט שהוכנס לתוך text$ . כמו כן, הפרמטר השני שהעברנו, 20, משמש אותנו כדי לשבור את השורות אחרי כל 20 אותיות. שבירת השורות היא א' ב' ב שימוש בעברית ויזואלית (אם לא נשבור את השורות, והם יישברו בגלל שנגמר המקום להצגתן בטבלה / בדפדפן, הם ייראה הפוכות). במקרה שלנו מדובר ב 20 תווים (במקרים רבים נותנים ערך גדול בהרבה). עוד שורה מעניינת היא השורה הבאה:
<code>
<textarea name=text dir=rtl><?echo $text?></textarea> 
</code>
בשורה הנ"ל יש חלק של PHP ו 2 חלקים ב HTML רגיל. ראשית מדובר בהצגה על המסך של textarea שהוא למעשה שדה טקסט רגיל בhtml. כידוע לנו, מה שבא בין התגיות:
<code>
<textarea></textarea> 
</code>
הוא הטקסט שיופיע בתוך התיבת טקסט. היות ולעיתים נרצה לשפר את התוכן של הטקסט, שכבר הפכנו, למשל להוסיף עוד אות או פחות אות (כדי למשל לבדוק את האיכות של hebrevc בהיפוך העברית) הוספנו את קטע ה php הבא:
<code>
<?echo $text?>
</code>
קטע זה פשוט מציג את $text שערכו לא השתנה מאז שהוא קיבל את : $HTTP_POST_VARS["text"]. יש לשים לב גם ל:
<code>
name=text
</code>
זה אומר שהמשתנה שיועבר אחרי submit של הטופס, הוא משתנה ששמו text. אם היה שם הערך hebrew נניח, אז:
<code>
$text=$_POST["text"]; 
</code>
לא היה עושה את העבודה, והיינו צריכים לרשום במקום::
<code>
$text=$_POST["hebrew"]; 
</code>

זה כל ה php שיש בתוכנית הבסיסית הזאת. בפרק הבא נדון בהרחבה בנושאים כמו: "מהם משתנים ב php" וכו', לעת עתה חשוב שהבנו את העיקרון, ואת הפשטות של שפת PHP. שום דבר מסעיר מדיי בתוכנית זאת, אבל בהחלט נקודת מוצא טובה, להבין את השפה, ואת הפשטות שלה.

 **הערה: ** אנחנו דנים בזה בהרחבה בהמשך, אבל מי שנבהל מהסימן ' $ ' אין מה להבהל. כל משתנה ב PHP מתחיל בתו הזה. מעבר לזה, אני בטוח שלא לכולם הכל ברור בשלב זה, זה בסדר, בהמשך הדברים יובהרו. התוכנית רק נועדה לתת קצת טעם של PHP !

==== תחביר משתנים ומה שמסביב ====
=== מה בפרק זה? ===
בפרק זה לא נדון בכתיבת תוכניות כלשהן בפועל, אלא רק בתחביר של השפה, והשימוש המעשי בו. \\  פרק זה אמור לתת את כל הכלים הדרושים על מנת להתחיל לתכנת לבד ככל העולה על רוחך בשפת PHP (תוך העזרות במדריך הרשמי, שבו יש רשימה מסודת של הפונקציות ב php ואיך משתמשים בהן, או בלשון העגה המקצועית, תיעוד של ה API של PHP). \\ \\ \\

=== התחביר הבסיסי של השפה ===
כמו שכבר הוסבר בפרק הקודם, השימוש ב - PHP מתבסס על השימוש בתגיות:
<code>
<? ?>
</code>
כלומר כל מה שבין תגיות אלו, הוא PHP וכל מה שמחוצה להן, מועבר לדפדפן (לקוח) מבלי שמפרש הפקודות של PHP מתערב. במקרים מסויימים, נרצה שהתגיות של PHP יהיו תגיות סטייל ASP כלומר: 
<code>
<% %>
</code>
במקרה כזה נאפשר את אופציה זאת ב php.ini. מה שצריך לעשות זה לשנות את השורה:
  asp_tags = Off
ל:
  asp_tags = on
הקובץ php.ini יושב בלינוקס בד"כ תחת הספריה etc/. אנחנו נחזור ונדבר קצת יותר על php.ini בהמשך המדריך.

חשוב להכיר מאפיין נוסף, שאפשר להתקל בו לעיתים בקוד מקור, והוא השימוש ב = להצגת מידע על המסך, למשל:
<code>
<;?=$text?>;
</code>
הדוגמא הנ"ל מבצע את אותה פעולה בדיוק כמו:
<code>
<?echo $text?>;
</code>
רק צורת הרישום בדוגמאות הנ"ל מעט שונה, למעשה זו דרך מקוצרת לרישום. כל אחד יכול לבחור בדרך שנוחה לו, לדעתי שימוש ב echo קריא ונעים יותר, אבל כל אחד כמובן מתכנת כמו שנוח לו.

=== משתנים ב PHP ===
כמו בשפות סקריפט רבות אחרות בעולם היוניקס, גם ב PHP שמות המשתנים מתחילות בתו '$'. משתנה הוא למעשה תו או רצף של תווים חוקיים (מה חוקי ומה לא בהמשך) שבאים בעקבות התו '$' ואשר מאכסנים בתוכם מספרים / תווים / מילים או כל תוכן אחר רצוי, כפי שנלמד בהמשך. \\
לא כל שם הינו חוקי, כשאפשר לאמר בכללי אצבע, שאין מגבלה (בפועל) של מספר התווים שירכיבו משתנה, זה יכול להיות משתנה בתו אחד, למשל: Z$ ועד עשרות תווים ויותר (אין טעם לתת שמות ארוכים מדי, מטעמי אסטטיקה של הקוד). המשתנה חייב להתחיל באות לועזית (קטנה או גדולה, זה לא משנה). כמו כן רק תווים לועזיים או מספרים יכולים להיות חלק מהתו (כל תו אחר, למשל אותיות עבריות, איו חוקי). ניתן דוגמאות למשתנים חוקיים:
<code>
$A $a $a23 $A2 $A3s $TEXT $Hebrew_text $Hebrw_Text_For_Reverse $hebrewText
</code>
אלו היו דוגמאות לשמות חוקיים, לעומת זאת השמות הבאים אינם מותרים:
<code>
 $1 $44f $_44 $4.4 $.4 $.f $*4 $^4 $d $d* $@ $rרf $()
</code>
במדריך הרשמי של PHP הגדילו לעשות ונתנו את תבנית ה regular expression לתיאור התווים החוקיים (הנושא של "ביטויים רגולריים" חורג ממסגרת הדיון של מדריך זה). לאילו מאיתנו שיודעים את הנושא (ואני בטוח שיש מעטים כאלה בין הקוראים) הנה הסט:
<code>
'[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*'
</code>
לא משהו שחייבים להבין כמובן.ולהמשך ההסבר: לתוך המשתנים, אנחנו מאתחלים ערכים, למשל:
  $Hebrew="טקסט כלשהו בעברית";
בדוגמא, הנ"ל הכנסנו לתוך המשתנה Hebrew$ את התוכן 'טקסט כלשהו בעברית". לו נרצה להציג אותו על המסך, נשתמש ב:
  echo $Hebrew;
 למשתנים ב php אין "טיפוס", ולא צריך להכריז עליהם. כל מי שבא מעולם c/c++ למשל, יודע שכדי ליצור משתנה כלשהו, לערכי מספר שלם חיובי למשל, יש צורך קודם להכריז על המשתנה:
  int num;
היה מכריז על משתנה בשם num מסוג int (מספר שלם חיובי). \\
ב PHP אין צורך בזה. אנחנו יכולים להשתמש בכל משתנה שאנחנו רוצים, בלי להכריז עליו, ואף אין אנו צריכים להכריז על סוג המשתנה, המפרש פקודות "מנחש" בשבילנו מהו סוג המשתנה (לעיתים נוכל לקבוע ידנית סוגי משתנים, או לבצע cast (המרת סוג משתנה) ידנית, אבל זה קורה במקרים יחסית נדירים). כלומר, אם נרצה למשל משתנה מספרי, למניה של מספר כניסות לאתר, נוכל להשתמש במשתנה, כלשהו, נניח בשם $count בלי להכריז עליו כלל.

ברגע שנגדיל את ערכו ב 1 (לצורך העניין בגלל שמדובר במונה, אנו נדרשים להגדיל ב 1 עם כל כניסה חדשה), בעזרת ++count$ (צורת תחביר ידועה להגדלת ערך ב 1) php "תנחש" שמדובר במס', ותגדיל את ערכו ב 1. בהקשר של משתנים יש לציין את משתני הסביבה של המערכת. משתנים אלו הם משתנים ש php מגדירה, ובהם יש נתונים מעניינים שונים, כגון גרסאת php, גרסאת שרת וכו'. ניתן להפעילם כמו כל משתנה אחר, למשל:
  $_SERVER["SERVER_PORT"];
יחזיר את הפורט של השרת. במקרה שלנו, אם נריץ בתוך עמוד php:
  echo $_SERVER["SERVER_PORT"];
על המסך יוצג מס' הפורט של שרת ה web, במקרה שלי (וככה זה בד"כ) הפורט הוא פורט 80 וזה הערך שיהיה על המסך. בעבר היה נהוג להשתמש ב:
  $HTTP_SERVER_VARS

כדי לקבל את ערכי משתנה הסביבה של השרת, אבל השימוש ב $_SERVER מסורבל פחות, ולכן אישית, אני מעדיף אותו. משתנים נוספים שעלינו להכיר הם משתנים מסוג GET ומשנים מסוג POST. משתני GET הם משתנים שמועברים על ידי ה url, כלומר שורת הכתובת בדפדפן. אם יש לנו עמוד בשם index.php בשרת המקומי שלנו, ונכנסנו אליו על ידי הקלדה ב url של:
  http://127.0.0.1/index.php?var=barak&amp;var2=bloch

העברנו שני משתנים, הראשון בשם var וערכו barak והשני בשם var2 וערכו bloch. בשיטה זו, אם זה לא ברור, אחרי שם הקובץ, יש לרשום את שם המשתנה וערכו, ובמקרה ויש עוד משתנה להעביר, מפרידים בין המשתנים בעזרת  "&". כדי לגשת למשתנה מסוג get יש להשמש ב:
  $some_var_name=$_GET["var"];

כשבמקרה שלנו, some_var_name$ קיבל את הערך של var שהוא barak. ישנו עוד סוג משתנה בשם POST שהוא נוצר, כמעט תמיד בעזרת טפסים של html. הגישה לסוג משתנה כזה היא על ידי:
  $some_var_name=$_POST["var"];

טפסים יודעים להעביר הן משתנים מסוג POST והן משתנים מסוג GET. הסוג הנבחר נקבע על ידי התגית <form>, אם רוצים להעביר post רושמים:
  <form method=post action="">;

אם רוצים להעביר משתנים מסוג get:
  <form method=get action="">

השימוש ב get או post תלוי בשימוש הרצוי: למשל, אם אנחנו בונים מנוע חיפוש, נרצה להשתמש ב get. הסיבה היא פשוטה: נרצה שתוצאות החיפוש של המשתמש יועברו דרך הדפדפן, ובמידה והמשתמש ימצא תוצאה הרצויה לו, יוכל להעביר אותה למשתמש אחר להדגמה וכו'... או לשמור את התוצאה הרלוונטית אצלו בבוקמרק.  הערה: בתגית form המאפיין action נועד להגדיר את המיקום (העמוד) שבו יופעל הטופס, אם הוא נשאר ריק (כמו בדוגמא למעלה, בין הגרשיים המחרוזת ריקה) אז המשתנים יועברו לעמוד הנוכחי. למשל, אם יש ברשותנו עמוד עם מנוע חיפוש. נוכל להכניס ל FORM את המאפיינים הבאים:
  <form method=get action="search.php">

אחרי שהמשתמש יכניס ערך לחיפוש וילחץ על submit, המשתנים השונים בטופס (בדוגמא של מנוע חיפוש, בד"כ תיבת טקסט של הערך לחיפוש) יועברו לעמוד שכתובתו search.php, שזה למעשה העמוד החדש שאליו המשתמש עובר! אם מחפשים בגוגל את המחרוזת php, לאחר שרושמים php מתקבל עמוד התוצאות, שכתובתו היא:
http://www.google.co.il/search?q=php&ie=UTF-8&oe=UTF-8&hl=iw|http://www.google.co.il/search?q=php&amp;ie=UTF-8&amp;oe=UTF-8&amp;hl=iw

גוגל מעביר באמצעות המשתנה q את הערך php (למעשה, זה קיצור של המילה query, שמתארת את הפעולה של ביצוע שאילתה על המסד נתונים עם המחרוזת שמועברת למשתנה זה) וכן מעביר ערכים נוספים (שקשורים לכך שמדובר בשפה העברית, ומאפשרים לקבל תוצאות רלוונטיות בצורה טובה יותר). אם היו משתמשים ב post, לא היה באפשרותי לתת את הלינק הישיר הנ"ל מן הסתם... החסרון של שימוש ב get הוא בכך שהוא מוגבל מבחינת האורך שניתן להעביר איתו (אורך המשתנים), הצורך בקידוד של המידע (בעזרת urlencode בד"כ, שכן http לא מכיר בתווים שונים, כמו עברית) וכו'.. \\ 
כמו כן לא תמיד נרצה להטריד את המשתמש ב url ארוך ומסורבל וכו'... (יש מקרים רבים שבהם זה פשוט חסר טעם).  \\
**__ הערות חשובות:__** בעבר היה נהוג לקבל משתני POST ו GET בצורה קצת מסורבלת יותר: 
<code>
$some_var_name=$_GET["var"]
$some_var_name=$HTTP_GET_VARS["var"]

$some_var_name=$_POST["var"];
$some_var_name=$HTTP_POST_VARS["var"]
</code>

בדוגמא הנ"ל הדגשתי את צורת השימוש הסטנדרטית הישנה שעדיין נתמכת. יחד עם זאת בגרסאות החדשות של PHP הוספה שיטת הרישום החדשה, הנוחה יותר (בדוגמא אינה מודגשת) ולכן שווה להתרגל לעבוד איתה (פחות כתיבה, יותר נוח, ועדיין קריא מאוד). עוד הערה שחשוב לשים לב אליה, עד לגרסאות האחרונות של PHP כל המשתנים היו בברירת מחדל גלובליים, כלומר אם מישהו נכנס לעמוד index.php שלנו על ידי הקלדת:
  http://our_domain/index.php?admin=yes

והיה לנו בתוך הקוד של אותו דף קטע מהסוג הבא:
  if ($admin==yes) { # Some code here }
במקרה כזה, למרות שלא השתמשתנו ב:
  if ($_GET["admin"]==yes) { # Some code here }

עדיין המערכת הייתה מכירה במשתנה, שכן משתני ה GET הינם גלובליים (גם משתני ה POST וה SERVER). בעזרת PHP.INI ניתן למנוע את זה, ובכלל בגרסאות האחרונות בברירת מחדל זה **אינו מאופשר**. \\ כמי שהתרגל בעבר להשתמש בשיטה המקוצרת, אני ממליץ להמנע מזה, יש בנושא זה סוגיות אבטחה כאלה ואחרות, וזה בהחלא לא הרגל בריא. מעבר לזה, בתוכניות גדולות ומורכבות לעיתים השימוש במשתנים גלובליים, הוא הרסני מבחינת ניהול הקוד ורק גורם לבעיות.... (בד"כ בתוכניות קטנות מאוד המשמעות זניחה).

הסיבה שהזכרתי את זה, היא במידה ותתקלו בקודים כאלה ב WEB תדעו שיש את הדרך לבצע זאת ככה, והדברים עובדים בגלל היכולת של php בנושא זה, אבל בהחלט מומלץ להמנע מהרגל תכנותי רע זה. עוד הערה שחשוב לציין, בגרסאות חדישות של PHP חייבים לאתחל משתנים בטרם משתמשים בהם, אלא אם קובעים אחרת ב php.ini.  אני אישית מוצא את זה מרגיז, ומאפשר את העבודה עם משתנים שאינם מאותחלים תמיד.

=== קבועים ב PHP ===
לפעמים נרצה להגדיר ערכי קבועים. קבועים הם למעשה משתנים שלא ניתן לשנות את ערכם.\\\
מה ההגיון בשימוש ב"קבועים"? ההגיון הוא לאפשר לאתחל אותם פעם אחת, בתוכנית ולמנוע את שינויים באמצע, כדי להמנע מטעויות. אם למשל אנחנו רוצים לעבוד מול מסד נתונים Mysql . כדי שהתוכנית תוכל להתחבר למסד כל פעם, יש צורך בנתינת הסיסמא. שימוש נבון יהיה להגדיר בנקודה כלשהי את שם המשתמש כקבוע. זה יאפשר לנו לגשת בנקודות השונות של התוכנית אל המסד תוך שימוש בערך הקבוע שהוגדר כ משתמש של מסד הנתונים. 

במידה ונחליף משתמש,בשלב כלשהו, נצטרך רק לערוך את השורה בה הוגדר ה"קבוע". על התווים המכילים את שם ה"קבוע" חלים אותכם כללים שהגדרנו על שמות של משתנים. ניתן דוגמא של הגדרת קבוע: \\ \\
<code>define("Mysql_user", "barak");
echo Mysq_user; # outputs "barak"</code>

בדוגמא הנ"ל יצרנו קבוע בשם Mysql_user שערכו barak ופשוט הצגנו אותו על המסך. בתוכנית עצמה, אפשר להשתמש בזה לפניה אל מסד הנתונים, תוך שימוש בקבוע של שם המשתמש. כמובן, שבתוכנית ממוצעת שמשתמשת ב Mysql פונים אל מסד הנתונים עשרות ומאות פעמים, לפיכך, אין יותר נוח מלבנות קובץ קונפיגורציה שבו יהיו קבועים שונים.

כמובן שזה נוח במידה והחלטנו לשנות הגדרות. אם למשל מחר נצטרך לשנות את שם המשתמש במסד ה SQL מאילוצים של "מנהל הרשת", מעבר לשרת אחר וכו', לא נצטרך לשנות את שם המשתמש של המסד בכל חלק רלוונטי בקוד, אלא רק בשורת ההגדרה של "הקבוע" שמכיל את שם המשתמש...

=== לולאות ומשפטי תנאי ===
אחרי שלמדנו מה זה משתנים, צריך לעשות איתם דברים שימושיים לא ? כדי לעשות את זה, אנחנו פשוט משתמשים ב לולאות ומשפטי תנאי, כמו בכל שפת תכנות מקובלת. מי שמכיר פרל, C או JAVA די ירגיש בבית. אחרים, יצטרכו קצת יותר לתרגל, אבל בסה"כ, השימוש הוא פשוט וברור. 

== if ==
לולאת if היא הבסיסית ביותר, אבל אולי החשובה ביותר. בעזרתה בודקים אם תנאי מסויים מתקיים (או לא מתקיים) כדי לקבוע אם לבצע מטלה כלשהי, אם נרצה לתת דוגמא בסיסית:
<code>if ($user==root)  {
SHOW_MANAGAR_FORM();
}
</code>

במקרה הנ"ל, בדקנו אם הערת user שווה ל root אם כן , אנחנו מפעילים פונקציה ששמה: SHOW_MANAGAR_FORM \\
הערה: השימוש ב ' == ' נועד לאמר למפרש של PHP לא לבצע הצבה של המחרוזת root במשתנה יוזר, אלא לבצע השוואה בינהם ! דוגמא נוספת:
<code>
if ($pass == sdfgf) {
print_page()
}
else {
echo "Sorry, wrong password";
}
</code>
בדוגמא הנ"ל בדקנו אם הערך של $pass שווה ל sdfgf (יכולה להיות סיסמא כלשהי) אם כן מפעילים את print_page אחרת מציגים על המסך: **Sorry, wrong password**\\
הפקודה elseif משמשת אותנו לביצוע מטלה אם מתקיים תנאי, לאחר שתנאי אחר לא התקיים, התחביר הולך ככה:
<code>
if (expression) { }
elseif(expression) { }
else{ }
</code>
אפשר להשתמש באינסוף רמות קינון של לולאות if elseif הכל בהתאם לצרכים שלנו. ניקח דוגמא קצרצרה לשימוש ב elseif :
if ($Browser=="Mozilla") {
echo "U using Mozilla, great choice";
} elseif ($Browser=="MSIE") { echo "U using MSIE" ; $show_alternative_Page("MSIE"); }
 else{ echo "U using some non IE / mozilla browser";}
</code>
בדוגמא הנ"ל בדקנו איזה דפדפן יש למשתמש (למעשה, לא בדקנו באמת, הנחנו של $Browser יש את הערך הזה. במידה ויש לו את מוזילה, אנחנו מציגים הודעה U using Mozilla, great choice וממשיכים הלאה. אחרת, אנחנו בודקים אם יש לו אינטנרנט אקספלורר, אם כן מציגים לו את ההודעה, U using MSIE ומראים לו עמוד אלטרנטיבי שמותאם לאינטרנט אקספלורר (בהנחה שהעמוד הנוכחי הותאם למוזילה ודומיו). במידה והדפדפן הוא גם לא אינטרנט אקספלורר, אנחנו סתם מציגים הודעה שאומרת: U using some non IE / [[http://www.mozilla.org|mozilla]] browser.

הדוגמא הנ"ל יכולה להיות שימושית (יש פונקציה ב PHP ואני משאיר זאת כתרגיל עבורכם למצוא אותה) שיכולה לתת לכם את סוג הדפדפן. במידה ויודעים מהו הדפדפן, ניתן להתאים עמודי WEB שיראו הכי טוב שאפשר בדפדפנים השונים (שכל אחד מהם עובד בצורה קצת שונה). 

== while ==
משתמשים בלולאה זו כדי לבצע סדר מסויים של פעולות כל עוד מתקיים תנאי כלשהו, התחביר הוא:
  while(expression) { # Exec }
אם נרצה לקחת דוגמא כלשהי:
<code>
$x=0
while ($x < 10)  {
$x=$x+1; 
echo "$x <br>";
}</code>
הסבר: איתחלנו ב $x את הערך 0 (לא היינו חייבים, במידה וזו פעם ראשונה שמשתמשים במשתנה $x). לאחר מכן הפעלנו לולאת while שתבוצע כל עוד x קטן מ 10. היות ופעם הראשונה x=0 התנאי מתקיים והלולה תבוצע. בשורה הראשונה בלולה הגדלנו את ערכו של $x ב - 1 , כלומר הוא יהיה שווה ל 1 . מיד לאחר מכן הצגנו את ערכו של x (בפעם הראשונה הוא שווה ל 1) וירדנו שורה בעזרת br (השימוש בנקודה מאפשר לנו לשרשר משתנים לתוך echo , או במקרה שלנו לעבור ממשתנה כלשהו, לרצף התווים <br> שב html הוא ירידת שורה.

== do while ==
 לולאת do while דומה בשימוש ל while. התחביר שלה הוא הבא:
 do  { # Code  } while(expression);
בלולאה זו, בפעם הראשונה הלולאה תתקיין בכל מקרה, ורק בתום הפעם הראשונה נבצע את בדיקת התנאי.

== switch()==
לולאה זו תפעיל קטע קוד כלשהו בהתם לבדיקת תנאי. התחביר של הפקודה נראה ככה:
<code>
switch($var) {
case 1:
# exec some statements.... 
case 2; 
# exec some statments....
case 3: 
# exec some statments...
default:
#exec some statments
}
</code>
בגדול, אנחנו מעבירים פרמטר כלשהו ל switch למשל $var ואז אנחנו בודקים. אם $var=1 אז אנחנו מבצעים את מה שבא אחרי case 1 וכו'...  אם ערכו לא מתאים לשום ערך, אפשר לבצע את מה שבא אחרי default .  לולאה זו לא מוסיפה "כוח" לשפה, אבל היא מסייעת לנו להמנע מקוד מיותר תוך שימוש בלולאות if ולקבל קוד קריא יותר.

הערה: לאחר שהמערכת מזהה את ה case שמתאים, למשל אם $var=2 אז מרגע שהמערכת פוגשת ב case 2: הקוד יופעל ללא עצירה, גם לאחר case 3: כנהוג בכל שפת תכנות מודרנית.  כדי לעצור את הביצוע בסיום case 2: מוסיפים את הפקודה break שמוציאה אותנו מיידית מבלוק ה - switch.  אם נרצה לתת דוגמא פשוטה לשימוש ב switch:
<code>
switch ($Lang) { 
case 0: 
echo "U Using Visual Hebrew mode"; 
echo "<div align=right>"
echo hebrevc($text_Hebrew,30);
echo "</div>"
break;
case 1:
echo "U using Visual Arabic mode";
echo "<div align=right>"
echo hebrevc($text_arabic,30);
echo "</div>" 
break;
default:
echo "U using English mode";
echo $text_English
}</code>
בדוגמא הנ"ל, הנחנו שהמספרים בתוך $Lnag מייצגים את השפה להצגה על המסך. אם יש את הערך 0 אז מוצגת על המסך הודעה שמדובר ב "מצב עברית ויזואלית" אנחנו מבצעים יישור של הפסקה לימין (כי מדובר בשפה שנכתבת מימין לשמאל) ואז מבצעים בעזרכת hebrevc היפוך של העברית. במקרה והערך של Lang הוא 1 אז מבצעים את אותו טריק אבל מציגים הודעה שמדובר בשפה הערבית, והטקסט שיוצג הוא $text_Arabic שמן הסתם אמור להיות אותו טקסט מתורגם לערבית. (הערה, יתכן והפונק' hebrevc לא תיתן את התוצאות הרצויות בערבית..., נושא זה לא נבדק ככל שידוע לי).  ואם הערך הוא כל ערך אחר, על המסך תוצג הודעה שמדובר במצב עבודה של אנגלית, והטקסט שיוצג יהיה באנגלית (בלי ישור לימין מן הסתם). 

כמובן שלו נשתמש ב "טופס" לבדיקת השפה הרצויה של המשתמש,או בדרך אחרת לבדיקת השפה הרצויה, אזי השימוש ברעיון שהוצג הוא מעשי ויכול לאפשר לנו לבנות עמודים עם שפות שונות בצורה נוחה ויעילה.

== for ==
 לולאה זו היא לולאה שמאוד חשוב להכיר (מאוד שימושית ונוחה). המבנה הכללי שלה הוא הבא:
  for (expr1; expr2; expr3) statement

הביטוי הראשון, הוא הערך ההתחלתי של משתנה כלשהו, הביטוי השני הוא התנאי לקיום הלולאה (למשל כל עוד x<10 )והביטוי השלישי הוא פעולה כלשהי שאנחנו רוצים לבצע עם כל סיום של ריצה בודדת בלולאה (למעשה בד"כ משמש לקידום מונה כלשהו שגורם בשלב כלשהו ליציאה מהלולאה בהתאם לתנאי שהוגדר בביטוי האמצעי / השני בלולאת ה for)/ ניתן דוגמא בסיסית:
<code>
for($i=0;$i<4;$i++) { 
echo $i;
echo "<br>";
}
</code>
בדוגמא הנ"ל, הערך ההתחלתי של i הוא 0 בכל סיבוב של הלולאה ערכו גדל ב 1 (השימוש ב ++ על משתנה כלשהו מאפשר את הגדלתו באחד !) והלולה מתבצעת כל עוד i יהיה קטן מ 4 . הרץ את הדוגמא, שחק עם הערכים ההתחלתיים והסופים, עם ביטוי התנטי ועם שורות הפלט, להבנה מלאה של הנושא. אם נרצה לתת דוגמא כלשהי שימושית ללולאת for:
<code>
<?
echo "<table border=1>";
for($x=1;$x<11;$x++) {
echo "<tr>\n";
for ($y=1;$y<11;$y++) { 
$kefel=$y*$x; 
echo "<td>$kefel</td>\n";
}
echo "</tr>\n";}
echo "</table>\n";
?></code>

דוגמא זו מעט מורכבת, אבל היא מראה יפה את העוצמה של לולאת for. לפני שנדון בדוגמא הערה - בשורות שבהן השתמשתנו ב echo הוספנו בסוף ההצגה בביטוי ' \n ' שמייצג את התו שורה חדשה, בפועל, זה גורם לקוד ש php מייצרת לרדת שורה בסוף כל echo. על המסך אין לזה השפעה (כי html יורדת שורה בכל <br> ולא בכל ירידת שורה של קוד המקור של המסמך) אבל זה מסוייע לקוד להפוך לקריא יותר...

ועכשיו נסביר את הדוגמא: מה שהדוגמא עושה זה מציגה טבלה של "לוח הכפל". הטריק הוא פשוט: שימוש בלולאת for אחת בתוך השניה. כדי להבין איך זה עובד, שחק מעט עם הקוד, הפוך את הקטע קוד של הלולאה הפנימית להערה, ובדוק את הפלט על המסך. שים לב כיצד כמה שורות בעזרת for הופכת לטבלה נאה ושימושית על המסך... תאר לך שאתה צריך לכתוב את לוח הכפל ב html נקי... (הסתכל בקוד המקור של העמוד בדפדפן ותוכל לראות את הקוד ש php מיצרת למעשה). זו אחת הדוגמאות שאני נוהג לתת לאנשים בלימוד שפה כלשהי, כי היא באמת דוגמא פשוטה מאוד, אך מהווה שימוש יפה ללולאת for.

== foreach ==
לא נתעכב הרבה על שימוש בלולאה זו (היא מתקדמת יותר). נציין שהיא הוכנסה ל PHP4 והיא דומה בפעולתה ללולאת foreach בשפות רבות אחרות (למשל perl). דוגמא לשימוש בה:
  foreach ($arr as $value) { echo "Value: $value<br>\n";

מה שהפונקציה עושה היא לוקחת משתנה מסוג מערך (יוסבר בהמשך מה זה) ופשוט עוברת על משתנה משתנה בו. array, הוא למעשה משתנה שמכיל בתוכו רצף של משתנים. אם נרצה לתת דוגמא כלשהי:
<code>$arr[0]="barak";
$arr[1]="roni";
$arr[2]="rotem";
foreach ($arr as $value) {
echo "Value: $value<br>;\n";
}</code>

על המסך יוצגו השמות השונים אחד מתחת לשני. אפשרות נוספת שיש לשימוש ב foreach הוא הבא:
<code><?
$arr[test]="90";
$arr[test2]="93";
$arr[test3]="55";
foreach ($arr as $key =&gt; $value) {
echo "$key; Value: $value<br>\n"}
?>
</code>
השימוש ב $key => $value מאפשר לנו לקבל בכל מחזור של הלולאה את הערך של האינדקס של ה"מערך". אנחנו במקרה שלנו מציגים בכל שורה, הן את מספר המבחן והן את הציון בו.

**הערה **: לולאות מהסוג for, foreach while, do..while ולמבנה switch אפשר להכניס שימוש ב break. השימוש במילה השמורה break מאפשר לנו לצאת מהלולאה / מבנה באמצע קיומה. למשל:
<code>
<?
$Max_Line=1;
for($i='a';$i<'z';$i++,$Max_Line++) {
echo $i;
if ($Max_Line>19)  {
break
}
}
?></code>
דוגמא הנ"ל הגדרנו משתנה Max_Line ואתחלנו בו את הערך 1 . אנחנו מנסים להציג את ה א' ב' הלועזי, בכל loop של for אנחנו מציגים את האות הבאה, החל מ a ועד ל z . אלא שהלולאה בודקת שלא מציגים יותר מ 20 אותיות, אם זה המצב, הלולאה תפסיק לרוץ !

כמובן שיש מקרים שבהם השימוש יהיה מעשי יותר, למשל אם נתקל במקרה קיצון כלשהו שנרצו בעקבתו לצאת מהלולאה.... (אלו דברים שנתקלים בהם במהלך תכנות מעשי...).

=== אופרטורים ב PHP ===
כמו בכל שפת תכנות מודרנית, גם ל PHP אופרטורים רבים ומגוונים. טבלת האופרטורים של PHP כולל סדר הקדימות שלהם (כלומר מה יבוצע לפני מה בהנחה ויש שני אופרטורים) זמינים במדריך הרשמי של PHP למשל בכתובת http://www.php.net/manual/en/language.operators.php

דוגמאות לשימוש באופרטורים עיקריים:
  if ($a<5 && $a<10)
התנאי הנ"ל יתקיים כל עוד המשתנה a יהיה גדול מ - 5 אבל קטן מ - 10 (האופרטור && דורש את קיום שני התנאים ביחד)

  if ($a>0 || $a<0)
הביטוי הנ"ל יתבצע אם $a קטן מאפס או גדול מאפס, כלומר שונה מאפס (האופרטור || אומר לנו שאחד משני התנאים צריך להתמלא). אפשרות חכמה יותר לרשום את מה שרשמנו בדוגמא האחרונה:
  if ($a!=0)
קיום התנאי כל עוד a לא שווה ל 0 (! הופך את המשמעות של '=' ל-"לא שווה"). 

  $i++;
הדוגמא הנ"ל שקולה לקוד הבא:
  $i=$i+1;
אפשר באותה מידה להשתמש באופרטור '-' למשל: 
  $i--;

עוד אפשרות לשימוש באופרטורים אלו:
  $i+=4;
יהיה שווה ערך ל: 
  $i=$i+4

דוגמא ל שימוש באופרטורים ++ ו --
<code>$i=20;
$i++;
echo $i # on screen: 21

$i--; # on screen 20
$i+=5 # on screan 25 bcause you can see this line as: $i=$i+5
</code>

=== פונקציות ב PHP ===
פונקציות ב - PHP כמו בכל שפת תכנות מקובלת אחרת, הם קטע קוד שנועד לבצע מטלה מסויימת. ישנן פונקציות מובנות שהן חלק מ PHP למשל hebrevc שדנו בה בפרק א' ופונקציות שניתן להגדיר לבד. ניתן דוגמא לפונקציה:
<code>
function kefel($a,$b) {
$result=$a*$b;
return $result;
}</code>

פונקציה זו, אחת הבסיסיות שיכולות לעשות מה שהיא עושה זה מבצעת פעולה פשוטה מאוד של כפל בין שני פרמטים שמועברים אליה (a ו b ) ואת התוצאה שלהם, שהיא המשתנה $result היא מחזירה למי שהפעיל אותה.  ההפעלה שלה יכולה להתבצע באופן הבא:
<code>
$num=3;
$num2=5; 
echo kefel($num,$num2);
</code>
כאן אנחנו יוצרים שתי משתנים עם מספרים, ומעבירים אותם כפרמטרים לפונקציה (שהיא מופעלת בשלב זה, כלומר מפרש הפקודות יעביר את הפרמטרים לפונקציה ויריץ אותה. הערך שיוחזר על ידי הפונקציה יוצג על המסך בגלל השימוש ב echo. אם אנחנו רוצים רק לקבל את הערך, אפשר לעשות את הדבר הבא:
<code>
$var=kefel($num,$num2);
</code>
במקרה הזה, התוצאה לא תוצג על המסך אלא תכנס לערך של var$. הדוגמא הנ"ל לא עושה יותר מדיי, אבל היא דוגמא בסיסית ביותר לפונקציה (למעשה היא לא שימושית, כי אפשר היה לעשות את הפונקציה בשורה אחת של קוד, בלי לקרוא לפונקציה...) 

עכשיו, אסביר קצת יותר לעומק על התחביר של הפונקציות ב PHP. כדי להשתמש בפונקציה ב PHP (פונקציה שאנחנו בונים לבד, לא מוכנה על ידי PHP ) יש לבצע שני שלבים:
  * ליצור את הפונקציה, או אם נרצה להשתמש במונח המקצועי "להגדיר את הפונקציה". זה נעשה תוך שימוש ב מילה השמורה ** function** כבאופן הבא:
<code>
function func_name ($var1,$var2... varN) {
# Some_code
# may return some value by using: return $var_name
}
</code>
הגדרת הפונקציה מתחילה במילה function ולאחריה בה שם הפונקציה עם סוגרים עגולים שבתוכם ניתן לשים פרמטרים שאפשר יהיה להעביר לפונקציה (בד"כ מעבירים פרמטרים). כל המטלות של הפונקציה נמצאות בתוך הסוגריים המסולסלות. שם הפונקציה מבצעת את העבודה עצמה.

לעיתים נרצה לסיים את הפונקציה ולהחזיר בסיומה ערך כלשהו, ואז נשתמש ב return sohmething כש-something יכול להיות מחרוזת (עם גרשיים כמובן) או משתנה מסוג כלשהו (כולל מערך) או מספר כלשהו (לא צריך עם גרשיים). לאחר השימוש ב return הפונקציה מסיימת לפעול, גם אם יש עדיין משפטים לביצוע. דוגמאות לערכים שניתן להחזיר:
<code>
return 1;
return "barak";
return $value;
</code>

ההגדרה של הפונקציה, היא לצורך בנייתה, מפרש הפקודות לא יבצע אותה, כל עוד לא קראנו לה, ואת זה מבצעים באופן הבא:
<code>
func_name($var1,$var2,$var3)
</code>

הרעיון מאחורי השימוש בפונקציות הוא פשוט מאוד: הן מאפשרות לנו לאחד סדר פעולות, שבד"כ יחזור על עצמו יותר מפעם אחת, בצורה מסודרת, וקריאה. \\ 
מעבר לזה, שימוש נבון בפונקציות, יאפשר לנו בקלות להעתיק ולהשתמש באותן פונקציות בתוכניות שונות לחלוטין. אם למשל פיתחנו פונקציה שתפקידה להחזיר את הערך של התאריך העברי, על פי היום הנוכחי הלועזי (יש פונקציה מובנית ב PHP לקבלת התאריכים הלועזיים) נוכל להשתמש בה בתוכניות שונות: \\  החל מאתר אינטרנט שבו נרצה לשלב בכל מאמר את התאריך העברי של כתיבתו, דרך לוח שנה מבוסס WEB שאולי נרצה לבנות וכו'...

חשוב מאוד כשבונים פונקציה לתת לה להיות כמה שיותר מופשטת, ושתיהיה בעלת הגמישות המירבית, כדי שתתאים לשימוש גם בתוכניות אחרות.  אם למשל ניצור פונקציה אחת בודדת שתציג פורום, הרי שעשינו פונקציה מסורבלת, ארוכה, לא נעימה לקריאה, ומעל לכל בלתי ניתנת לשימוש חוזר (אלא אם משכתבים את כל הקוד). לעומת זאת אם נחלק את הצגת עמודי הפורום לפונקציות משנה, למשל פונקציה להצגת הודעה בודדת, פונקציה להצגת עץ ההודעות, פונקציה לקביעת המספור של העמודים וכו', יהיה הרבה יותר קל להבין את הקוד, ואף לעשות בו שימוש חוזר, שהרי נניח מימוש של "העץ" שימושי גם לפרוייקטים אחרים שהם אינם פורום או משהו שדומה לפורום בכלל, וכנ"ל פונקציות אחרות שיכולות לשמש אותנו בבניית הפורום. מי שבא אל PHP מעולם של שפות שאין בהן "פונקציות" כמו פסקל, הוא יכול לראות בפונקציה כמקבילה ל "פרוצדורה".

=== עוגיות ו-PHP ===
עוגיות, הן למעשה קבצי טקסט שנמצאים במחשב של הלקוח, המהווים אוסף של משתנים. בעזרת עוגיות אפשר לשמור אצל הלקוח נתונים שונים שנכול לגשת אליהם בפעם הבאה שהוא יכנס לאתר. \\ 
למשל, אם אנחנו רוצים לתת למשתמש לשנות את העיצוב של האתר לפי צרכיו, מה שצריך לעשות זה לשתול אצלו עוגיות עם המאפיינים שהוא בחר. אחרי שמשתנים אלו נשמרים אצל המשתמש, אנחנו יכולים לגשת אליהם ולייצר למשתמש את העמוד בעיצוב הרצוי.

לעוגיות יש מספר מאפיינים, כמו תאריך תפוגה וכודומה. צריך לזכור שלא כל הדפדפנים ולא כל המשתמשים יאפשרו לשלוח אליהם עוגיות, ולכן צריך לדעת להתמודד גם עם מצב זה, בצורה האלגנטית ביותר.

השימוש בעוגיות חייב להעשות בטרם נשלח ה header ללקוח. ה-header הוא כותרת ה http שנשלחת ללקוח. ברגע ששלחנו למשתמש תוכן כלשהו, למשל בעזרת echo או בעזרת print אין אפשרות להשתמש בעוגיות (וזה תקף גם למקרה שאמרנו ל מפרש של PHP להתעלם מקטע קוד מסויים, כלומר שהוא מחוץ ל <??> , שזה בפועל כמו שימוש ב echo... כי המידע נשלח לדפדפן בפועל). הסיבה לכך נעוצה בצורה בו בנוי הפרוטוקול, שאינו מאפשר לעבוד בצורה דו כיוונית ככל שנדרש, אלא מגדיר בנפרד את שלב ה header שבו שאפשר להעביר עוגיות, להשתמש ב session, ולבצע redirect לעמוד אחר (קרא על הפונקציה header במדריך הרשמי של php לעוד מידע). אם נרצה לתת דוגמא לשימוש לא חוקי בעוגיות, שלא יעבוד:
<code>
<html>
<head>
<? setcookie ("TestCookie", $value); ?>
<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso8859-8">
<title>Log--Visual</title>;
</head>
<body>
</body>
</html>
</code>

השימוש אינו חוקי, כי נשלח ללקוח כבר השורות של התגיות:
<code>
<html>
<head>
</code>

כדי ליצור עוגיה משתמשים ב setcoockie:
<code>setcookie ("BGcolor", $val);</code>

בדוגמא הנ"ל יצרנו עוגיה שתחזיק אצל המשתמש עד שהוא יפעיל מחדש את הדפדפן (או יותר נכון יסגור את הדפדפן) \\  העוגיה תהיה משתנה בשם BGcolor וערכה יהיה val$ \\ \\  אם נרצה לתת למשתמש עוגיה עם טווח חיים ארוך יותר:
<code>setcookie ("BGocolor", $value,time()+3600)</code>

עוגיה זו תקבל את אותו ערך אבל תחזיק שעה (החל מהשניה בה היא מופעלת + 3600 שניות \\  אם נרצה שהיא תחזיק נניח 30 יום, נוכל להריץ:
<code>setcookie ("BGocolor", $value,time()+3600*24*30)</code>

כדי לקבל את ערכה של העוגיה נוכל להריץ:
<code>$cookie_IS=$_COOKIE["BGcolor"];</code>

אם נרצה להציג את הערך על המסך זה יראה כמובן כך:
<code>echo $_COOKIE["BGcolor"];</code>

=== מחלקות ואובייקטים ===
התלבטתי רבות אם לכתוב את פרק זה. \\ 
בפרק זה נסביר בכללית את השימוש במחלקות ובאובייקטים ב PHP אבל היות ומדובר בנושא מתקדם יחסית, אתה יכול לדלג על פרק זה, ולא לדאוג (אפשר לחיות גם בלי אובייקטים). מצד שני השימוש באובייקטים יכול להיות נוח, בעיקר בפרוייקטים גדולים יחסית, אז אולי כדאי ללמוד את נושא זה. אם יש לך נסיון בשפה מונחית עצמים כלשהי, כגון "c++" אתה יכול לקבל כאן רושם ראשוני כיצד זה ממומש ב php, אחרת, ראה את פרק זה כמבוא ראשוני ביותר לנושא מעניין זה. 

מחלקה היא קטע קוד שמאחד בתוכה משתנים ו / או פונקציות.  כדי לפנות אל אותם משתנים / פונקציות יוצרים משתנה מסוג אובייקט. משתנה זה יכול לגשת למשתנים ולמחלקות השונות של הפונקציה (ב PHP לא ניתן בשלב זה לבצע הסתרה של חלקי קוד מהאוייבקטים, אבל בתכנות מונחה עצמים אמיתי, זה אחד היסודות החשובים). אם נרצה לקחת דוגמא קטנה של שימוש במחלקה:
<code>
class Files  {
 function Files($Name,$Mode='r') {
  $var File_Name=Name; 
  # define file name var
  $var Mode; 
  # define mode (r for read only, w to writh and so on)
 }
 function write($var) {  } 
 function read()  {
  #exec here some code to write to file
 }
}
</code>

בדוגמא הנ"ל הגדרנו (עדיין היא לא מופעלת, זו רק הגדרה של המחלקה !) את המחלקה בשם Files מחלקה זו נועדה לשמור ולפתוח קבצי טקסט. למחלקה הגדרנו ראשית פונקציה בונה. פונקציה בונה היא פונקציה ששמה זהה לשם המחלקה שבה היא נמצאת, במקרה שלנו הפונקציה הי Files)( מן הסתם.  הפונקציה הבונה תורץ ישר עם בנית האובייקט (באופן אוטומטי). היא רצה פעם אחת עם בנית האובייקט וזהו. היא שימושית לאיתחול משתנים שונים שקשורים לאובייקט. בעת שניצור את האובייקט נראה זאת בהמשך נוכל להעביר איתו ערכים (שיכנסו אל הפונקציה Files בתור פרמטרים). 

הפרמטר הראשון הוא שם הקובץ באוייבקט והפרמטר השני הוא המוד של העבודה עם האובייקט (במקרה שלנו, אם לא נעביר פרמטר, בברירת המחדל המצב יהיה מצב 'r' כלומר קריאה בלבד). לאחר מכן הגדרנו פונקציות לקריאה ולכתיבה של הקובץ/ הפונקציה לכתיבה לקובץ מקבלת כפרמטרים משתנה בשם $var שהוא יהיה הטקסט שנכניס אל הקובץ.

 בשלב זה, כדי לפשט את ההסבר, לא הכנסנו קוד אמיתי לתוך הפונקציות הללו (את זה נשאיר לך כתרגול). אז כיצד מפעילים את המחלקה? ככה:
<code>
$File_OBJ = new Files("/var/www/html/counter.txt","w");
$File_OBJ->write("233");
</code>

יצרנו אובייקט חדש בשם File_OBJ$ והעברנו לפונקציה Files את הנתיב של הקובץ, ואת מוד הפעולה w - כלומר כתיבה לקובץ. בשורה השניה הפעלנו את הפונקציה לכתיבת הקובץ של האובייקט $File_OBJ והעברנו לתוכו את הערך 233. זה יכול לשמש אותנו למשל בבניית מונה. כדי להשתמש בזה לבנית מונה כל מה שצריך להוסיף, זה קודם כל שורה לקריאת הערך הנוכחי של הקובץ לאחר מכן הגדלת ערכו ב 1 ואז כתיבה מחדש לקובץ. וכמובן, להוסיף את הפונקציות הדרושות לעבודה עם קבצים בפונקציות של המחלקה. מאפיין חשוב שיש למחלקה הוא השימוש ב $this .  היות ולמחלקה יכולים להיות מספר מופעים, למשל במידה והגדרנו את המופעים הבאים:
<code>
$File_OBJ = new Files("/var/www/html/counter.txt","w"); 
$File2_OBJ = new Files("/var/www/html/counter2.txt","r");
$File3_OBJ = new Files("/var/www/html/counter3.txt","w");
</code>

והיות וגם לא ידוע לנו מהו שם האובייקט / האובייקטים שיצרנו בתוך הגדרת המחלקה (שהרי המחלקה יוצאת טיפוס נתונים מסויימים, והאובייקט הוא מופע שנקבע אח"כ בהתאם לצרכים של התוכנית), אז אין לנו אפשרות להשתמש ב File_OBJ$ או בכלל בשם האובייקט שיצרנו ישירות מתוך גוף המחלקה (זה לא גמיש, כי זה אוכף את המחלקה לעבוד היטב רק עם "אובייקט אחד בודד"). לכן משתמשים ב $this שהוא משתנה מובנה בתוך PHP כבאופן הבא:
<code>
function write($var) {
 if ( $this->mode != 'w') {
  echo "Fatal Error !"; 
  exit(1);
 }
}
</code>

בדוגמא הנ"ל, ברגע שקראנו "לאובייקט" this מפרש הפקודות של PHP יודע שמדובר בקריאה לפונקציה / משתנה של האוייבקט הנוכחי המופעל.. 

**כמה תוספות**: הגדרת אובייקט - אובייקט הוא למעשה משתנה מורכב, שמכמס בתוכו פונקציות ומשתנים שונים בהתאם להגדרת המחלקה. השימוש באובייקטים מאפשר לפשט מאוד תוכניות מורכבות, שכן הוא מאפשר לאגד (או "לכמס") פונקציות ומשתנים בעלי מאפיינים משותפים. השימוש ב אובייקטים מאפשר למשתמש לבצע תכנות מונחה עצמים (וההסבר המלא אודות מהו תכנות מונחה עצמים הוא מחוץ לתחום של מדריך זה), אם כי בצורה מוגבלת יחסית לשפות תכנות מונחות עצמים טהורות כמו JAVA או אפילו נחות יחסית לשפות כלאיים מהסוג של C++ . 

בכל מקרה, ב PHP ניתן לבצע הורשה של נתונים ממחלקה. אנחנו לא נפרט במדריך זה בנושא של הורשה, רק נציין שהורשה היא מאפיין חשוב מאוד בתכנות מונחה עצמים שמאפשר לך להוריש מחלקה מסויימת לתת מחלקה אחרת. המחלקה היורשת (החדשה) מקבלת את המאפיינים של המחלקה שמורישה (כולל המשתנים והפונקציות כפי שמוגדר בפונקציה המקורית). הפונקציה החדשה יכולה (ולמעשה זה תפקידה) להוסיף עוד חלקי קוד חדשים למחלקה, לפיכך היא מאפשרת שימוש חוזר בקוד.

אם נרצה להבהיר את הנוחות שבהורשה: אם ברשותך קוד של עגלת קניות מתוחכמת מבוססת מחלקה שהורדת מהרשת, בהנחה שהמחלקה היא מחלקה מורכבת שכוללת מאות שורות שאינך מבין את כולן, אך ברצונך להוסיף מאפיין נוסף לעגלה, מבלי לשנות (ולהבין את חלקי הקוד הפנימיים שלה) אתה יכול לבצע הורשה של המחלקה, ולקבל מחלקה חדשה שכוללת את כל המאפיינים של המחלקה המקורית, ואתה יכול פשוט להוסיף לה עוד מאפיינים, בלי לשנות את המחלקה המקורית בכלל, ובלי לסכן בפגיעה בקוד שלה (בהנחה והוא שימושי בחלקים אחרים במערכת שאתה בונה).

עוד יתרון גדול, הוא בפרוייקטים גדולים שעובדים עליהם מתכנתים רבים. כל מתכנת מקבל על עצמו לעבוד על מחלקה מסויימת, והוא יכול לממש בתוכה את כל הפונקציות שהוא זקוק להם, בלי לדאוג שהוא יבחר בשמות פונקציה ומשתנים שכבר בשימוש בפרוייקט.. (בעיה שקוראת המון בפרוייקטים גדולים).  הסיבה היא שהמחלקות השונות יכולות להגדיר פונקציות ומשתנים עם שמות זהים, וכמובן שאין בעיה עם זה, שכן סוג האובייקט, כפי שהוא מוגדר באמצעות השימוש ב new הוא זה שקובע איזה פונקציה תופעל בסופו של דבר.  כמובן שזה לעתים נוח גם בפרוייקט גדול שמבצעים לבד, שכן האפשרות לתת שמות זהים לפונקציות ולמשתנים היא, היא דבר שתמיד יכול לסייע. אם למשל אנחנו רוצים לתת מאפיין border פעם לטבלה, פעם ל חלון ופעם לעמוד, כמובן, שאפשר להשתמש במאפיין הזה בתור משתנה, כמה פעמים, כשהמחלקה שתופעל היא זו שתגדיר מה תפקידו בפועל....

לסיכום: נציין ששימוש בתכנות מונחה עצמים מאפשר לצמצם דרמטית בעיות שקשורות בתחזוקה של הקוד, בעיקר בקוד גדול שעובדים עליו המון מתכנתים שונים (ואם מדובר בפרוייקט של קוד פתוח, לעיתים הם בכלל לא מכירים אחד את השני, ומקסימום משוחחים בינהם ב - IRC ....) ולפיכך, טוב במקרים מסויימים להשתמש בתכנות מונחה עצמים. השימוש באובייקטים הוא בהחלט בונוס, ולא מעט קודים רציניים נכתבו ללא שורה אחת בתכנות מונחה עצמים, ככה שאפשר אם לא רוצים, לוותר על הנושא הזה ולהשתמש במאפיינים אחרים של השפה. החסרון של תכנות מונחה עצמים שהוא ידוע כבעל ביצועים נחותים יותר, וקצת קשה להתרגל לעבוד בתכנות מונחה עצמים למי שהורד לתכנות מבני סטנדרטי.

=== על התו ';' ===
טוב, אז כמו שבטח שמת לב, כמעט כל משפט נגמר בתו ';' (המוכר כנקודה פסיק). מי שתכנת בעברו בשפה כלשהי, יודע במה מדובר, ולא זקוק להסברים. לנבוכים שביננו, אסביר בקצרה שהתו הזה מסמן למפרש הפקודות של php להבין שנגמר מקטע קוד מסויים, ואנחנו עוברים לחלק אחר. נבחן את הקוד הבא:
<code>
$i=5;
$i++;
echo $i;
</code>
בשורה הראשונה המשתנה מקבל את הערך 5, בשורה השניה הוא גודל באחד ובשורה השלישיות הוא מוצג על המסך (כמספר 6 כמובן). את אותו קוד יכולנו לכתוב בשורה אחת:
<code>
$i=5; $i++; echo $i;
</code>

כמובן שככה זה פחות קריא, אבל מפרש הפקודות לא מונע מאיתנו את הגמישות לכתוב בצורה הנוחה ביותר מבחינתנו. כדי שמפרש הפקודות ידע כיצד לקרוא כל חלק בנפרד "ולהבין" נכון את מקטעי הקוד הוא נעזר בתו ';'. לא תמיד צריך להשתמש בנקודה פסיק בתום המשפט, זה נובע בעיקר מההקשר הרלוונטי (למשל, בלוקים של לולאות לא מסתיימים בנקודה בפסיק). מתי זקוקים לנקודה פסיק זה משהו שנובע מהגיון מאוד ברור, ובכל מקרה, מבלבל לעיתים מתכנתים חדשים, ולפיכך אין להבהל משגיאות שנובעות משימות (או חוסר שימוש) בנקודה פסיק...  זה דבר שמשתפר עם האימון בתכנות.

==== מעבר לבסיס. ====

===  קצת על php.ini ===
הקובץ php.ini שכבר הוזכר בפרקים קודמים הוא למעשה קובץ קונפיגורציה של PHP. כמקובל ביוניקס, את php מקנפגים על ידי עריכה של קובץ הגדרות. הקובץ php.ini מאפשר לקבוע המון הגדרות שיכולות להשפיע על רמת האבטחה של המערכת, ועל יכולתה להיות מתאימה לדרישות המשתמש וכן על הביצועים אפילו.

בד"כ, המערכת תומכת ישר מהקופסא בכל מה שהמשתמש הממוצע דורש / צריך. בכל מקרה הקובץ מתועד היטב (יש המון הערות בקובץ) ומומלץ להציץ בו לקבלת עוד מידע לגבי האפשרויות ש PHP נותנת לך כמשתמש...  אם החלטת לשנות חלקים בקובץ, ההמלצה שלי היא לשמור עותק של הקובץ כגיבוי, שכן לעיתים בטעות "הורסים את הקובץ" בלי לשים לב על ידי מחיקת שורות חשובות (זה יכול לקרות פשוט מטעות אנוש, בהיסח דעת) ושחזור של הקובץ, יכול להיות משימה מורכבת אם לא יודעים למה הוא בדיוק לא מבצע את המטלה כראויי.... (גיבוי הקובץ זו האפשרות להמנע ממצב לא נעים זה).

 הקובץ php.ini יושב ברוב מערכות הלינוקס תחת התקיה
<code>
/etc
</code>
בחלונות, הוא בד"כ יישב תחת:
<code>
c:\php
</code>

מתי נרצה לערוך חלקים שונים ב php.ini? במקרים שונים, למשל בעת שדרוג php לעיתים נגלה שדברים עובדים קצת שונה ממה שהתרגלנו אליו ונאלץ לערוך את php.ini במקום לשכתב חלקים גדולים בקוד. אם יש לנו קוד שמשתמש רבות במשתנים גלובליים שמתקבלים מ GET ו POST, אנו עלולים לגלות שבגרסאות מתקדמות של PHP (למשל 4.3) הקוד לא יעבוד כראוי. 

יהיו בפנינו שתי אפשרויות: 
  - לעשות את העבודה הקשה (והמשתלמת לעיתים מבחינת האבטחה ואיכות הקוד) ולשנות את כל החלקים שבהם התייחסנו למשתני GET ואחרים כמשתנים גלובליים) ולהשתמש בהתם "כמו בספר" כלומר לפנות אליהם בעזרת $_GET וכו'...
  - לערוך את php.ini להכיר במשתנים הגלובאליים. עוד דברים חשובים שנמצא ב php.ini הן הגדרות בעלות השפעה על האבטחה כגון האפשרות לעבוד עם upload של קבצים (הערה: אם אתה משתמש בפונקציות לביצוע upload קרא מדריכים בנושא, זה עלול להיות מסוכן מאוד !) 

הגדרות שיאפשרו לנו להשתמש ב asp tags כלומר במקום:

| | \\  &lt;??&gt; \\ | |

\\ \\ \\  להשתמש ב: \\

| | \\  &lt;% %&gt; \\ | |

\\ \\ \\  כמוגן ב ASP כמובן. \\ \\  אני לא ארחיב בנושא, כי הקובץ פשוט כתוב בצורה ברורה מאוד, עם הערות והסברים לגבי החלקים השונים, אני מניח גם שמשתמש חדש לא ירצה בד"כ לשחק עם הקובץ, ככה שאני משאיר לך לחקור את הקובץ בזמנך החופשי, אחרי שתשתפשף יותר עם שפת php

----

====== ה. תוכנית ראשונה שימושית - טופס לשליחה בדואר אלקטרוני ======

[[#index5|עבור לאינדקס השאלות של פרק זה]]

===== [[|5.1]] מה בפרק זה. =====

בפרק זה נראה תוכנית שימושית ראשונה ב php. \\  התוכנית היא אחת התוכניות היותר קלות ב PHP ולכן בחרתי בה. \\  מעבר לזה, היא מראה יותר מכל את העוצמה של שפה זו - עוצמה שמבטאת בפשטות רבה, עם שימושיות של ממש. \\ \\  למי שעדיין לא הבין - התוכנית שתוצג בהמשך היא תוכנית שתאפשר לנו לתת למשתמש טופס, שלאחר מילויו ישלח אוטומטית לנמען כלשהו (למשל מנהל הרשת). \\  היתרון בשימוש בטופס כזה היא בכך שהוא חוסך מהלקוח את הצורך לשלוח מייל, מה שיכול להיות בעייתי הן מבחינת הסירבול שנדרש ממנו (ולמרבה הפלא, רבים עוד לא יודעים לשלוח דוא"ל), אבל לא פחות חשוב, מאפשר לנו לקבל את האימייל מהלקוחות בפורמט שנוח לנו (טקסט פשוט במקרה שנדון בו), כשאנחנו יודעים מה אנחנו מקבלים תמיד ויכולים לשלוט על מבנה הדוא"ל (למשל להוסיף שדות בהתאם לצרכים וכו'). \\  מעבר לזה - ניתן במקביל לנתב את ההודעה גם למסד נתונים כלשהו למטרות כאלה ואחרות (למשל מעקב אחרי טיפול בדרישת הלקוחות וכו').

===== [[|5.2]] עמוד הטופס - index.html =====

בקובץ זה שום דבר לא מסעיר, רק עמוד html רגיל שמציג לנו טופס עם שלושה שדות עיקריים וכפתור submit כפי שיתואר בהמשך. \\ \\  נציג את הקובץ: \\

| | \\  &lt;!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"&gt; \\  &lt;html&gt; \\  &lt;head&gt; \\  &lt;title&gt;טופס משוב&lt;/title&gt; \\  &lt;meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-8-I"&gt; \\  &lt;/head&gt; \\  &lt;body dir=rtl&gt; \\  &lt;form method=post action=mail.php&gt; \\  כותרת: (תיאור קצר וענייני)&lt;br&gt; \\  &lt;input type=text name=title maxlength=20&gt;&lt;br&gt; \\ \\  &lt;b&gt;תוכן ההודעה&lt;/b&gt;&lt;br&gt; \\  &lt;textarea name=body&gt;&lt;/textarea&gt;&lt;br&gt; \\ \\  כתובת הדוא"ל של השולח&lt;br&gt; \\  &lt;input type=text name=email maxlength=40&gt;&lt;br&gt; \\  &lt;input type=submit&gt; \\  &lt;/form&gt; \\  &lt;/body&gt; \\  &lt;/html&gt; \\ \\ | |

\\ \\ \\  שום דבר לא מסעיר, ניתן הסברים לשורות שדורשות הסבר, למעשה המקטע המעניין הוא המקטע הבא: \\ \\

| | \\  &lt;form method=post action=mail.php&gt; \\  כותרת: (תיאור קצר וענייני)&lt;br&gt; \\  &lt;input type=text name=title maxlength=20&gt;&lt;br&gt; \\ \\  &lt;b&gt;תוכן ההודעה&lt;/b&gt;&lt;br&gt; \\  &lt;textarea name=body&gt;&lt;/textarea&gt;&lt;br&gt; \\ \\  כתובת הדוא"ל של השולח&lt;br&gt; \\  &lt;input type=text name=email maxlength=40&gt;&lt;br&gt; \\  &lt;input type=submit&gt; \\  &lt;/form&gt; \\ \\ | |

\\ \\  מקטע הקובץ הנ"ל הוא החלק בקוד ה html שמתאר את הטופס עם הפרטים למילוי. \\ \\  נסביר כל חלק וחלק במקטע זה: \\ \\

| | \\  &lt;form method=post action=mail.php&gt; \\ \\ | |

\\ \\  זוהי שורה סטנדטית של תגית form ב html, הפרמטר method מתאר כיצד יועברו המשתנים, במקרה שלנו השתמשנו ב post (זו בד"כ האפשרות הרצויה כשמשתמשים בתיבות מילוי של טקסט מסוג textarea), וה action מתאר איזה קובץ יופעל לאחר שנבצע submit (כלומר שליחת הקובץ). \\  במילים אחרות, בדוגמא שלנו ברגע שהמשתמש ילחץ על submit המשתמש (יחד עם הנתונים שהוקלדו בתיבות טקסט) יועבר לקובץ mail.php שבתקיה הנוכחית). \\ \\ \\ \\

| | \\  כותרת: (תיאור קצר וענייני)&lt;br&gt; \\  &lt;input type=text name=title maxlength=20&gt;&lt;br&gt; \\ | |

\\ \\  כאן כמובן מציגים כותרת לתיבת הטקסט הראשונה ובשורה השניה מציגים את התיבה. \\  הפרמטר שמעניין אותנו הוא name=title שאומר שברגע שהמשתמש יבצע "שליחה" לטופס, המשתנה שייצג את הטקסט שהוקלד בתיבת הטקסט הנ"ל הוא title, והיות ואנחנו עובדים ב POST אז, לקובץ mail.php יועבר המשתנה \\  $_POST["title"] \\ \\ \\

| | \\  &lt;b&gt;תוכן ההודעה&lt;/b&gt;&lt;br&gt; \\  &lt;textarea name=body&gt;&lt;/textarea&gt;&lt;br&gt; \\ \\ | |

\\ \\  כאן מוצגת כותרת לשטח הטקסט שישמש את המשתמש במערכת להקליד את גוף ההודעה שלו. \\  הפרמטר name=body מגדיר את המתשנה body כמיצג את הנתונים שימולאו בטופס. \\ \\  זהו אותו רעיון גם בקטע הבא של הכנסת כתובת המייל של המשתמש. \\  אני מניח שהרעיון ברור, לפיכך לא אמשיך להסביר את הנושא. \\ \\ \\  הערה: בד"כ נהוג לתת בדיקות ברמת jscript לטפסים שהלקוח מקליד, כדי לבדוק שהם מולאו בצורה תקינה עוד בטרם הוא שולח אותם לשרת, וכך, במקרה ובטעות הם לא מולאו בהצלחה (למשל המשתמש שכח לקליד כתובת דוא"ל, או הכניס נתון שגוי כלשהו), הלקוח לא צריך לחכות לקבל את תשובת השגיאה מהשרת, אלא הוא מקבל במיידית עם הנסיון לשלוח את הטופס הודעה בצורת חלונות msgbox שאומרת לו שהיתה שגיאה במילוי הטופס (עם הסבר על השגיאה כמובן). \\  זה כמובן לא מתחייב, ומדריך זה אינו מדריך ל javascript ככה שחסכתי כמה שורות קוד... \\

===== [[|5.3]] קובץ התוכנית עצמה - mail.php =====

| | \\  &lt;? \\  $to = "root@localhost"; \\  $body = "this mail sent from mysite.com using formmail\n"; \\  ?&gt; \\  &lt;!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"&gt; \\  &lt;html&gt; \\  &lt;head&gt; \\  &lt;title&gt;טופס לשליחה בדואר אלקטרוני&lt;/title&gt; \\  &lt;meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-8-I"&gt; \\  &lt;/head&gt; \\  &lt;body dir=rtl&gt; \\  &lt;? \\  $title = $_POST["title"]; \\ \\  if ($title=="") \\  { \\  $title = "this mail posted using formmail - with no subject"; \\  } \\ \\  if ($_POST["body"]=="") \\  { \\  echo "שגיאה, נא הקלד תוכן להודעה&lt;br&gt;\n"; \\  echo "טופס לא נשלח!&lt;br&gt;\n"; \\  echo "&lt;/body&gt;\n&lt;/html&gt;\n"; \\  exit(); \\  } \\  if (strlen($_POST["email"])&lt;5) \\  { \\  echo "הקלד כתובת מייל חוקית&lt;br&gt;\n"; \\  echo "&lt;/body&gt;\n&lt;/html&gt;\n"; \\  exit(); \\  } \\ \\  $body .=$_POST["body"]; \\  mail($to,$title,$body); \\  echo "תודה, נשתל לענות בהקדם!\n"; \\  ?&gt; \\  &lt;/body&gt; \\  &lt;/html&gt; \\ \\ | |

\\ \\ \\  כדי ללמוד כיצד הקובץ עובד, אני מציע לך לנצל את ההזמנות ועכשיו להציץ בו, בטרם אני אסביר שורה שורה, ולנסות להבין לבד מי נגד מה. \\  סביר להניח שכמה דברים לא יהיו ברורים (וזה בסדר לא להתרגש) - ההסבר המלא, בשורות הבאות. \\ \\

| | \\  &lt;? \\  $to = "root@localhost"; \\  $body = "this mail sent from mysite.com using formmail\n"; \\  ?&gt; \\ | |

\\ \\  הגדרנו משתנים כללים. \\  המשתנה הראשון, הלא הוא to$, מיועד להגדרת היעד למשלוח הטופס, כלומר מיהו אותו נמען שיקבל את הדואר. \\  במקרה שלנו, בחרנו במנהל המערכת של המחשב המקומי (המחשב שמארח את השרת) - המנהל הוא המשתמש root (במערכות יוניקס) והכתובת localhost מתארת את המחשב המקומי. \\  כדי שהמייל באמת יגיד ליעדו שרת המייל צריך לעבוד (וה PHP צריך לתמוך בו, בד"כ זה המצב). \\  אם שרת ה DNS יעבוד "כמו שצריך" אז אפשר לתת בתור נמען (למשתנה to$) כל כתובת אימייל ולא רק כתובת מייל פנימיות של השרת. \\ \\  המשתנה השני שהגדרנו, body$ כולל בתוכו מחרוזת שתוכנס למייל שישלח (בתור שורה ראשונה בתוכן הדואר שיתקבל). \\ \\

| | \\  $title = $_POST["title"]; \\ \\  if ($title=="") \\  { \\  $title = "this mail posted using formmail - with no subject"; \\  } \\ | |

\\ \\  במקטע הקוד הנ"ל לקחנו את המשתנה title שהועבר בעזרת POST והכנסנו אותו למשתנה $title. \\  ואז אנחנו מפעילים בעזרת הלולאה if, בדיקה האם המשתנה $title מכיל מחרוזת ריקה (הגרשיים של הערך שמושווה נפתחים ונסגרים בלי שום ערך). \\  במילים אחרות, בדקנו האם המשתמש לא הקליד שום דבר בתור כותרת למכתב, במידה והתשובה חיובית, יבוצע מקטע הקוד שבתוך הסוגריים המסולסלים, ואנחנו מכניסים למשתנה title$ טקסט כלשהו, שבסה"כ אומר שזה מייל שהגיע מיישום ה formmail. \\  כמובן שהבדיקה הנ"ל לא חשובה, אפשר לאפשר מייל ללא שום כותרת, אבל ההנחה היא שיותר קל כשבשורת הכותרת של המייל, יש הודעה שמסבירה מה פשר המייל. \\ \\

| | \\  if ($_POST["body"]=="") \\  { \\  echo "שגיאה, נא הקלד תוכן להודעה&lt;br&gt;\n"; \\  echo "טופס לא נשלח!&lt;br&gt;\n"; \\  echo "&lt;/body&gt;\n&lt;/html&gt;\n"; \\  exit(); \\  } \\ | |

\\ \\  במקטע הקוד הנ"ל ביצענו בדיקה פשוטה האם המשתנה body מסוג POST אינו כולל שום ערך, או במילים אחרות האם נשלח מכתב עם תוכן ריק. \\  במידה והתשובה חיובית, המקטע שבתוך הסוגריים המסולסלים מתבצע, ומוצגת הודעת שגיאה. \\  ההנחה היא שלא רוצים לקבל מייל ללא תוכן. \\  שורה אח"כ בעזרת הפקודה echo שולחים למסך את התגיות של סיום מסמך ה html ויוצאים החוצה או אם נרצה מפסיקים את הרצת הסקריפט בעזרת הפונקציה המובנית ב PHP הלא היא exit, היות ואנחנו לא רוצים להמשיך לבצע את הסקריפט (השארנו הודעת שגיאה למשתמש, אין טעם להמשיך להריץ את הסקריפט). \\ \\ \\

| | \\  if (strlen($_POST["email"])&lt;5) \\  { \\  echo "הקלד כתובת מייל חוקית&lt;br&gt;\n"; \\  echo "&lt;/body&gt;\n&lt;/html&gt;\n"; \\  exit(); \\  } \\ \\ | |

\\ \\  כאן אנחנו יכולים לשכלל את הקוד, בכוונה בחרתי במשהו די בסיסי. \\ \\  בגדול, אנחנו רוצים לבדוק האם המשתמש הקליד כתובת אימייל חוקית, אחרת אנחנו לא רוצים לקבל את הדוא"ל, כי אין סיבה לקבל הודעה ארוכה ללא יכולת להשיב לפונה. \\  הבדיקה שמתבצעת בדוגמא שלנו, מתבססת על הפונקציה strlen שהיא פונקציה שמחזירה את מספר התווים שמייצגים את המחרוזת שמועברת אליה כפרמטר. \\  במקרה שלנו, מעבירים את המשתנה email מסוג POST לתוך הפונקציה, וביצענו השוועה האם הערך קטן מ 5. \\  אם הערך קטן מחמש, נכנסים לתוך הסוגרים המסולסלים שבהם ישנה הודעה שכתובת המייל אינה חוקית והסקריפט יפסיק לרוץ בעזרת exit. \\ \\  כמובן שהבדיקה היא פרמיטיבית מאוד, היה טוב יותר לבדוק האם מבנה כתובת המייל היא חוקית, כלומר לבצע בדיקות כגון: האם יש את התו '@' שנמצא בין שם וכתובת שרת חוקיים. \\  יש מגוון אפשרויות לבצע את זה, בד"כ נהוג להשתמש ב regex לביצוע מסימות אלה. \\  השימוש ב regex אינו קל מדי בלשון המעטה, ודורש לא מעט אימון (בסופו של דבר משתלם בהחלט). \\  מעבר לזה, אפשר להשתמש בפונקציות אחרות של php שיודעות לקבל ערכים שונים בהקשר ל"מחרוזות" ולתת לנו בדיקה מהימנה יותר לגבי ה"מחרוזת" (האם היא חוקית בכלל בתור כתובת דוא"ל). \\  את הנושא הזה אני משאיר לך כ"שיעורי בית" :-) . \\ \\  בכל מקרה, המשך הקוד: \\

| | \\  $body .=$_POST["body"]; \\  mail($to,$title,$body); \\  echo "תודה, נשתדל לענות בהקדם!\n"; \\ \\ | |

\\ \\  אחרי שעברנו בדיקות לגבי שלושת השדות נותר רק לשלוח את הדוא"ל עצמו. \\  בשורה הראשונה אנחנו מצרפים למשתנה body$ את הערך של המשתנה body$ מסוג POST. \\  במילים אחרות: \\  אנחנו רוצים שההודעה שמיצג המשתנה body$ (ההודעה היא תוכן המשתנה כפי שהגדרנו בתחילת הקובץ) תופיע ולאחריה יופיע התוכן של ההודעה שהוקלדה על ידי המשתמש (והמייוצגת על ידי משתנה body$ שהוא משתנה אחר בסופו של דבר, והוא מהסוג POST$). \\  יכלנו לכתוב את הקוד ככה: \\

| | \\  $body = $body.$_POST["POST"]; \\ | |

\\ \\  שאומר שהמשתנה body החדש, שווה למשתמה body$ הישן בתוספת (שרשור של משתנים נעשה בעזראת האופרטור נקודה) התוכן של מה שהמשתמש הקליד (המשתנה body$ מסוג POST). \\ \\  בכל מקרה, בדוגמא שלנו, בחרנו בכתיב מקוצר של אותה פעולה, על ידי שימוש באופרטור נקודה לפני הסימן שווה. \\  האופרטור נקודה אומר להכניס למשתנה שמשאל לסימן '=' את הערך הקודם שלו ולהוסיף את הערך שמימינו. \\  מבולבל מעט? לא נורא, שחק עם הקוד ואני בטוח ששניים שלושה נסיונות והכל ברור... \\ \\  לאחר מכן מבצעים את שליכת המייל עצמה, בעזרת הפקודה mail. \\  כדי לדעת אילו פרמטרים להכניס אליה, והאם בכלל היא קיימת נעזרתי במדריך הרשמי של php. \\  חיפוש אחר הנושא של mail (במקרה דרך האתר www.php.net ) העביר אותי לעמוד שמתאר את הפונקציה (הסבר קצרצר והדגמה אודותיה). \\  מבנה הפונקציה, על פי המדריך הרשמי הוא הבא: \\

| | \\  bool mail ( string to, string subject, string message [, string additional_headers [, string additional_parameters]]) \\ | |

\\ \\ \\  בגדול, מה שזה אומר שהפונקציה מחזירה ערך מסוג bool או בוליאני, כלומר true אן false (אלו הערכים שיכולים להחשב כבוליאנים). \\  הפרמטר הראשון שמועבר לפונקציה הוא string to כלומר משתנה מסוג string שהתיאור שלו הוא to, כלומר מעבירים מחרוזת שמתארת את כתובת היעד למשלוח הדוא"ל. \\  הפרמטר השניה הוא פרמטר מסוג מחרוזת (string) שהתיאור שלו הוא subject כלומר כותרת ההודעה שנשלח (מה יופיע בשורת ה subject אצל הלקוח. \\  הערך השלישי הוא גם כן משתנה מסוג מחרוזת שהתיאור שלו הוא message כלומר תוכן ההודעה עצמה. \\  התיאור של כל פרמטר הוא למעשה שם המשתנה בתוך הקוד מקור של php (אם נציץ בקוד של php עצמה נוכל לראות את המשתנים הללו). \\  לא תמיד השמות מספיק ברורים, ולכן במדריך הרשמי יש הסברים מפורטים בד"כ לגבי כל פרמטר ופרמטר בהתאם לצורך. \\ \\  הפרמטרים שאפשר להעביר אח"כ הם פרמטרים שלא חובה להעביר אותם (הם מופקים בסוגרים מרובעים שאומרים שאלו פרמטרים של רשות). \\  אני משאיר לך כתרגיל לבדוק במדריך הרשמי למה נועדו פרמטרים אלו בדיוק וכיצד משתמשים בהם.

----

====== ו. תוכנית שניה - מונה צפיות. ======

[[#index6|עבור לאינדקס השאלות של פרק זה]]

===== [[|6.1]] על התוכנית בפרק זה. =====

מטרת התוכנית היא לתת מונה של צפיות בעמודים (מספר הצפיות בעמודים שונים באתר). \\  כדי לאפשר זאת, נתבסס על מסד הנתונים Mysql לאכסון של הנתונים ולקבלת המידע הרלוונטי. \\ \\  המטרה: תוכנית גמישה ככל שניתן, שתאפשר לנו להוסיף עוד ועוד עמודים למנייה בהתאם לגדילת ושינוי האתר עם הזמן. \\  כדי לפשט את ההסבר, לא ניתן את הקוד לניהול המערכת, אלא ביצירת המסד נתונים נכניס שלושה ערכים להדגמה (שיהוו שלושה עמודים שונים באתר, שלהם נבצע מניה). \\ \\  הקוד הוא קוד מפושט, ולא נכנס לנושאים כגון שימוש בעוגיות על מנת למנוע הקלקות כפולות של משתמש, ומבחינתנו, כל צפיה בעמוד (גם בעת ביצוע רענון של התצוגה אצל המשתמש) תספר.

===== [[|6.2]] בנית מסד הנתונים. =====

אנחנו נשתמש במסד נתונים מסוג Mysql. \\  אחרי שדאגנו שהמסד מותקן במערכת ורץ, נצטרך ליצור מסד בשם counter, שלתוכו יוכנסו הנתונים. \\  כדי לסבר את האוזן למי שלא מכיר את Mysql: מסד הנתונים של Mysql כולל מערכת הרשאות פנימית שכוללת שם משתמש וסיסמא. \\  כל משתמש יכול לקבל הרשאות שימוש על מסד אחד או יותר. \\  החלוקה למסדים מאפשרת למשתמש לנהל ביעילות פרוייקטים שונים, עם טבלאות שונות בלי שתהיה התנגשות בינהם. \\  העבודה מול mysql נעשית בד"כ תוך שימוש בכלים טקסטואלים. \\  אפשר לראות במסד ה SQL כאוסף של טבלאות, שניתן לעבוד מולם במהירות וביעילות רבה יחסית. \\ \\  נחזור לדוגמא שלנו. \\  ראשית, יוצרים את מסד הנתונים/ \\  התחביר ליצירת מסד הנתונים הוא: \\

| | \\  mysqladmin -u username -ppassword create databasename \\ | |

\\ \\  כשאם הססמא של המסד SQL שלנו היא 123456, שם המשתמש שלנו הוא root (זה מסד שאינו קשור למשתמש root במערכות יוניקס !), ובהנחה שאנחנו רוצים ששם המסד יהיה counter אז מה שצריך להקליד יראה ככה: \\ \\

| | \\  mysqladmin -u root -p123456 create counter \\ | |

\\ \\ \\  עכשיו, אנחנו רוצים לבנות את הטבלאות של Mysql ולהכניס להם ערכים ראשונים של שלושה עמודים שונים בתור הדגמה. \\ \\  כדי לבצע זאת עלינו ליצור קובץ של מסד הנתונים, שאותו נוכל להעביר ל mysql. \\  ככה נראה קובץ ה mysql בתצורת טקסט: \\ \\

| | \\  ############ \\  # SQL schema \\  ############ \\  DROP TABLE IF EXISTS counter; \\  CREATE TABLE counter ( \\  id int(10) unsigned DEFAULT '0' NOT NULL auto_increment, \\  label varchar(255) NOT NULL, \\  count int(10) unsigned DEFAULT '0' NOT NULL, \\  PRIMARY KEY (id) \\  ); \\  INSERT INTO counter VALUES ("","עמוד ראשי","0"); \\  INSERT INTO counter VALUES ("","עמוד שני","0"); \\  INSERT INTO counter VALUES ("","עמוד שלישי","0"); \\ | |

\\ \\  יש לשמור את התוכן של הקוד בתיבה הנ"ל בתור קובץ טקסט, אני קראתי לו schema.sql שכן זה השם שמתאר אותו נכון. \\  קובץ זה (שלא קשור ל php עדיין) הוא קובץ טיפוסי של Mysql \\  הוא בשורה הראשונה מבצע DROP, כלומר מחיקה של טבלה בשם counter אם קיימת ואח"כ יוצר טבלה בשם counter \\  לטבלה נקבעים שלושה שדות: \\ \\  א. \\

| | \\  id int(10) unsigned DEFAULT '0' NOT NULL auto_increment, \\ | |

\\ \\  השדה הראשון הוא שדה ששמו id והוא משתנה מספרי שלם (int) חיובי (שכן הוא unsigned) , שערכו בברירת מחדל הוא 0 והוא מסוג auto_increment כלומר, בכל פעם שיוצרים רשומה חדשה במסד הנתונים (שאילתה מסוג insert) הרשומה תקבל ערך שגודל באחד. \\  המספר 10 בסוגריים מתאר את מספר הספריות שיכולות לייצג את המספר, במקרה שלנו החל מ 0 ועד למספרים בני 10 ספרות... (מספרים מאוד גדולים שסביר להניח שלא נעבור לעולם....). \\ \\  זה מאפשר לנו לתת ערך חד חד ערכי לכל רשומה, בתצורת מספר שגדל עם כל רשומה חדשה, מאוד נוח ככה לפנות לרשומות השונות, כפי שנראה בהמשך. \\ \\  ב. \\

| | \\  label varchar(255) NOT NULL, \\ | |

\\ \\  כאן הוגדרה עמודה מסוג varchar שהוא שדה שיכול להכיל משתנים תווים ששמו label והוא למעשה ישמש אותה להגדרה של הסבר מילולי לגבי כל עמודה ועמודה, ככה שנוכל בהמשך הדרך, לראות בקלות למה קשורה כל רשומה (בעזרת המאפיין הזה, שהוא לא חד חד ערכי אבל הוא ברור יותר במבט אינושי מסתם מאשר המספרים שמיצגים כל רשומה בשדה id). \\  גודל השדה הוא עד 255 תווים שונים... בקיצור. \\ \\  ג. \\

| | \\  count int(10) unsigned DEFAULT '0' NOT NULL, \\ | |

\\ \\  כאן הגדרנו משתנה מסוג מספר (int) שהוא חיובי (unsigned) שערכו בברירת המחדל הוא אפס. \\  שדה זה הוא השדה שישמש אותנ למנית מספר הצפיות בכל עמוד ועמוד. \\ \\ \\ \\

| | \\  PRIMARY KEY (id) \\ | |

\\ \\  בשורה זו פשוט ציינו שהערך בשדה id הוא מסוג PRIMARY KEY מה שבגדול אומר שהוא חד חד ערכי. \\ \\

| | \\  INSERT INTO counter VALUES ("","index","0"); \\  INSERT INTO counter VALUES ("","who","0"); \\  INSERT INTO counter VALUES ("","where","0"); \\ | |

\\ \\  השורות הנ"ל פשוט מכניסות שלושה ערכים לתוך מסד הנתונים. \\  כל רשומה במסד מתייחס לעמוד אחר באתר שלגביו אנחנו בונים "מונה צפיה". \\ \\  הפרמטר הראשון שאנחנו מעבירים בכל רשומה הוא "" כלומר מחרוזת ריקה. למה? בגלל שהערך בכל מקרה יקבע על ידי Mysql כי העמוד הראשונה היא מסוג auto_increment. \\ \\  הפרמטר השני הוא מספר שמתאר את מספר הצפיות. \\  כמובן שהמספר הרצוי הוא 0 (אם היינו מעבירים "" , כלומר מחרוזת ריקה, בגלל ההגדרה של הטבלה כ default 0 בעמודה זו, היינו זוכים לאותו אפקט כמובן). \\ \\  הפרמטר השלישי הוא מחרוזת שמתארת כל עמוד בצורה "אנושית" (למעשה עדכון העמודה label), אפשר ורצוי לתת ערך שיתאר בצורה הכי ברורה את שם העמוד המשוייך אליו. \\ \\  בחזרה לתוכנית. \\  אם כן, אחרי ששמרנו את סכימת המסד בתור קובץ בשם schema.sql הגיע הזמן להכניס את הסכימה לתוך המסד נתונים. \\  כדי לבצע זאת,בהנחה ששם המסד הוא counter שם המשתמש הוא root והססמא היא 123456 (בהמשך לפקודה שהשתמשנו לבנית המסד בתחילת הפרק), נריץ את הפקודה הבאה \\ \\

| | \\  mysql -u root -p123456 counter &lt; schema.sql \\ | |

\\ \\ \\ \\ ** הערה חשובה:** מטרת המדריך היא לא ללמד Mysql לפיכך, לא ירדתי יותר מדי לעומק, למי שרוצה יודעת יותר על שימוש ב Mysql, אני ממליץ לקרוא את המדריך של [[mailto:karielATpenguin.org.il|כתריאל טראום]] על Mysql באתר הפינגווין. \\  המדריך של כתריאל זמין בכתובת הבאה: \\

| | \\ http://www.penguin.org.il/guides/mysql-intro\\ | |

\\ \\  כמו כן ישנו המדריך הרשמי של mysql הזמין להורדה באתר הבית של mysql. \\

===== [[|6.3]] הקובץ count.inc.php - סופסוף קוד ה PHP =====

הקוד של העמוד הוא הקוד הבא: \\

| | \\  &lt;? \\  /*********************************************************** \\  *** counter.php - simple counter system (php+mysql based *** \\  *** Under GNU GPL licenced *** \\  ************************************************************/ \\ \\  // connection to mysql server function ! \\  $con = mysql_connect("localhost","root","123456") or die ("could not connect:"); \\  // echo $con; \\  mysql_select_db("counter",$con); \\  // we update counter here ! \\ \\  $id = $_GET["id"]; \\ \\ \\  $SQL = "UPDATE counter SET count=count+1 WHERE id=\"".$id."\" "; \\  mysql_query($SQL) or die ("&lt;b&gt;ארעה שגיאה בשאילתת SQL בפונקציה counter &lt;br&gt;".mysql_error()); \\ \\  $SQL = "SELECT count from counter WHERE id=\"".$id."\""; \\  $res = mysql_query($SQL) or die ("&lt;b&gt;ארעה שגיאה בשאילתת SQL בפונקציה counter &lt;br&gt;".mysql_error()); \\  $row = mysql_fetch_array($res, MYSQL_ASSOC); \\  $count = $row["count"]; \\  mysql_free_result($res); \\ \\ \\  ?&gt; \\ \\ | |

\\ \\ \\  הגיע הזמן להסביר את חלקי הקוד השונים: \\ \\

| | \\  $con = mysql_connect("localhost","root","123456") or die ("could not connect:"); \\ | |

\\ \\  הפקודה הנ"ל מחברת אותנו אל מסד הנתונים. \\  כדי לעבוד מול mysql אנחנו צריכים להתחבר למסד, בעזרת הפונק' mysql_connect. \\  הפרמטר הראשון, localhost אומר שה mysql רץ במחשב המקומי (באותו שרת שמריץ את השרת אינטרנט, אם מדובר בשרת מרוחק צריך לתת את ה IP כמובן) \\  הפרמטר השני הוא שם המשתמש של מסד הנתונים במקרה שלנו root והפרמטר השלישי הוא הססמא, שהגדרנו למשתמש, במקרה שלנו 123456 \\  יש לשים לב שהשארנו אופציה, במקרה והפונקציה תכשל (למשל, הססמא תהיה שגויה) אז תופעה הפונקציה die שמקבלת כפרמטר את הודעת השגיאה שתוצג על המסך. \\  הפונקציה die מה שהיא עושה זה שני דברים: \\  מציגה את ההודעה שמועברת אליה (במקרה שלנו Could not connect) ולאחר מכן מפסיקה את הרצת הסקריפט (אין טעם להריץ אותו אם אין חיבור בהצלחה למסד הנתונים בד"כ). \\  יש לשים שאת הערך שמוחזר מ mysql_connect הכנסנו לתוך המשתנה $con וזאת מכיוון של $con יש מטרה מאוד מיוחדת במקרה הזה. \\  הוא ה reasorce id שלנו, או בעברית פשוטה, הוא משתנה מיוחד שמכיר את הערך של החיבור למסד הנתונים, והוא נדרש לנו בסגירת החיבור (במידה ורוצים לסגור אותו כדי לחסוך במשאבים של השרת) וחשוב לא פחות, הוא ידרש לנו במספר פקודות שידרשו אותו, כפי שנראה כבר בפקודה הבאה ! \\ \\

| | \\  mysql_select_db("counter",$con); \\ | |

\\ \\  כאן אנחנו הפעלנו את הפקודה mysql_select_db שמאפשרת לנו להתחבר למסד נתונים מסויים. \\  אחרי שכבר יש לנו חיבור למערכת ה Mysql מהפקודה הקודמת, והיות וקיבלנו בתור משתנה את ה"משאב חיבור" מה שנותר זה לבחור את המסד נתונים שאיתו עובדים. \\  במקרה שלנו הפרמטר הראשון שנעביר הוא counter שהוא המחרוזת שמייצגת את שם מסד הנתונים שאיתו אנחנו עובדים, והפרמטר השני הוא המשתנה $con שהוא ה resource id שלנו. \\ \\

| | \\  $id = $_GET["id"]; \\ | |

\\ \\  כאן ביצענו הצבה פשוטה של המשתנה id מסוג GET לתוך משתנה id$. \\  המשתנה הזה מייצג את ה id של אותו עמוד שנרצה לעדכן. \\  כלומר, אם נבצע לעמוד include מעמוד אחר, נעביר בתור משתנה GET$ אם מספר ה id שמתאים לעמוד שאותו נרצה לעדכן. \\  ברגע שנכליל את קובץ זה, בהנחה שבתור משתנה GET (בעזאת ה URL) יהיה מוגדר ש id = 1 אז המשתנה $id יקבל את הערך 1 מה שכפי שנראה בהמשך יגרום למונה להגיד את עצמו ב - 1. \\ \\ \\

| | \\  $SQL = "UPDATE counter SET count=count+1 WHERE id=\"".$id."\" "; \\ | |

\\ \\  זה כבר מתחיל לבלבל ! \\  מה עשינו כאן: בגדול, הגיע הזמן להריץ שאילתת SQL שמה שהיא צריכה לעשות זה לעדכן את המסד נתונים, לערך החדש. \\ \\  כדי לבצע זאת חילקנו את בנית השאילתה לשני חלקים (מטעמי נוחות וקריאות של הקוד) החלק הראשון, הוא החלק המוצג כאן, והוא יצירת השאילת כמחרוזת שמוצבת לתוך משתנה בשם SQL$. \\  זה רעיון טוב תמיד לבצע ככה את השאילתות SQL כי זה תורם לקריאות הקוד בצורה משמעותית (גם אם זה לא נראה ככה כרגע...). \\ \\  בכל מקרה, אנחנו משתמשים בשאילתה מסוג UPDATE שתפקידה לבצע עדכון של נתונים ברשומה מסויימת. \\ \\  אז מה קורה שם בדיוק? כבר מגיע ההסבר, לא להבהל. \\  המילה UPDATE אומרת שזו שאילתה מסוג UPDATE \\  ואז באה המילה counter שהיא שם הטבלה שעליה מתבצע השינוי. \\  המילה SET היא חלק מהפקודה UPDATE והיא אומרת שלאחריה ינתן הערך החדש בטבלה, במקרה שלנו אנחנו מעדכנים את העמודה count ונותנים לה את הערך count+1 \\  אם כאן היתה מסתיימת השאילתה החיים היו קלים יחסית, אלא מה? במקרה כזה בכל הרשומות (כולל אלו של הדפים האחרים) היה השדה של count גודל באחד, אבל אנחנו רוצים שרק במקרה שבו id הוא אותו id$ שקיבלנו בעזרת GET תתבצע הפעולה, ולכן אנחנו מוסיפים את התנאי "היכן ש" או WHERE. \\ \\  היות והמקטע הזה מעט מסובך אני מעתיק שוב את חלק הקוד המסובך להבנה, להסבר מעמיק: \\

| | \\  WHERE id=\"".$id."\" " \\ | |

\\ \\  אם כן מה קורה כאן? \\  בגדול, המבנה אמור להיות WHERE id=1 אבל החלטתי לשנות את המבנה (וזה חוקי מבחינה תחבירית) ל WHERE id="1", היות ולעיתים משפט ה WHERE יתייחס ל "תווים" ובמקרה כזה חייבים להשתמש בגרשיים שיתחמו את הביטוי. \\  נחזור למקרה שלנו, לאחר id= יש "סלאש" שאומר ל php שהתו הבא יוכנס למשתנה (במקרה שלנו SQL ) כמו שהוא ולא יציין סוף של מחרוזת (להזכיר, המחרוזת שמוכנסת ל SQL תלומה בגרשיים בתחילה ובסוף) היות וה " הנ"ל מייצג את הגרש הראשון לפני המספר שמועבר ל WHERE . \\  לאחריו יש עוד גרש, הפעם בלי סלאש לפניו, מה שאומר שכרגע סיימנו את המחרוזת. \\  אלא מלא, לאחריה בא האופרטור נקודה, הוא מציין שאנחנו משרשרשים עוד מחרוזת או משתנה (שמייצג מחרוזת) למחרוזת, במקרה שלנו זה המשתנה $id שקיבלנו בשלב מוקדם יותר. \\  לאחריו יש נקודה שאומרת שאנחנו רוצים לשרשר עוד משהו, יש גרשיים שאומרים שאנחנו משרשרשים מחרוזת (ולא משתנה נוסף) ויש סלאש ותו '"' שאומר שגרשיים אלו ייהיו בהמשך המחרוזת (המשך השרשור של המחרוזת) ואז יש גרשיים נוספים שמסיימים את התיחום של המשפט. \\ \\  מסובך לך? ייתכן, זה מסובך לכולם בהתלחה. \\  אבל זה הזמן להוסיף לתוכנית בשורה הבאה: \\

| | \\  echo $SQL \\ | |

\\ \\ \\  ולשחק עם המחרוזת שמוצבת בתוך SQL ולהבין בדיוק את הנושא... כמה דקות של מסחק, וזה אמור להיות ברור יותר... \\  אל תבהל, אין הרבה דברים מבלבלים כמו הנושא של בניית מחרוזות שישמשו בתור שאילתת SQL, וכולם מתבלבלים בהתחלה... \\  זה הזמן להתאמן על זה קצת... ולהבין לאט לאט שזה לא כל כך נורא. \\ \\

| | \\  mysql_query($SQL) or die ("&lt;b&gt;ארעה שגיאה בשאילתת SQL בפונקציה counter &lt;br&gt;".mysql_error()); \\ | |

\\ \\  הפונקציה mysql_query פשוט מפעילה את ה"שאילתה" שמועברת אליה בתור פרמטר, במקרה שלנו השאילתה היא המחרוזת שמוצבת בתוך SQL ושאותה בנינו בשורה הקודמת. \\  אם השאילתה תכשל, וזה יכול לנבוע משגיאות תחביר או בעיה אחרת, אז תופעה הפונקציה die שתציג הודעה שגיאה מסודרת, תרד שורה (תגית ה html &lt;br&gt;) ואז (בעזרת השרשור, שים לב לאופרטור נקודה אחרי הגרשיים שמסיימות את המחרוזת) תפעיל את mysql_error שהיא פונקציה מיוחדת שמחזירה את ההודעת שגיאה האחרונה שמסד הנתונים החזיר - במילים אחרות, אחרי שורת הרווח, תוצג הודעת השגיאה הרלוונטית, מה שיכול לעזור לנו להבין מה לא עשינו טוב. \\  המשתנה $res מקבל "resource id", ויש לו שימוש מיוחד - נוכל לבצע פעולות המשך (כמו במקרה שלנו. \\ \\

| | \\  $SQL = "SELECT count from counter WHERE id=\"".$id."\""; \\ | |

\\ \\  כדי שנוכל לקבל את הערך של המונה (במידה ונרצה להציג את מספר המניה על המסך) אנחנו יוצרים שאילתה חדשה. \\  השאלה היא מסוג SELECT (שאילתה זו מאפשרת לנו לקבל נתונים מהמסד) המילה count אומרת שמה שאנחנו רוצים לקבל זה ערכים של count (מניה), אם נרצה לקבל גם ערכים אחרים נפריד את הערכים האחרים בפסיקים. \\  לאחר מחר אנחנו מבקשים לבחור את הנתונים מתוך הטבלה counter ולבסוף אנחנו מבצעים את משפט התנאי WHERE כשהתנאי הוא כש id = $id , כלומר לקבל רק את הרשומה שקשורה לעמוד הנוכחי ! \\ \\

| | \\  $res = mysql_query($SQL) or die ("&lt;b&gt;ארעה שגיאה בשאילתת SQL בפונקציה counter &lt;br&gt;".mysql_error()); \\ | |

\\ \\  אנחנו מפעילים את שאילתת ה SQL שבנינו בשורה הקודמת, וכרגיל במקרה ויש שגיאה מפסיקים את התוכנית עם הצגת הודעת שגיאה רלוונטית. \\  מעבר לזה, אנחנו הפעם שומרים גם את ה resource id שרלוונטי לשאילתה, היות ובהמשך אנחנו צריכים להכניס את הנתונים לתוך משתנים (במקרה שלנו רק נתון אחד), וכדי להכניס אותם נצטרף כפי שנראה בהמשך את המשתנה הזה. \\ \\ \\

| | \\  $row = mysql_fetch_array($res, MYSQL_ASSOC); \\ | |

\\ \\  מה שביקשנו בשורה זאת היא לבצע fetch או שליפה של הנתונים כ array (כלומר המשתנים שיתקבלו יהיו במבנה של "מערך"). הפרמטרים שהועברו לפונקציה הם $res שהוא ה"משאב" שהאילתה הקודמת, של ה select יצרה, כלומר שבמשאב זה הנתונים שלהם אנחנו זקוקים, וכן הפרמטר השני שאומר שה array הוא מסוג associative או hash , כלומר מערכת שהאיברים השונים שלו הם הערים שהתקבלו מהמסד ואילו בתוך הסוגרים המרובים (האידקס של המערך אם נרצה) מורכבים מהשדה הרלווטי במסד. \\  את הנתונים שקיבלנו מה fetch אנחנו שומרים בתוך $row, כדי שנוכל לגשת אליהם. \\  במקרה שלנו יש רק משתנה אחד רלוונטי, כי לולאת ה where בשאילת ה הקודמת הגבילה את התשובה רק ל "רשומה אחת" ורק שדה אחד נבחר על ידי select הלא הוא שדה ה "count". \\ \\

| | \\  $count = $row["count"]; \\ | |

\\ \\ \\  העברנו את הערך של המשתנה מסוג array שמתאר את מה שבקשנו, שזה מספר המניות של הרשומה המסוימת, לתוך משתנה פשוט בשם count. \\  עכשיו אנחנו יכולים להציג את המספר וכו' בהתאם לדרישות של התוכנית (למשל להציג את ההודעה: "עד עכשיו עמוד זה נצפה xx פעמים"). \\ \\

| | \\  mysql_free_result($res); \\ | |

\\ \\  סגרנו את המשאב של res$ שכן כשהמשאב פתוח, משמע עומס על המסד נתונים. \\  ברגע שגרמנו להשתמשו בו פשוט סגרנו אותו. \\ \\  תוספת: כדי להבהיר יותר את הנושא של קבלת נתונים (fetch) יש מספר אפשרויות ב php לביצוע הפעולה (כולם מתועדות נהדר). \\  אם אנחנו רוצים ליצור תצוגה על המסך של כל הערכים בטבלה שלנו, אנחנו יכולים להשתמש בקוד הבא: \\

| | \\  $SQL = "SELECT * from counter"; \\  $res = mysql_query($SQL) or die ("&lt;b&gt;ארעה שגיאה בשאילתת SQL בפונקציה counter &lt;br&gt;".mysql_error()); \\  while ($row = mysql_fetch_array($res, MYSQL_ASSOC)) \\  { \\  echo "id=".$row["id"]." "; \\  echo "label=".$row["label"]." "; \\  echo "count=".$row["count"]."&lt;br&gt;\n"; \\  } \\ \\ | |

\\ \\  בשורה הראשונה שאילת ה SQL שיצרנו היא שאילתה שלוקחת את כל השדות (*) מהרשומת, ואין תנאי לגבי הרשומות (ככה שכולם נבחרות). \\ \\  השורה הבאה פותחת לולאת while שמתקיימת כל עוד יש עוד נתונים לקבלה. \\  כל מחזור של הלולאה עוברים לרשומה הבאה. \\  מה שקורה בתוך הסוגריים המסולסלות זה אני מניח ברור, פשוט מציגים על המסך את הערכים של כל משתנה ומשתנה בליווי של כיתוב שמבהיר מה הוא מייצג.

----

**המדריך תחת רשיון ה [[http://www.gnu.org/copyleft/fdl.html|GFDL]]**\\  ניתן לקרוא את הגרסא המתורגמת (תרגום לא משפטי) של רשיון זה [[http://www.cs
.technion.ac.il/~erelsgl/tnk/rjyon_bivrit.html|כאן]]\\  תרגיש חופשי להשתמש במדריך ולהעתיק חלקים ממנו, על פי תנאי הרשיון\\  המדריך נכנתב על ידי [[mailto:barak@php.org.il|ברק]] לשימוש [[http://www.penguin.org.il|אתר הפינגווין]] שם אפשר למצוא את הגרסא המעודכנת האחרונה של המדריך. \\