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

להלן רשימת הטכניקות והטיפים:

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

קוד PHP:

 $i++; 


דרך שנייה, נקראת פרה-קידום:

קוד PHP:

 ++$i; 


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

[ למידע על פרה\פוסט-קידום\הפחתה אפשר למצוא, לדוגמא, באתר של איתן: http://php.eitan.ac.il/main.php?id=00132
או באתר של PHP הרישמי: http://il2.php.net/manual/en/langua...s.increment.php ]

2. בדיקת זוגיות של מספר:

בדר"כ כשבודקים אם מספר הוא זוגי או לא, מריצים את הקוד הבא:

קוד PHP:

 if ( ($i % 2) == 0 )
    # it's dual 


אבל זה ידוע שפעולות מתמטיות יעילות פחות מאשר פעולות לוגיות, לכן עדיף יותר לבצע את הפעולה הבאה:

קוד PHP:

 if ( ($i & 1) == 0 )
    # it's dual 


בפעולה זו אנו בודקים אם הסיבית האחרונה של מספר (בצורתו הבינארית) היא '0' לוגי או '1' לוגי.
אם הסיבית האחרונה (LSB = Least Significant Bit) היא 1, אז המספר הוא אי-זוגי.
אם הסיבית האחרונה (LSB ... ) היא 0, המספר זוגי.

[ למידע על אופרטורים לוגים מהאתר של איתן: http://php.eitan.ac.il/main.php?id=00129
מהאתר של PHP הרישמי: http://il2.php.net/manual/en/langua...ors.bitwise.php ]

3. שימוש ב-isset בלולאת FOR:

ברוב קודי ה-PHP ואולי בכולם תמיד תצטרכו לבצע פעולה של לולאת FOR.

בדר"כ, הקוד ייראה בצורה הבאה (או יהיה דומה לו):

קוד PHP:

 $big_array = (/*...*/);

for ($i=0; $i < count($big_array); $i++)
{
    /* Do Something */
} 


שימוש בפונקציה count (או בפונקציה strlen, במקרה שמריצים את לולאת ה-FOR על מחרוזת) הוא מיותר, וסתם מבזבז משאבים חיוניים.
ואם אני לא טועה, עפ"י כתיבת התנאי של הלולאה בצורה הבאה:

קוד PHP:

 /*...*/$i < count($big_array)/*...*/ 


הפונקציה count תרוץ כל פעם מחדש, מה שגורם לחיסרון די משמעותי מבחינת היעילות, שכן הדרך הבאה עדיפה יותר:

קוד PHP:

 /*...*/
$size = count($big_array);
for ($i=0; $i < $size; $i++)
/*...*/ 


בדרך הנ"ל הפונקציה count רצה פעם אחת בלבד, והתוצאה שלה נשמרת במשתנה.
בדרך זו, במקום שהפונקציה count תרוץ כל פעם שהלולאת FOR מבצעת סיבוב נוסף, היא רצה פעם אחת וחוסכת די הרבה משאבים.
אבל, ידוע שהפונקציה isset מהירה יותר מ-strlen (ומהירה יותר גם מ-count ופונקציות רבות אחרות), לכן יהיה עדיף לכתוב את הקוד הנ"ל בצורה הבאה:

קוד PHP:

 $big_array = (/*...*/);

for ($i=0; isset($big_array[$i]); ++$i)
{
    /* Do Something */
} 


חשוב לשים לב לכך שהחלפתי את דרך ההעלאה של המשתנה i ב-אחד.
כלומר, במקום לכתוב:

קוד PHP:

 $i++ 


כתבתי:

קוד PHP:

 ++$i 


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

[ למידע על לולאת FOR מהאתר של PHP הרישמי: http://il2.php.net/manual/en/control-structures.for.php ]

4. הכנסת משתנים למחרוזת המוגדרת בתצורות שונות:

יש צורות רבות להגדרת מחרוזת, לדוגמא:

קוד PHP:

 $str = 'string';
# OR
$str = "string";
# OR
$str = <<<EOF
string
EOF;
# OR
?>
string
<?php 


[ למידע נוסף מהאתר הרישמי על צורות הגדרת מחרוזת: http://il2.php.net/manual/en/language.types.string.php ]

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

קוד PHP:

 //$subject = 'PHP';
$str = 'I am learning '.$subject.' at this moment.'; 


מהירה יותר מהדרך:

קוד PHP:

 $str = "I am learning $subject at this moment."; 


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

קוד PHP:

 echo 'I am learning ' , $subject , ' at this moment.'; 


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

( מה שבטוח, כאשר מגדירים מחרוזת ללא משתנים בכלל, עדיף להשתמש בגרשים יחידים - ' )

דבר נוסף, עד כמה שידוע לי, שימוש בהגדרת מחרוזת באמצעות Heredoc ( כשלדוגמא כתוב בהתחלה EOF>>>) והכנסת משתנים לתוכה, מומלץ רק אם המחרוזת ארוכה יחסית ויש משתנים רבים.

מי שיודע על נושא זה מידע נוסף מוזמן להוסיף...

[ למידע על מחרוזות וצורת איחסון מהאתר של PHP הרישמי: http://il2.php.net/manual/en/language.types.string.php
למידע על אופרטורי מחרוזות: http://il2.php.net/manual/en/langua...tors.string.php ]


5. שימוש ב- if-else ואופרטור Ternary:

יש ב-PHP אופרטור לכתיבת קוד if-else מקוצר, אופרטור זה נקרא Ternary.
לקוד הבא:

קוד PHP:

 if ($myVar)
    /* execute a code */
else
    /* execute an other code */ 


יש את התחליף הבא, באמצעות Ternary:

קוד PHP:

 $myVar ? /* execute a code */ : /* execute an other code */ ; 


ידוע ששימוש באופרטור Ternary (למעוניינים, בעיברית הפירוש "משולש" או "של שלושה") מהיר יותר משימוש בפקודות if-else.
[ למידע על האופרטור Ternary מהאתר של PHP הרישמי: http://il2.php.net/manual/en/langua...parison.ternary ]

ד"א, צורת שימוש מיוחדת (לפחות מבחינתי) באופרטור Ternary שאהבתי:

קוד PHP:

 $i > 30
    ? echo 'greater than 30.'
    : $i > 20 
        ? echo 'greater than 20.'
        : $i > 10
            ?  echo 'greater than 10.'
            : $i > 5 
                ? echo 'greater than 5.'
                : echo 'Too small.'; 


6. שימוש בערכים הבוליאניים true ו- false:
[ מידע נוסף: http://il.php.net/manual/en/language.types.boolean.php ]

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

לדוגמא, במקום לכתוב:

קוד:

 ... TRue ....

עדיף לכתוב:

קוד:

... true ...

* אני לא יודע אם זה נכון גם לגבי null והחברים הדומים (כמו array, new וכדו').

7. לולאת for מהירה יותר מלולאת while, לכן עדיף יהיה להשתמש בה אם אפשר (ותמיד אפשר).
לדוגמא, במקום לכתוב:

קוד PHP:

 while ( $i > 0)
{
    /* 
    ...
    */
} 


אפשר לכתוב:

קוד PHP:

 for ( ; $i > 0 ; )
{
    /* 
    ...
    */
} 


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

8. שימוש נכון במבני בקרה (Control Structures):

מבני בקרה, ביניהם if-elseif-else / for / while, ניכתבים לפעמים בצורה הבאה:

קוד PHP:

 if (...)
{
    // execute one code syntax
} 


בדוגמא הנ"ל אני מתכוון שמתבצעת פקודה אחת בלבד, אם ל- if חוזר ערך true בתנאי שלו.
כשקיים מצב שצריך להריץ רק פקודה אחת בתוך מבנה בקרה, PHP מרשה להסיר את הסוגריים המסולסלות, כך שהקוד לבסוף ייראה בצורה הבאה:

קוד PHP:

 if (...)
    // execute one code syntax 


לדוגמא, אפשר גם "להגזים" ולרשום:

קוד PHP:

 if (...) echo 'Hello World!'; 


כך שכל הקוד של מבנה הבקרה ותוכנו יהיה בשורה אחת בלבד.

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

[ למידע על מבני בקרה: http://il2.php.net/manual/en/langua...-structures.php ]

9. פקודת echo מהירה יותר מ-print, כי print (בנוסף להדפסת המחרוזת) גם מחזירה את המחרוזת שהוא מדפיס.

10. שימוש בפונקציה str_replace מהירה יותר מ-preg_replace, ושימוש בפונקציה preg_replace מהירה יותר מ- ereg_replace. הישתמשו בהחלפת מחרוזות בחוכמה...
* הערה: זה נוגע גם לפונקציות האחיות, כלומר פונקציות Strings מהירות יותר מפונקציות preg, ופונקציות preg מהירות יותר מפונקציות ereg.

11. השתמשו תמיד ב-Tab'ים כשאתם כותבים את הקוד!
ב-Tab אני מתכוון לכפתור בצד שמאל של המקלדת, מעל כפתור ה- Caps Lock ומתחת לכפתור הטילדה\זרקא ( ~ ).
ראה תמונה:
https://2007-uploaded.fresh.co.il/2...05/82328157.jpg
דוגמא לכתיבת קוד עם Tabs:

קוד PHP:

 class someClass
{
    function login()
    {    
        $this->skin = load_skin('login');
        
        switch($gInput['code'])
        {
            case 'loginf':
                $this->login_user_form();
                break;
            case 'dologin':
                $this->do_login_user();
                break;
            case 'logout':
                $this->logout_user();
                break;
            default:
                # Do something.
                break;
        }
    
    }
/* etc. */
} 


_________________________________________________

קישורים חיצוניים למידע על טכניקות PHP טובות וטיפים נוספים:
http://www.sitepoint.com/forums/showthread.php?t=456441 - המומלץ ביותר מבין כל מה שמצאתי.
http://www.4webhelp.net/tutorials/?cid=3
http://warpspire.com/tipsresources/...intainable-code
http://www.phpwact.org
http://www.devarticles.com/c/a/PHP/...ing-Up-PHP-Code
http://evolt.org/node/26440
http://phpcode.mypapit.net/category/quick-tips
_________________________________________________


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

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

--- ! Area Close ! ---

לגבי האופרטור המשולש (Ternary)
האופרטור הזה קיים גם בשפות אחרות וגם שם הוא מהיר יותר מif...else רגיל
(בC זה עניין של המרה פשוטה לאסמבלי)

אבל

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

למשל הקוד הבא הוא טוב

קוד PHP:

 $answer== 'Y' ? echo 'Yes' : echo 'No'; 


אבל הקוד הבא לא מומלץ, למרות שיעבוד

קוד PHP:

 $ans1 == 'Y' ? $ans2 == 'Y' ? echo 'Yes Yes' : echo 'Yes No' : echo 'No!'; 


_________________________________________________

אזהרה: משרד הבריאות קובע כי העישון מזיק לבריאות !
תראו, אפילו החייזר נהיה ירוק מזה

מנהל פורום מדע בדיוני ופנטסיה ופורום מדע טכנולוגיה וטבע בפרש

ציטוט:

במקור נכתב על ידי המממ אבל הקוד הבא לא מומלץ, למרות שיעבוד קוד PHP:  $ans1 == 'Y' ? $ans2 == 'Y' ? echo 'Yes Yes' : echo 'Yes No' : echo 'No!';

צודק, הקוד הזה לא מומלץ.

אבל הצגתי קוד המשתמש ב-Ternary שנכתב בצורה שונה, בצורה מובנת.

הרי עיקר ההמלצה זה בגלל שיהיה קשה להבין את התחביר כשיש Ternary אחד בתוך השני.

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

ציטוט:

במקור נכתב על ידי DCD ... פעולות לוגיות ... ... אופרטורים לוגים ...

זהו אינו אופרטור לוגי, התכוונת לפעולות/אופרטורים על סביות.

ציטוט:

במקור נכתב על ידי DCD ... 3. שימוש ב-isset בלולאת FOR: קוד PHP:  $big_array = (/*...*/); for ($i=0; isset($big_array[$i]); ++$i) {     /* Do Something */ }  ...

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

ציטוט:

במקור נכתב על ידי DCD ... print (בנוסף להדפסת המחרוזת) גם מחזירה את המחרוזת שהוא מדפיס ...

לא מזמן היה פה דיון בנושא, ומסתבר שכמעט כל אחד חושב ש-ptint מחזירה את המחרוזת, אך האמת היא ש-print מחזירה תמיד 1.



חוץ מזה, חן חן על ההשקעה

ציטוט:

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

בדיוק...התבלבלתי בכתיבה.

ציטוט:

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

נכון, אבל רציתי לציין אפשרות זאת למרות העניין עם ה-NULL, כיוון שזה מתאים ואפשרי להשתמש ב-isset במקרים רבים מאוד.
באמת הייתי צריך לכתוב ש-isset מחזיר FALSE כשיש null...

ציטוט:

במקור נכתב על ידי ישראל K חוץ מזה, חן חן על ההשקעה

תודה

ציטוט:

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

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

ציטוט:

בדרך הנ"ל הפונקציה count רצה פעם אחת בלבד, והתוצאה שלה נשמרת במשתנה. בדרך זו, במקום שהפונקציה count תרוץ כל פעם שהלולאת FOR מבצעת סיבוב נוסף, היא רצה פעם אחת וחוסכת די הרבה משאבים. אבל, ידוע שהפונקציה isset מהירה יותר מ-strlen (ומהירה יותר גם מ-count ופונקציות רבות אחרות), לכן יהיה עדיף לכתוב את הקוד הנ"ל בצורה הבאה:

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

ציטוט:

ד"א, צורת שימוש מיוחדת (לפחות מבחינתי) באופרטור Ternary שאהבתי:

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

ציטוט:

השתמשו תמיד ב-Tab'ים כשאתם כותבים את הקוד!

ובמילה אחת: הזחה.


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

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

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

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

ציטוט:

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

לא התכוונתי לזה ש isset איטי יותר מcount, אלא שהלולאה שהוצגה כטובה ביותר:

קוד PHP:

 $big_array = (/*...*/); 

for ($i=0; isset($big_array[$i]); ++$i) 
{ 
    /* Do Something */ 
} 


פחות טובה מהלולאה שהוצגה קודם לכן:

קוד PHP:

 /*...*/ 
$size = count($big_array); 
for ($i=0; $i < $size; $i++) 
/*...*/ 


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

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

אני חושב שהיחידים שמשקיעים כסף כדי לבדוק מה יכול לחסוך בהוצאות כדי להרוויח עוד כסף (כל אלו שמבזבים כסף על הוצאות בדיקת TCO), הם דווקא אלו שכסף זו הבעיה האחרונה שלהם

אמת לאמיתה

אם אתה מכיר טעויות ידועות שקשורות ל-PHP ולמסדי נתונים אתה יכול לכתוב אותם.

זה מטרת האשכול בעיקרון.

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

בסוף ההודעה כתבתי שאפשר להרחיב גם על התעסקות עם גורמים אחרים שקשורים ל-PHP.

ציטוט:

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

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

ציטוט:

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

זה עניין שאני באמת צריך לבדוק...

ציטוט:

במקור נכתב על ידי maxim k שתי הערות...אחת מהן המממ כבר ציין...השנייה היא, שמקור השם ternary operator הוא בכך ש אופרטור זה פועל על שלושה אופרנדים...כפי שאופרטור הפועל על שני אופרנדים נקרא בינארי, ואופרטור שפועל על אופרנד אחד נקרא אונרי...מכיוון שזהו האופרטור היחיד בשפות נוסח C הקבל שלושה אופרנדים, דבר בו השם ternary operator, אבל אין זה יהיה נכון לקרוא לו פשוט "טרינרי" או Ternary , אלא יש לקרוא לו "האופרטור הטרינרי".

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

ציטוט:

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

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

וגם בנוגע ל-count שיש יחסית הרבה קודים שמשתמשים בו בצורה לא מתאימה.

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

אתם מוזמנים להוסיף טכניקות שלא כתבתי או בכלל לתקן דברים נוספים שיכול להיות שטעיתי בהם, בעיקר בשביל להשתפר ולהבין טוב יותר את השפה ומאפייניה.

וכמו שכתב ישראל:

ציטוט:

[ההערה שלך לגבי העדיפות להשקיע יותר ביעילות השאילתות בהחלט משמעותית יותר].

תודה

ציטוט:

אני חושב שיש טעות בעניין הזה.

אתה מוזמן לגגל ולראות בעצמך

ציטוט:

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

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

ציטוט:

במקור נכתב על ידי DCD ... כתוב באחד המקורות ...זה ידוע ב-PHP

אני מניח שהמקור הראשון שכתב זאת, התכוון לומר שהוא מדבר על PHP והוא לא יודע מה לגבי שפות אחרות. אך לא בהכרח שהוא בדק שבשפות אחרות זה לא כך.

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

קוד PHP:

 $i = 3;
echo $i++; // prints 3
echo $i; // prints 4 


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

1. הערך הנוכחי של המשתנה מוצב בכתובת חדשה בזיכרון
2. הערך של המשתנה מקודם באחד
3. הערך הקודם (זה שהוצב בשלב 1) מוחזר
4. הערך שהוצב בשלב 1 נמחק

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

1. הערך של המשתנה מקודם באחד
2. הערך של המשתנה מוחזר

שים לב שמה שכתבתי כאן תקף לרוב שפות התכנות הנפוצות שקיימות.

אני מקווה שהדברים ברורים יותר עכשיו

כל הכבוד!!!

תודה על ההשקעה!!
עזרת לי מאוד

למנהלי הפורום:
אני ממליץ לשים קישור לאשכול הזה איפשהו בדביקים - אני יודע שאני עוד יחזור לאשכול הזה
+ממליץ על צלש לבחור (עריכה: *תיקון* < ראיתי את זה רק עכשיו > )

תודה.

בהחלט יש כאן כמה דברים שעזרו לי.

"We should forget about small efficiencies, say about 97% of the time: premature optimization is the root of all evil." (Knuth, Donald. Structured Programming with go to Statements, ACM Journal Computing Surveys, Vol 6, No. 4, Dec. 1974. p.268.)

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

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

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

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

אם חזרתי על הערות שכבר נכתבו בתגובות, אני מתנצל - אני מגיב ישירות להודעה הראשית:

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

2. אם אתה הולך על על אופטימיזציה ברמה שכזו, למה לא לחסוך תהליך השוואה?

קוד PHP:

 if ( $var & 1) { //it's odd number...} 


3. את הקוד הבא:

קוד PHP:

 $size = count($big_array);
for ($i=0; $i < $size; $i++) 


ניתן לכתוב גם:

קוד PHP:

 for ($i = 0, $size = count($array) ; $i < $size ; ++$i)... 


ולחסוך עוד שורה.

ולהמשך, isset היא לא דרך נכונה לבדוק אם מפתח (key) קיים במערך.
מה יקרה עבור הקוד הבא:

קוד PHP:

 $arr = array('a', 'b', null, 'c');
for ($i=0; isset( $arr[$i] ) ; ++$i) {
     echo $arr[$i];
} 


במקום לקבל abc כמו שאתה מצפה (אנו רצים על כל המערך, null לא מדפיס כלום ולכן הפלט אמור להיות abc, לא כן?) אנו מקבלים ab. מדוע?


4. שימוש בפסיקים בכל ה-language construct הינו עדיף על אופרטורים. לצערי הדבר גורם לחוסר קריאות של הקוד ויש להשתמש בו במתינות ובהתאם להקשר.

5. הדוגמה ש"אהבת" היא צורה קלאסית לקוד לא קריא.

6. אני לא יודע מה המקור לסעיף הזה. ניסיתי לבדוק את אמיתותו ולא מצאתי משהו רשמי בנושא. אל תשכח שיש הבדל בין תהליך ה-lexical parsing לבין ניתוח מחרוזות של משתנים. אני לא מאמין שיש הבדל כלשהו בין כתיבת ערכים בוליאנים באותיות גדולות או קטנות. מאחר ומילות המפתח ב-php כולן הינם case-insensitive.
כלומר אין הבדל בין false ל FALS ואין הבדל בין echo לבין ECHO או בין var_dump ל-VAR_DUMP.

7. נכון.

8. סטנדרטים של כתיבת קוד.

9. יעיל יותר...? זה עשוי לעזור: http://www.faqts.com/knowledge_base...ml/aid/1/fid/40

10. בהחלט! כל פונקציה שמבצעת regex ויש לה חלופה ללא regex, כנראה עדיפה.

11. שוב, סטנדרטים לכתיבת קוד.... (-:

[ זיו ]
[ fat fish ]

ציטוט:

במקור נכתב על ידי fat fish 6. אני לא יודע מה המקור לסעיף הזה. ניסיתי לבדוק את אמיתותו ולא מצאתי משהו רשמי בנושא. אל תשכח שיש הבדל בין תהליך ה-lexical parsing לבין ניתוח מחרוזות של משתנים. אני לא מאמין שיש הבדל כלשהו בין כתיבת ערכים בוליאנים באותיות גדולות או קטנות. מאחר ומילות המפתח ב-php כולן הינם case-insensitive. כלומר אין הבדל בין false ל FALS ואין הבדל בין echo לבין ECHO או בין var_dump ל-VAR_DUMP.

ראה את התגובות בעמוד הבא (הוא גם נמצא בארכיון): http://ilia.ws/archives/12-PHP-Opti...icks.html#c6052

קבועים.
כלומר, php מכיל את הקבוע TRUE שהוא למעשה ייצוג של true (הערך הבוליאני שהוא חלק מהשפה).
מתוך קוד המקור של php:

קוד:

#define TRUE 1

תהליך הparsing מנתח את TRUE באותיות גדולות כפנייה לקבוע ולא כחלק משפת php. ולכן php מחפש את ערכו של TRUE בטבלת הקבועים שלו.

מן הסתם אם יש מילת מפתח של השפה, שימוש בקבוע לציון מילה זו הינו overhead מיותר.

למי שרוצה להכיר את הקבועים של php (חלקם מוגדרים על ידי ההרחבות השונות):

קוד PHP:

 var_dump( get_defined_constants() ); 


[ זיו ]
[ fat fish ]

הרצתי את הקוד:

קוד PHP:

 var_dump( get_defined_constants() ); 


וקיבלתי את התוצאה הבאה:

ציטוט:

...["TRUE"]=> bool(true) ["FALSE"]=> bool(false) ["NULL"]=> NULL ...

אז יכול להיות שהתכוונו שצריך\כדאי לכתוב את הקבועים הבוליאניים באותיות גדולות, לא יודע.

something's fishy

הפוך, עדיף לכתוב באותיות קטנות.

אגב, print_r מוציא פלט קריא יותר מאשר var_dump, כדאי להשתמש בזה למצבים דומים.

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

אבל כפי שכתוב, הערך המקורי הוא (למשל) TRUE, ולא true. זה הנתונים שקיבלתי מהמערך של הקבועים של PHP.

הערך של הקבוע הוא TRUE.
הערך של הפקודה הוא true.

הקבוע TRUE מפנה לערך true.

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

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

5. למה לא קריא? הוא קריא מאוד יחסית לאופרטור הזה, זאת הסיבה שאהבתי את הדוגמא הזאת.

7. במקור שהבאת כתוב ש-echo מהיר יותר, רק שזה ממש בקצת:
echo is marginally faster since it doesn't set a return value

print טוב רק במקרה שרוצים להשתמש בערך המוחזר ממנו (שזה 1), אבל אם פשוט רוצים להדפיס, עדיף להשתמש ב-echo.
כתבתי סעיף זה כי לפעמים מתכנתים מדפיסים הרבה פעמים פקודות באמצעות echo\print.

תודה על ההערות