הגדרה ושימוש במערכים ב-PHP

מערכים ב-PHP

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

קיימות מספר סיבות לשימוש במערכים:

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

קיימים כמה מאפיינים למערכים ב-PHP, נסקור אותם:

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

הגדרת מערכים וגישה לאיברים במערך

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

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

מערך מבוסס אינדקס (מערך עם מפתח מספרי)

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

דוגמה:

<?php
$colors = ['Red', 'Green', 'Blue'];
echo $colors[1]; // Outputs: Green
?>

בדוגמה זו הגדרנו מערך בשם colors המכיל 3 איברים שערכיהם: Red, Green, Blue. האינדקסים נקבעים אוטומטית מ-0 לאיבר הראשון ועד 2 לאיבר השלישי. כאשר אנו ניגשים לאיבר באינדקס 1 (כלומר האיבר השני במערך) מוחזר הערך Green.

מערך אסוציאטיבי (מערך עם מפתח מחרוזת)

במערך מסוג זה, אנו קובעים זוגות: מפתח וערך. המפתחות הם מטיפוס מחרוזת.

דוגמה:

<?php
$user = ['name' => 'Alice', 'phone' => '050-8765432'];
echo $user['phone']; // Outputs: 050-8765432
?>

בדוגמה זו הגדרנו מערך בשם user המכיל 2 איברים. האיבר הראשון עם המפתח name והערך Alice, האיבר השני עם המפתח phone והערך 050-8765432. כאשר אנו ניגשים לאיבר עם המפתח phone מוחזר הערך המקושר למפתח הזה, כלומר, הערך 050-8765432.

מערך ריק

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

דוגמה:

<?php
$emptyArray = [];
?>

הוספת איברים למערך ושינוי איברי מערך קיימים

ניתן בצורה דינמית להוסיף איברים או לערוך איברים קיימים במערך.

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

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

דוגמה:

<?php
$fruits = ['Apple', 'Banana'];
$fruits[] = 'Cherry'; // Adds Cherry at the next index
echo $fruits[2]; // Outputs: Cherry
?>

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

דוגמה:

<?php
$fruits = ['Apple', 'Banana'];
echo $fruits[1]; // Outputs: Banana
$fruits[1] = 'Orange'; // Changes the value Banana to Orange
echo $fruits[1]; // Outputs: Orange
?>

הוספה ושינוי איברים במערכים אסוציאטיבים

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

דוגמה:

<?php
$person = ['name' => 'John', 'age' => 35];
$person['father'] = 'David'; // Adds a new element with the index father and the value David
echo $person['father']; // Outputs: David
?>

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

דוגמה:

<?php
$person = ['name' => 'John', 'age' => 35];
$person['age'] = 36; // Updates the value of age
echo $person['age']; // Outputs: 36
?>

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

מחיקת ערכים ממערך

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

דוגמה:

<?php
$array = [1, 2, 3, 4, 5];

// Remove element at key 2
unset($array[2]);

print_r($array);
// Outputs: [0 => 1, 1 => 2, 3 => 4, 4 => 5]
?>

נשים לב שמחיקת האיבר במערך משמרת את האינדקסים המקוריים, כך שהאינדקסים כבר אינם רציפים. בדוגמה לעיל, הסרנו את האיבר עם אינדקס 2, ויצרנו מערך עם אינדקסים 0, 1, 3, 4 (ללא האינדקס 2).

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

דוגמה:

<?php
$array = array_values($array);
// Outputs: [0 => 1, 1 => 2, 2 => 4, 3 => 5]
?>

מערכים רב מימדיים

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

דוגמה:

<?php
$products = [
    ["name" => "Laptop", "price" => 1000],
    ["name" => "Tablet", "price" => 500],
];
echo $products[0]['name']; // Outputs: Laptop
?>

בדוגמה זו הגדרנו מערך מבוסס אינדקס בשם products המכיל 2 איברים, שכל אחד מהם הוא מערך אסוציאטיבי. האיבר הראשון הוא מערך שכולל 2 איברים: איבר עם המפתח name והערך Laptop ואיבר עם המפתח price והערך 1000. האיבר השני גם הוא מערך שכולל 2 איברים: איבר עם המפתח name והערך Tablet ואיבר עם המפתח price והערך 500. בדוגמה אנו ניגשים לאיבר הראשון (אינדקס 0) ובתוכו לאיבר עם המפתח name.

