בMySQL ישנן שתי פעולות מעניינות לחיפוש במחרוזות. הראשונה היא LIKE והשניה היא REGEXP. לא אפרט וארחיב יותר מדי עליהן, את תפקודן המלא ניתן לקרוא באתר של MySQL להרחבה.
LIKE מאפשרת לנו להשתמש בסימן _ בכדי לתפוס כל תו שהוא וב% בכדי לתפוס כל רצף שהוא של תווים (כולל 0). REGEXP מאפשרת לנו להריץ ביטויים רגולוריים.
שימוש נפוץ לפעולות האלו הוא חיפוש בתוך מחרוזת. במאמר אבדוק את היעילות של כל אחת מהן, בבדיקה של האם מחרוזת מכילה תת מחרוזת, תפקיד ששתיהן תבצענה בקלות ותשגנה את אותה המטרה.

את המבחן אבצע עם שרת MySQL שמותקן לוקאלית על המחשב שלי. אצור טבלה עם עמודה id ועמודה name באורך 32 תווים. אכניס הרבה שורות (100,000) עם מידע שונה (md5 של מונה הלולאה) ואראה איזו מהשיטות יותר יעילה לחיפוש תת המחרוזת 5eda

הקוד שבו השתמשתי ליצירת הטבלאות והכנסת הנתונים הוא:

CREATE TABLE `tbl` (
	`id` INT(11) UNSIGNED NOT NULL AUTO_INCREMENT,
	`name` CHAR(32) NOT NULL,
	PRIMARY KEY (`id`)
)
COLLATE='utf8_general_ci'
ENGINE=MyISAM
ROW_FORMAT=DEFAULT;
 
DELIMITER $$
CREATE PROCEDURE DO_INSERT()
	BEGIN
		DECLARE i INT DEFAULT 0;
		my_loop: LOOP
			INSERT INTO `tbl`(`name`) VALUES(MD5(i));
			SET i = i + 1;
			IF i = 100000 THEN 
				LEAVE my_loop;
			END IF;
		END LOOP my_loop;
	END $$
DELIMITER ;
CALL DO_INSERT();

הקודים שבהם השתמשתי לשליפת נתונים עם LIKE וREGEXP הם:

SELECT * FROM `tbl` WHERE `name` LIKE '%5eda%';

SELECT * FROM `tbl` WHERE `name` REGEXP '5eda';

SELECT * FROM `tbl` WHERE `name` REGEXP '^.*5eda.*$';

התוצאות היו ברורות וחד משמעיות. בעת שימוש בLIKE קיבלתי זמן 0.046 ו0.062 שניות (כנראה בגלל caching), בעת שימוש בREGEXP בשיטה הראשונה קיבלתי זמן 0.125 ו0.144 שניות ובשיטה השנייה 0.328 ו0.344 שניות.
שתי הפעולות השיגו את אותו הדבר בדיוק, רק שLIKE הייתה מהירה פי יותר מ2.5 מREGEXP בשיטה הראשונה ופי 6.25 בשיטה השנייה!

שיהיה לכם שימוש מושכל!

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

שיטות איטרציה

• unoptimized:
  for($i = 0; $i < count($array); $i++) { }
• semioptimized1:
  $c = count($array);
  for($i = 0; $i < $c; $i++) { }
• semioptimized2:
  for($i = 0, $c = count($array); $i < $c; $i++) { }
• optimized:
  for($i = count($array) – 1; $i >= 0; $i–) { }

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

תוצאות

מסקנות

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

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

• $arr[$i] = $val; – הכנסת הערך $val למערך $arr במקום ה$i.
• $arr[] = $val; – הכנסת הערך $val למערך $arr במקום הבא (לדוגמה אם יש אינדקסים 0, 1, 2 המקום יהיה 3).
• array_push($arr, $val); – זהה לחלוטין לקודם מבחינת תפקוד.
• נבחן שיטה אחת נוספת שממלאת מערך במספרים מa עד b נכתב כך: $arr = range($a, $b);

המבחן

