[עמוד ראשי]   [נושא קודם]
מערכים


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

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

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

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

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

1. יצירת מערכים
מערכים נוצרים בעזרת האופרטור "new" ובעזרת פונ' הבנאי של המערך (ניתן לעשות זאת ב- 3 דרכים שונות) :
var a = new Array();
פונקציה זו יוצרת מערך ריק ללא אלמנטים

var a= new Array(3,7,"testing");
כאן יצרנו מערך בעל אלמנטים ספציפיים

var a= new Array(10);
כאן יצרנו מערך בעל 10 אלמנטים כאשר כל אלמנט הוא בעל ערך לא מוגדר

בגרסה 1.2ניתן לשבץ את ערכי המערך בתוך סוגריים מרובעים כאשר כל אלמנט מופרד בפסיק מאלמנט אחר ואלמנט שהינו מחרוזת צריך לבוא בין 2 גרשים, לדוגמא :
var digits = [2,5,8,0]; 
var many =['son',false,3.14];
מערכים יכולים להכיל אובייקטים ו/או מערכים אחרים :
var b = [ [7,{x:6 , y:4}] , [2,{x:3 , y:0}] ]
2. קריאת וכתיבת אלמנטים של מערכים
על מנת לגשת לאלמנט של מערך נשתמש באופרטור [ ]. ניתן להעביר ערך מתוך אלמנט של מערך לתוך משתנה אחר ולהיפך :
value = a[0];
a[1]= 7.88;
הפעולות הבאות גם כן אפשריות :
i = 2 ; 
a[i]= 8;
a[i+4] = "goodbye"; 
a[a[i]] = a[0]; 
3. הוספת אלמנטים חדשים למערך
בשפות כמו c ו - java מערך הוא בעל מס' קבוע של אלמנטים הנקבע מראש. זהו לא המקרה ב-JS ,מערך יכול להכיל מס' של אלמנטים, הניתן לשינוי בכל רגע.
על מנת להוסיף אלמנט חדש למערך, פשוט נקצה לו ערך :
a[10] =10;
מערכים ב- JS הם "דלילים", הכוונה לכך היא שאינדקסים של המערך לא צריכים לבוא כמספרים רציפים, הזכרון מוקצה אך ורק עבור אותם אלמנטים אשר מאוחסנים במערך באופן מעשי.
כך, כאשר מבצעים את שורות הקוד הבאות, JS מקצה זכרון רק עבור אינדקסים 0,5000 ולא עבור 4,999 האחרים :
array[0] = 3;
array[5000] = "This is a beautiful day"; 
שימו לב כי אלמנטים של מערך יכולים להתווסף גם לאובייקטים :
var t = new Triangle(5,3,7);
t[0] = "This is an array element of an Object !"
זוהי הוספת אלמנט של מערך לאובייקט ותו לא. מערכים אשר נוצרים בעזרת הבנאי ( )Array, הם בעלי מאפיינים מיוחדים שאינם קיימים באובייקטים.

4. אורך של מערך

כל המערכים, באשר הם, בעלי תכונה שנקראת "length"-אורך. בשל העובדה כי מערכים יכולים להכיל אלמנטים לא מוגדרים, אורך המערך הינו תמיד אחד יותר מהאלמנט האחרון במערך שהוגדר (בעל האינדקס הגבוה ביותר שהוגדר). תכונה זו מעודכנת אוטומטית כאשר אלמנט חדש נוסף למערך ,על מנת "לתחזק" קבוע זה.
דוגמא:
var array = new Array();	   // array.length ==0		( לא מוגדר אף אלמנט ) 
array = new Array(10);	   // array.length ==1		( אלמנטים ריקים 0-9 מוגדרים )
array = new Array(1,2,3);	   // array.length ==3		( אלמנטים 0-2 מוגדרים ) 
array = [4,5];		   // array.length ==2		( אלמנטים 0,1 מוגדרים ) 
array[5] = -1;		   // array.length ==6		( אלמנטים 0,1,5 מוגדרים ) 
array[49] = 0;	            // array.length ==50		( אלמנטים 0,1,5,49 מוגדרים )
השימוש השכיח ביותר לתכונת האורך במערכים הוא במעבר על איברי המערך בלולאה עפ"י אורכו :
var fruits = ["mango","banana","melon","cherry"]; 
for (var i=0; i < fruits.length ; i++ )
alert (fruits[i]);
כמובן שבדוגמא זו אנו מתבססים על כך כי אינדקסי איברי המערך הינם מס' רציפים. במידה וזה אינו המקרה נצטרך לבצע בדיקה האם האיבר הספציפי קיים :
for(var i=0; i < fruits.length ; i++)
if (fruits[i]) 
  alert (fruits[i]);
תכונת האורך היא בעלת ערך קריאה/כתיבה.
אם נציב בתכונה זו ערך קטן יותר מאורכו האמיתי של המערך הוא ייקטע עפ"י ערכו החדש. כל אלמנט שאינו נכלל באורך זה מושמט, וערכו נעלם.
אם נציב בתכונה זו ערך גדול יותר מאורכו האמיתי של המערך, אלמנטים לא מוגדרים יתווספו למערך בסופו על מנת להתאים את הגודל "החדש".

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

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