ניתן ליצור מערכים בעלי יותר מ-2 מימדים. נראה מערך בן 3 מימדים להלן.

דוגמה:

<?php
// Defining a 3D array
$cube = [
    "Layer1" => [
        "Row1" => ["A1", "B1", "C1"],
        "Row2" => ["A2", "B2", "C2"],
        "Row3" => ["A3", "B3", "C3"],
    ],
    "Layer2" => [
        "Row1" => ["D1", "E1", "F1"],
        "Row2" => ["D2", "E2", "F2"],
        "Row3" => ["D3", "E3", "F3"],
    ],
    "Layer3" => [
        "Row1" => ["G1", "H1", "I1"],
        "Row2" => ["G2", "H2", "I2"],
        "Row3" => ["G3", "H3", "I3"],
    ],
];

// Accessing elements from the 3D array
echo $cube["Layer1"]["Row1"][0]; // Outputs: A1
echo $cube["Layer2"]["Row3"][1]; // Outputs: E3
echo $cube["Layer3"]["Row2"][2]; // Outputs: I2

// Iterating through the 3D array
foreach ($cube as $layer => $rows) {
    echo "In $layer:\n";
    foreach ($rows as $row => $columns) {
        echo "  $row contains: " . implode(", ", $columns) . "\n";
    }
}

// Output:
// A1
// E3
// I2
// In Layer1:
//   Row1 contains: A1, B1, C1
//   Row2 contains: A2, B2, C2
//   Row3 contains: A3, B3, C3
// In Layer2:
//   Row1 contains: D1, E1, F1
//   Row2 contains: D2, E2, F2
//   Row3 contains: D3, E3, F3
// In Layer3:
//   Row1 contains: G1, H1, I1
//   Row2 contains: G2, H2, I2
//   Row3 contains: G3, H3, I3
?>

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

איטרציות על מערכים ב-PHP

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

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

איטרציה על מערכים באמצעות לולאת for

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

דוגמה:

<?php
$numbers = [1, 2, 3];
for ($i = 0; $i < count($numbers); $i++) {
    echo $numbers[$i] . "\n";
}
?>

בדוגמה זו, הגדרנו את המערך numbers הכולל 3 איברים: איבר עם הערך 1 באינדקס 0, איבר עם הערך 2 באינדקס 1 ואיבר עם הערך 3 באינדקס 2. לולאת ה-for עוברת על המערך בצורה סדרתית באופן הבא: המשתנה i מקבל ערכים מ-0 ועד 2 (הפקודה count מייצגת את גודל המערך שהוא 3, והמשתנה i נבדק שהוא תמיד קטן מ-3) ובכל פעם ניגשים למערך באינדקס ה-i שלו. לולאת ה-for עושה למעשה 3 איטרציות, כאשר בכל איטרציה ערכו של i גדל ב-1, החל מ-0 ועד 2.

איטרציה על מערכים באמצעות לולאת foreach

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

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

דוגמה:

<?php
$fruits = ["Apple", "Banana", "Cherry"];
// foreach loop without keys
foreach ($fruits as $fruit) {
    echo $fruit . "\n";
}
?>

בדוגמה זו, הגדרנו את המערך fruits שכולל 3 איברים: איבר עם הערך Apple באינדקס 0, איבר עם הערך Banana באינדקס 1 ואיבר עם הערך Cherry באינדקס 2. לולאת ה-foreach עוברת על כל ערכי המערך, כאשר בכל איטרציה המשתנה fruit מקבל ערך נוסף מהמערך, החל מהערך הראשון Apple ועד הערך האחרון Cherry. נשים לב שאין התייחסות כלל בקוד לאינדקסים של האיברים, הטיפול הוא ישירות בערכים עצמם.

דוגמה נוספת:

<?php
$user = ["name" => "Alice", "age" => 30];
// foreach loop with keys
foreach ($user as $key => $value) {
    echo "$key: $value\n";
}
?>

בדוגמה זו, הגדרנו את המערך user שכולל 2 איברים: איבר עם המפתח name והערך Alice ואיבר עם המפתח age והערך 30. לולאת ה-foreach עוברת על כל איברי המערך, כאשר בכל איטרציה המשתנה key מקבל את המפתח של האיבר והמשתנה value מקבל את הערך של האיבר.