בניתי מבחן קטן, שמכניס את המספרים מ0 עד 99,999 לתאים המתאימים (0 ב0, 1 ב1 וכו') – סה"כ 100,000 תאים.
המבחן בנוי מהצהרה על המערך ולולאה שמכניסה את $i למקום ה$i בהתאם לשיטות 1 עד 3 (הניחו כי $val הוא $i).

define('TIME', microtime(true));
 
$arr = array();
 
for($i = 0; $i < 100000; $i++) {
	// HERE COMES THE ACTION
}
 
echo microtime(true) - TIME;

נוסף לכך הרצתי במקום הלולאה את הקוד הבא:

$arr = range(0, 99999);

התוצאות נראו כך (פחות שניות יותר טוב):

• $arr[$i] = $i;
  0.046030044555664 (שניות)
• $arr[] = $i;
  0.048002958297729 (שניות)
• array_push($arr, $val);
  0.17743587493896 (שניות)
• $arr = range(0, 100000);
  0.020608901977539(שניות)

או בגרף (כמה שנמוך יותר, יותר מהיר):

לכן הסקתי את המסקנות הבאות:

• במידה ואתם צריכים מערך שמכיל מספרים מa עד b תשתמשו בפונקציה range.
• עדיף במעט להשתמש באינדקסים (זניח).
• לא להשתמש בarray_push היא איטית ביותר מפי 3.5!

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

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

המבנה של char פשוט יותר להסברה:
עבור ההצהרה char(X) בכל שורה יוקצו בדיוק X בייתים לאחסון. במידה ונכניס רק X – Y בייתים, יתווספו ברצף Y בייתים ובהם NULL.
המבנה של varchar טיפה יותר מורכב:
עבור ההצהרה varchar(X) בכל שורה יוקצו עד X + 1 בייתים לאחסון. במידה ויוכנסו Y בייתים, יתפסו Y + 1 בייתים בלבד, שהאחד הנוסף מכיל NULL המציין את סוף המידע.

מתי להשתמש במה:
כאשר הגודל הוא קבוע או כמעט כמובן שעדיף להשתמש בchar, הן פחות מקום יתפס ואם כל השורה היא fixed length (משמע מכילה רק טיפוסים באורך קבוע כמו מספרים, char, enum וכו') גם מעבר על שורות יהיה מהיר יותר.
כאשר הגודל משתנה מומלץ להשתמש בvarchar, כך נחסוך מקום באופן משמעותי.

מקווה שלמדתם משהו חדש!

בזמן האחרון גיליתי שיש הבדל מאוד מאוד משמעותי בין == ל=== מבחינת ביצועים.
ההבדל בגדול מבחינת השימוש הוא ש == משווה את הערך ו=== גם משווה את סוג המשנה. כך שלדוגמה string לא ריק == לtrue אבל לא === לtrue וכדומה.

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

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

• פונקציה פשוטה וסטנדרטית.
• מחלקה רגילה, יצירת אובייקט וקריאות לפעולה בו.
• מחלקה עם פעולה סטטית וקריאות ישירות אליה.
• שימוש בDesign Pattern שנקרא Singleton שבו יוצרים מחלקה רגילה ופעולה סטטית אחת שיוצרת אובייקט אחד של המחלקה ומחזירה אותו. לא ניכנס ללמה זה טוב.

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

פונקציה פשוטה: 0.38151597976685 שניות. (נסמן ב100%)
מחלקה רגילה: 0.97387981414795 שניות. 255% מפונקציה פשוטה!
פעולה סטטית: 1.8012449741364 שניות. 472% מפונקציה פשוטה!
Singleton וקריאה רגילה: 3.3634400367737 שניות. 881% מפונקציה פשוטה!

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

המבחנים בוצעו על wamp עם php 5.3.0, במחשב עם מעבד אינטל פנטיום 4 במהירות 3.2GHz ו1GB זכרון.
את הקבצים שאיתם ביצעתי את ההשוואה תוכלו להוריד.

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

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

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

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

פולימורפיזם הוא מה שמאפשר לנו להתייחס לכמה אובייקטים – שמחלקותיהם יורשות מאותה מחלקה – בצורה דומה. כך שניתן להריץ את הפעולה eat עם אותם פרמטרים על אובייקטים של המחלקות Bear וLion, היורשות מהמחלקה Carnivore.
בשפות בהן יש להצהיר על משתנים ולציין את סוגם (כמו C, ASP.Net, Java וכו') יש לכך יתרון נוסף, ניתן להצהיר על משתנה מסוג Carnivore ולהציב בו אובייקט של המחלקה Lion! פשוט כי היא יורשת ממנו!

אתן דוגמה לישום פשוט שכולל מחלקות פשוטות שמנהלות databaseים מסוג MySQL וSQLite. נצא מתוך נקודת הנחה שיש לנו database עם טבלה pages שמכילה עמודת name וcontent.
היישום ישלוף דף לפי מה שמוגדר בget ויציג אותו, אם לא ימצא דף יציג הודעת שגיאה.

נכתוב את המחלקות:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

abstract class abstract_db {
	protected $con;
 
	abstract public function __construct($con_data);
	abstract public function query($query_string);
	abstract public function num_rows($query);
	abstract public function escape_string($string);
	abstract public function fetch($resource);
	abstract public function __destruct();
 
}
 
class mysql_db extends abstract_db {
 
	public function __construct($con_data) {
		$this->con = mysql_connect($con_data['host'], $con_data['username'], $con_data['password']);
		mysql_select_db($con_data['database'], $this->con);
	}
 
	public function query($query_string) {
		return mysql_query($query_string, $this->con);
	}
 
	public function num_rows($query) {
		return mysql_num_rows($query);
	}
 
	public function escape_string($string) {
		return mysql_real_escape_string($string, $this->con);
	}
 
	public function fetch($resource) {
		return mysql_fetch_object($resource);
	}
 
	public function __destruct() {
		mysql_close($this->con);
	}
 
}
 
class sqlite_db extends abstract_db {
 
	public function __construct($con_data) {
		$this->con = sqlite_open($con_data['file']);
	}
 
	public function query($query_string) {
		return sqlite_query($query_string, $this->con);
	}
 
	public function num_rows($query) {
		return sqlite_num_rows($query);
	}
 
	public function escape_string($string) {
		return sqlite_escape_string($string);
	}
 
	public function fetch($resource) {
		return sqlite_fetch_object($resource);
	}
 
	public function __destruct() {
		sqlite_close($this->con);
	}
 
}

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

נכתוב את גוף היישום, (כך שישתמש בdatabase מסוג mysql):

1
2
3
4
5
6
7
8
9

$db = new mysql_db(array('host' => 'localhost', 'username' => 'root', 'password' => '', 'database' => 'example'));
$query = "SELECT name, content FROM pages WHERE name = '".$db->escape_string(array_key_exists('page', $_GET)?$_GET['page']:'index')."'";
$result = $db->query($query);
if($db->num_rows($result) == 0) {
	exit('Invalid page!');
}
$row = $db->fetch($result);
echo '<h1>'.$row->name.'</h1>';
echo '<p>'.$row->content.'</p>';

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

בכדי לעבור לשימוש בsqlite בדרך כלל (אם לא היינו משתמשים בשכבת אבסטרקציה בדומה לזו) היינו צריכים לעבור שורה שורה ולהחליף את כל הפקודות mysql_* לפקודות הsqlite המתאימות להן; אך ביישום הזה כל שעלינו לעשות זה להחליף את השורה הראשונה לזו:

$db = new sqlite_db(array('file' => 'example.db'));

זהו זה, זה הכל!

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

בהצלחה!

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

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

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

class Carnivore {
	public $legs = 4;
	public $speed_kmh = 10;
	public $eyes = 2;
	public $cover_type = 'Leather';
	public $cover_length_cm = 4;
	public $can_eat = array();
 
	public function __construct() {
	}
 
	public function eatable($eatable_thing) {
		if(is_array($eatable_thing)) {
			$this->can_eat = array_merge($this->can_eat, $eatable_thing);
		}
		else {
			$this->can_eat .= $eatable_thing;
		}
		return;
	}
 
}
 
class Bear extends Carnivore {
	public $cover_type = 'Fur';
	public $cover_length_cm = 5;
	public $can_eat = array('fish', 'rabbits');
	public $roar_volume_dba = 75;
 
	public function roar() {
		echo "Rooaarrr!!";
	}
 
	public function get_fish($amount = 1) {
		// Go to the river and get a fish
	}
 
	public function sleep($for_hrs = 6) {
		// Go to the cave and sleep
	}
 
}
 
class Polar_Bear extends Bear {
	public $cover_color = 'White';
	public $cover_length_cm = 10;
 
	public function get_fish($amount = 1) {
		// Break ice first and get fish from there
	}
 
	public function sleep($for_hrs = 9) {
		// Go to a lonley place and sleep
	}
 
}
 
$carnivore = new Carnivore();
echo $carnivore->cover_type; // Outputs Leather
echo is_a($carnivore, 'Carnivore') ? 'yes' : 'no'; // Outputs yes
echo is_a($carnivore, 'Bear') ? 'yes' : 'no'; // Outputs no
echo is_a($carnivore, 'Polar_Bear') ? 'yes' : 'no'; // Outputs no
 
$bear = new Bear();
echo $bear->cover_type; // Outputs Fur
echo is_a($bear, 'Carnivore') ? 'yes' : 'no'; // Outputs yes
echo is_a($bear, 'Bear') ? 'yes' : 'no'; // Outputs yes
echo is_a($bear, 'Polar_Bear') ? 'yes' : 'no'; // Outputs no
 
$polar_bear = new Polar_Bear();
echo $bear->cover_type; // Outputs Fur
echo is_a($polar_bear, 'Carnivore') ? 'yes' : 'no'; // Outputs yes
echo is_a($polar_bear, 'Bear') ? 'yes' : 'no'; // Outputs yes
echo is_a($polar_bear, 'Polar_Bear') ? 'yes' : 'no'; // Outputs yes

כרגיל נעבור על הקוד.
ראשית הצהרנו על מחלקה פשוטה שמייצגת טורף.
שנית הצהרנו על מחלקה שמייצגת דוב ומרחיבה את מחלקת הטורף (Bear extends Carnivore). במבט קליל נגלה שכתבנו כמה מאפיינים שכבר הוזכרו במחלקת הטורף. מה שיקרה בפועל זה שמחלקת הטורף תשוכפל ובכל מקום בו כתבנו משהו בשם חדש הוא יוחלף. הצהרנו כאן גם על מאפיין חדש לחלוטין וכמה פעולות חדשות שפשוט יתווספו.
שלישית הצהרנו על מחלקה שמייצגת דוב קוטב ומרחיבה את מחלקת הדוב. כאן הצהרנו על מחדש על מספר מאפיינים ופעולות ויקרה דבר זהה למה שקרה בנושא מחלקת הדוב והטורף.
לבסוף יצרתי אובייקט של כל אחת מהמחלקות, לשם הדוגמה הדפסתי את סוג הכיסוי של כל אחד מהאובייקטים והפלטים היו: Leather, Fur וFur. עוד דוגמה הייתה הפונקצייה is_a, שבודקת האם אובייקט הוא מופע של מחלקה מסויימת או בן של אותה מחלקה. הפלטים די ברורים.

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

class Polar_Bear {
	public $legs = 4;
	public $speed_kmh = 10;
	public $eyes = 2;
	public $cover_type = 'Fur';
	public $cover_length_cm = 10;
	public $can_eat = array('fish', 'rabbits');
	public $roar_volume_dba = 75;
	public $cover_color = 'White';
 
	public function __construct() {
	}
 
	public function eatable($eatable_thing) {
		if(is_array($eatable_thing)) {
			$this->can_eat = array_merge($this->can_eat, $eatable_thing);
		}
		else {
			$this->can_eat .= $eatable_thing;
		}
		return;
	}
 
	public function roar() {
		echo "Rooaarrr!!";
	}
 
	public function get_fish($amount = 1) {
		// Break ice first and get fish from there
	}
 
	public function sleep($for_hrs = 9) {
		// Go to a lonley place and sleep
	}
 
}

למה כל זה טוב?

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

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

בהצלחה!

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

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

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

ישנן 3 רמות שונות של גישות:

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

עד עכשיו בכדי ליצור מאפיין למחלקה רשמנו את המילה var ואחריה את שם המאפיין ופעולות רשמנו כמו שאנו רושמים פונקציות מחוץ למחלקה.
מעכשיו והלאה לפני מאפיינים נרשום public/private/protected במקום המילה var ולפני כל פעולה נרשום public/private/protected.

מספר יתרונות

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

דוגמה

ניתן דוגמה לשימוש כמעט אמיתי של מחלקות ושל כימוס, נכתוב מחלקה של משתמש קונה באתר קניות ושל מוצר באתר קניות. מטרתנו היא לכתוב מחלקה שבהינתן username וpassword של משתמש היא מאפשרת לנו למצוא מידע עליו, לבצע פעולת רכישה ולעדכן את שמו. ובנוסף מחלקה שמייצגת מוצר כלשהו, שבהינתן id היא מוצאת את מחיר ושם המוצר, אובייקטים שלה מועברים לפעולת הרכישה.
נניח שקיים כבר חיבור למסד נתונים mysql וקיימת טבלה Customers שמכילה עמודות של id, username, password, fullname, credit_card וטבלת Products שמכילה עמודות של id, name, price.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

class Product {
	public $id;
	public $name;
	public $price;
 
	public function __construct($id) {
		$this->id = (int)$id;
		$query = mysql_query("SELECT name, price FROM Products WHERE id = '{$this->id}' LIMIT 0,1");
		$query = mysql_fetch_array($query);
		$this->name = $query['name'];
		$this->price = $query['price'];
	}
 
}
 
class Customer {
	private $data = array();
 
	public function __construct($username, $password) {
		$username = mysql_real_escape_string($username);
		$password = md5($password);
		$query = mysql_query("SELECT id, username, password, full_name, credit_card FROM Customers WHERE username = '{$username}' AND password = '{$password}' LIMIT 0,1");
		$this->data = mysql_fetch_array($query);
	}
 
	private function credit_card_valid() {
		// Make sure there are enough digits and all this stuff
		return $is_vaild;
	}
 
	public function buy(Product $prod) {
		// First make sure the credit card is valid
		if($this->credit_card_valid()) {
			// Call an imiginary function which takes money from a credit card
			make_a_payment_using_credit_card($this->data["credit_card"], $prod->price);
			// Submit an email to the site administrator that a new product has been bought
			let_admin_know_by_email($prod->id);
			return "Thank you ".$this->full_name.", for buying at our shop. The admin will contact you soon.";
		}
		return false;
	}
 
	public function update_name($new_name) {
		$this->data["full_name"] = $new_name;
		$new_name = mysql_real_escape_string($new_name);
		mysql_query("UPDATE Customers SET full_name = '{$new_name}' WHERE id = '{$this->data['id']}'");
	}
 
	public function full_name() {
		return $this->data["full_name"];
	}
 
}
 
// Lets look for the user yossi22
$yossi = new Customer("yossi22", "123abc");
// Excpected to print something like "Yossi Avraham"
echo $yossi->full_name();
 
// We are now using the product class, and look for the product with the id 12345
$new_television = new Product(12345);
// Lets make Yossi buy a new television
// If he gets it let him know
$ret = $yossi->buy($new_television)
if($ret) {
	// Will out put "Thank you Yossi Avraham, for buying at our shop. The admin will contact you soon."
	echo $ret;
}
 
// Maybe Yontan want a new TV two?
$yonatan = new Customer("yonatan1", "976431");
// Wait! he changed his name to Ohad Regev
$yonatan->update_name("Ohad Regev");
$ret = $yonatan->buy($new_television)
if($ret) {
	// Will out put "Thank you Ohad Regev, for buying at our shop. The admin will contact you soon."
	echo $ret;
}

בואו ננסה להבין קטע אחרי קטע:
ראשית כתבנו מחלקת Product המכילה 3 משתנים ציבוריים id, name וprice – מספר סידורי, שם ומחיר ולה פעולת Constructor ציבורית שמקבלת id ומוצאת את המוצר שפרטיו תואמים לid זה.
שנית הצהרנו על מחלקה בשם Customer, היא מכילה משתנה פרטי בשם data, פעולת Constructor ציבורית המקבל שם משתמש וסיסמה, פעולת רכישה ציבורית המקבלת מוצר (שימו לב לארגומנט הראשון, ניתן להגדיר את סוג המחלקה שאנו מצפים לקבל) ומשתמשת בפעולה פרטית המוודאת תקינות של כרטיס אשראי, פעולה ציבורית לעדכון השם ופעולה ציבורית להחזרת השם. לא אכנס לתוכן כל פעולה כיוון שהן די פשוטות וזניחות.
לאחר מכן יצרנו אובייקט בשם yossi שהוא מופע של המחלקה Customer והעברנו שם משתמש וסיסמה, הדפסנו את השם המלא של יוסי. כעת ניצור אובייקט new_television שהוא מופע של המחלקה Product עם הid שמספרו 12345.
לאחר מכן נגיד ליוסי לקנות טלוויזיה חדשה, ואם הוא הצליח לקנות אז נדפיס הודעה שמכילה את השם שלו.
מאוחר יותר ביצענו תהליך דומה למשתמש אחר בשם יונתן, ששינה את שמו לאוהד. לאחר שקנה טלוויזיה חדשה תודפס לו הודעה המכילה את שמו החדש.

גישה למידע פרטי

כעת נבדוק מה קורה כאשר אנו מנסים לגשת לקוד שמוגדר כפרטי – private.
נוסיף את הקוד הבא לאחר ההצהרה על המשתנה yossi:

print_r($yossi->data);

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

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

$yossi->credit_card_valid();

נקבל פלט שכזה:

סיכום

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

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

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

// This is the class Dog
class Dog {
	// This is the property speed which represents dogs speed
	var $speed;
 
	// This is the method talk
	function talk() {
		echo "woof woof";
	}
 
	// This is the method walk, which receives 1 argument and probabbly uses the speed property
	function walk($to) {
		// This is just an example, implementation of walk method should be here
	}
 
}
 
// Lets create an object of Dog named Lassie
$lassie = new Dog();
 
// Lets make Lassie talk
$lassie->talk();
 
// Lets change the speed of Lassie
$lassie->speed = 10;
// Lets make Lassie walk some where
$lassie->walk("some where");

אסביר את הקוד:
class Dog – המילה השמורה class מציינת פתיחת מחלקה.
var $speed – המילה var (בהמשך נלמד על public, protected וprivate) מגדירה מאפיין למחלקה.
הפונקצייה talk וwalk – פעולות של המחלקה, walk מקבל ארגומנט אחד.
$lassie = new Dog(); – המילה השמורה new יוצרת מופע של המחלקה שרשומה אחריה. בקרוב נבין מה משמעות הסוגריים.
$lassie->talk(); – הסימן "->" משמש לשם פנייה לאיברים (מאפיינים ופעולות) של המחלקה, קריאה לפעולה talk.
$lassie->speed = 10; – שינוי של המאפיין speed ל10.
$lassie->walk("some where"); – קריאה לפעולה walk עם ארגומנט 1.
הפלט של הקוד הזה יהיה כמובן "woof woof".

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

1
2
3
4

$flaffi = new Dog();
$lassie->speed = 8;
$flaffi->walk("here");
$flaffi->talk();

פעולת Constructor ("בנאי") והמשתנה $this

בכל מחלקה ניתן להשתמש במשתנה הפנימי $this. משתנה זה הוא למעשה מפנה למשתנה של האובייקט עצמו כך שאם אוסיף את הקוד $this->speed = 10; לפעולה talk, ברגע שהיא תורץ המאפיין speed של האובייקט עצמו (לדוגמה $lassie) ישתנה ל10.

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

1
2
3

	function Dog($speed) {
		$this->speed = $speed;
	}

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

1
2

$lassie = new Dog(10);
$flaffi = new Dog(8);

תצורת הזיכרון של משתני אובייקטים

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

קוד להמחשה:

1
2
3
4
5
6
7
8
9

$a = 5;
$b = $a;
$b = 8;
echo $a; // Will print out 5
 
$dog1 = new Dog(5); // Init the speed to 5
$dog2 = $dog1;
$dog2->speed = 8;
echo $dog1->speed; // Will print out 8

לקריאה נוספת בעברית – Value Type & Reference Type in PHP (נכתב על ידי איתי סלע).