5. מתודות של מערכים

ישנן מתודות הפועלות על מערכים, רובן בשימוש גרסאות 1.1 ומעלה ( חלקן מגרסא 1.2 ).
join( )
מתודה זו הופכת את כל האלמנטים של המערך למחרוזת ומשרשרת אותם :
var arr = [1,2,3];
s = arr.join();		// result : s == "123"
בצורה זו נקבל תוצאה אחרת, כאשר האיברים מופרדים ע"י פסיק :
s = arr.join(" , ");		// result : s == "1,2,3"
reverse( )
מתודה זו הופכת את סדר איברי המערך :
sort( )
מתודה זו ממיינת את איברי המערך. כאשר היא נקראת ללא ארגומנטים, ממיינת עפ"י סדר אלפביתי ( באופן זמני הופכת את האיברים למחרוזות כשנדרש ע"מ לבצע את ההשוואה ).
ע"מ למיין את המערך עפ"י סדר אחר, חובה להעביר פונקצית השוואה בתור ארגומנט למתודה. פונקציה זו היא המחליטה מי משני הארגומנטים המושווים יופיע לפני האחר במערך הממוין.
אם האיבר הראשון צריך להופיע לפני האחר, פונקצית ההשוואה צריכה להחזיר מס' בעל ערך קטן מ- 0.
במקרה ההפוך, יוחזר מס' בעל ערך גדול מ- 0, אחרת, אם האיברים שווים/זהים, יוחזר כערך המס' 0.
לדוגמא, על מנת למיין איברי מערך בסדר נומרי :
var ar = [78,1758,6,297,843];
ar.sort();
ar.sort(function(a,b){ return a-b;});
בשל העובדה כי פונקצית העזר מופיעה רק פעם אחת, ואין לה שימוש נוסף, יכולים אנו להשתמש בפונקציה אנונימית (ללא שם) בעזרת הבנאי של Function( )
slice( )
מתודה זו מחזירה חלק מהמערך, החלק המצויין/המפורט.
שני הארגומנטים שלה מגדירים את ההתחלה והסיום של אותו חלק שצריך להיות מוחזר.
הערך המוחזר כולל את האיבר הנמצא באינדקס ההתחלה, אך אינו כולל את האיבר הנמצא באינדקס הסיום (הארגומנט השני).
אם מצויין ארגומנט אחד בלבד, המערך המוחזר מכיל את כל האיברים מאותו מקום במערך ועד לסופו. אם אחד מן הערכים שלילי, הוא מציין את האיבר במערך באופן יחסי לסופו, למשל , ארגומנט (1-)מייצג את האיבר האחרון במערך.
var a = [1,2,3,4,5];
a.slice(0,3);		// returns [1,2,3]
a.slice(3);		// returns [4,5]
a.slice(1,-1);		// returns [2,3,4] 
a.slice(-3,-2);		// returns [3] .Buggy in IE 4: returns [1,2,3] 
push( ) pop( )
זוג מתודות, המאפשרות לנו שימוש במערכים כאילו הם מחסניות (אינן נתמכות ב- i.e4).
push( ) מוסיפה איבר אחד או יותר לסוף המערך, ומחזירה את הערך של האיבר האחרון.
pop( ) מבצעת את ההיפך, מסירה את האיבר האחרון מהמערך, מקטינה את אורך המערך ומחזירה את הערך של האיבר המוסר.
שתי המתודות משנות את המערך הספציפי ואינן מייצרות העתק של המערך עם השינויים. צירוף זה של מתודות מאפשר לנו לממש את עיקרון המחסנית
(LIFO – Last In First Out).
unshift( ) shift( )
זוג מתודות אלה, שגם כן אינן נתמכות ב- i.e4, דומות מאוד למתודות הנ"ל, אלא שהן מכניסות ומסירות אלמנטים מתחילתו של מערך.
( )unshift מוסיפה איבר/איברים לתחילתו של המערך, מסיטה אותם, על מנת לפנות מקום לאיבר/איברים החדשים ומחזירה את אורכו החדש של המערך.
( )shift מסירה את האיבר הראשון במערך ומחזירה אותו, מסיטה חזרה את כל איברי המערך למקומות שהתפנו.
דוגמאות :
var arr = [];	         // arr : []
arr.unshift(1);		// arr : [1]		returns 1
arr.unshift(22);	         // arr : [22,1]		returns 2 
arr.shift();		// arr : [1]		returns 22
arr.unshift(3,[4,5]);	// arr : [3,[4,5],1]	returns 3
arr.shift();		// arr :[[4,5],1]	         returns 3
arr.shift();		// arr : [1]		returns [4,5] 
arr.shift();		// arr : []		returns 1
toString( )
המתודה toString( ) ניתנת לשימוש גם במערך, כמו בכל אובייקט. עבור מערך, מתודה זו הופכת כל אחד מאיבריו למחרוזת, כאשר הם מופרדים בפסיק (המתודה נקראת עבור איברי המערך הספציפיים במידת הצורך)
לדוגמא :
[1,2,3].toString()	        // '1,2,3' 
["a","b","c"].toString()  // 'a,b,c'
[1, [2,'c']].toString()   // '1,2,c'