באופן כללי, ניתן לראות כי לולאות foreach כוללות קוד קריא יותר מאשר לולאות for, וככל שהדבר אפשרי נמליץ לעשות מעברים סידרתיים על מערכים באמצעות לולאות foreach. בפרקים הבאים נסקור בהרחבה נוספת את נושא הלולאות.

פירוק מערכים למשתנים נפרדים

ניתן "לפרק" מערך למשתנים נפרדים בכמה צורות.

פירוק מערך באמצעות הפונקציה list

הפונקציה list מאפשרת השמה של מערך למשתנים נפרדים ובכך לפצלו.

דוגמה:

<?php
$array = ["John", "Doe", 25];
list($firstName, $lastName, $age) = $array;
echo $firstName; // Outputs: John
echo $lastName; // Outputs: Doe
echo $age; // Outputs: 25
?>

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

דוגמה:

<?php
// Associative array
$array = ["key1" => "value1", "key2" => "value2", "key3" => "value3"];

// Disassembling with array_values() and list()
list($val1, $val2, $val3) = array_values($array);

echo $val1; // Outputs: value1
echo $val2; // Outputs: value2
echo $val3; // Outputs: value3
?>

פירוק מערך באמצעות השמה למערך אנונימי

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

דוגמה:

<?php
// Indexed array
$array = ["dog", "cat", "fish"];

// Disassembling with anonymous array
[$pet1, $pet2, $pet3] = $array;

echo $pet1; // Outputs: dog
echo $pet2; // Outputs: cat
echo $pet3; // Outputs: fish
?>

פירוק מערך באמצעות האופרטור שלוש נקודות (spread operator)

האופרטור 3 נקודות (...) מאפשר לאסוף את יתר הערכים של מערך שלא פוצל ולהכניסם למערך נפרד.

דוגמה:

<?php
// Indexed array
$array = [10, 20, 30, 40, 50];

// Disassembling with the spread operator
[$first, $second, ...$remaining] = $array;

echo $first; // Outputs: 10
echo $second; // Outputs: 20
print_r($remaining); // Outputs: [30, 40, 50]
?>

פירוק מערך באמצעות הפונקציה extract

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

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

דוגמה:

<?php
// Associative array
$array = ["name" => "John", "age" => 30, "city" => "New York"];

// Disassembling with extract()
extract($array);

echo $name; // Outputs: John
echo $age;  // Outputs: 30
echo $city; // Outputs: New York
?>

פירוק מערך באמצעות השמה למשתנים

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

דוגמה:

<?php
// Indexed array
$array = ["red", "green", "blue"];

// Manual disassembling
$color1 = $array[0];
$color2 = $array[1];
$color3 = $array[2];

echo $color1; // Outputs: red
echo $color2; // Outputs: green
echo $color3; // Outputs: blue
?>

מניפולציות מתקדמות על מערכים ב-PHP

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

count - מחזיר את מספר האיברים במערך.

דוגמה:

<?php
$fruits = ["Apple", "Banana", "Cherry"];
echo count($fruits); // Outputs: 3
?>

in_array - בודק אם קיים איבור עם הערך הנתון במערך.

דוגמה:

<?php
$fruits = ['apple', 'banana', 'orange'];

if (in_array('banana', $fruits)) {
    echo "Banana is in the array.\n";
} else {
    echo "Banana is not in the array.\n";
}

// Output: Banana is in the array.
?>

array_merge - ממזג 2 או יותר מערכים.

דוגמה:

<?php
$merged = array_merge(["A", "B"], ["C", "D"]);
print_r($merged); // Outputs: Array ( [0] => A [1] => B [2] => C [3] => D )
?>

array_unique - מסיר שכפולים ממערך.

דוגמה:

<?php
$array = [1, 2, 2, 3, 4, 4];
$uniqueArray = array_unique($array);
print_r($uniqueArray); // [1, 2, 3, 4]
?>

array_keys - מחזיר מערך עם המפתחות של מערך נתון.

array_values - מחזיר מערך עם הערכים של מערך נתון.

דוגמה:

<?php
$array = [
    "name" => "John",
    "age" => 25,
    "city" => "New York"
];

// Using array_keys
$keys = array_keys($array);
print_r($keys); // Outputs: Array ( [0] => name [1] => age [2] => city )

// Using array_values
$values = array_values($array);
print_r($values); // Outputs: Array ( [0] => John [1] => 25 [2] => New York )
?>

array_push - מוסיף איבר בסוף המערך.

array_pop - מסיר ומחזיר את האיבר מסוף המערך.

array_shift - מוסיף איבר בתחילת המערך.

array_unshift - מסיר ומחזיר את האיבר מתחילת המערך.

דוגמה:

<?php
$array = [1, 2, 3, 4];

// Using array_push
array_push($array, 5, 6);
print_r($array); // Outputs: Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 [5] => 6 )

// Using array_pop
$lastElement = array_pop($array);
echo $lastElement . "\n"; // Outputs: 6
print_r($array); // Outputs: Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 )

// Using array_shift
$firstElement = array_shift($array);
echo $firstElement . "\n"; // Outputs: 1
print_r($array); // Outputs: Array ( [0] => 2 [1] => 3 [2] => 4 [3] => 5 )

// Using array_unshift
array_unshift($array, 0, 1);
print_r($array); // Outputs: Array ( [0] => 0 [1] => 1 [2] => 2 [3] => 3 [4] => 4 [5] => 5 )
?>

sort - ממיין מערך לפי הערכים.

rsort - ממיין מערך לפי הערכים בסדר הפוך.

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

ksort - ממיין מערך לפי המפתחות.

usort - ממעין מערך באמצעות פונקציית מיון חיצונית.

דוגמה:

<?php
$array = [4, 2, 8, 6, 1];
$assocArray = ["c" => 4, "a" => 2, "b" => 8, "d" => 6, "e" => 1];

// Using sort
sort($array);
print_r($array); // Outputs: Array ( [0] => 1 [1] => 2 [2] => 4 [3] => 6 [4] => 8 )

// Using rsort
rsort($array);
print_r($array); // Outputs: Array ( [0] => 8 [1] => 6 [2] => 4 [3] => 2 [4] => 1 )

// Using asort
asort($assocArray);
print_r($assocArray); // Outputs: Array ( [e] => 1 [a] => 2 [c] => 4 [d] => 6 [b] => 8 )

// Using ksort
ksort($assocArray);
print_r($assocArray); // Outputs: Array ( [a] => 2 [b] => 8 [c] => 4 [d] => 6 [e] => 1 )

// Using usort
$customSortArray = [3, 1, 4, 1, 5, 9];
usort($customSortArray, function ($a, $b) {
    return $a % 2 <=> $b % 2; // Sort by odd/even
});
print_r($customSortArray); // Outputs a custom order based on the comparison function
?>

array_map - מפעיל פונקציית callback על כל אחד מאיברי המערך. לדוגמה: הכפלת כל איבר במערך בערך נתון.

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

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

דוגמה:

<?php
$array = [1, 2, 3, 4, 5];

// Using array_map
$doubled = array_map(fn($num) => $num * 2, $array);
print_r($doubled); // Outputs: Array ( [0] => 2 [1] => 4 [2] => 6 [3] => 8 [4] => 10 )

// Using array_filter to find even numbers
$evenNumbers = array_filter($array, fn($num) => $num % 2 === 0);
print_r($evenNumbers); // Outputs: Array ( [1] => 2 [3] => 4 )

// Using array_reduce to sum all values
$sum = array_reduce($array, fn($carry, $num) => $carry + $num, 0);
echo $sum; // Outputs: 15
?>

array_chunk - מפצל מערך למערכים נפרדים בגודל נתון.

array_splice - מוחק חלק מאיברי המערך ומחליף אותם באיברי מערך אחרים. האיברים שנמחקים מוחזרים.

array_slice - מחזיר חלק מתוך מערך, ללא שינוי המערך המקורי.

דוגמה:

<?php
$array = [1, 2, 3, 4, 5, 6, 7, 8];

// Using array_chunk
$chunks = array_chunk($array, 3);
print_r($chunks); 
// Outputs: Array ( [0] => Array ( [0] => 1 [1] => 2 [2] => 3 ) [1] => Array ( [0] => 4 [1] => 5 [2] => 6 ) [2] => Array ( [0] => 7 [1] => 8 ) )

// Using array_splice
$spliceArray = [1, 2, 3, 4, 5];
array_splice($spliceArray, 2, 2, [99, 100]);
print_r($spliceArray); 
// Outputs: Array ( [0] => 1 [1] => 2 [2] => 99 [3] => 100 [4] => 5 )

// Using array_slice
$slicedArray = array_slice($array, 2, 4);
print_r($slicedArray); 
// Outputs: Array ( [0] => 3 [1] => 4 [2] => 5 [3] => 6 )
?>