array_unique() ב-PHP: הסרת ערכים כפולים

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

<?php
$tags = ["php", "arrays", "php", "tips", "arrays", "php"];

$unique = array_unique($tags);
print_r($unique);

print_r(array_values($unique)); // renumbered 0, 1, 2

התוצאה הראשונה שומרת על המפתחות 0, 1, 3: המיקומים שבהם כל ערך הופיע לראשונה. עטפו את הקריאה ב-array_values() כשאתם רוצים רשימה נקייה, למשל לפני json_encode.

איך array_unique מחליטה ששני ערכים זהים

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

<?php
$mixed = [1, "1", 1.0, true, "01", 2];

var_dump(array_unique($mixed));                // compared as strings
var_dump(array_unique($mixed, SORT_REGULAR));  // compared with ==
var_dump(array_unique(["10", "1e1", "010"], SORT_NUMERIC));

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

הסרת כפילויות בלי תלות באותיות גדולות וקטנות

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

<?php
$languages = ["PHP", "Python", "php", "Go", "python", "GO", "Rust"];

$keys = array_unique(array_map('strtolower', $languages));
$result = array_values(array_intersect_key($languages, $keys));

print_r($result);

array_map בונה עותק באותיות קטנות עם אותם מפתחות, array_unique שומרת את המפתחות של המופעים הראשונים, ו-array_intersect_key בוחרת את המפתחות האלה מתוך המערך המקורי. לטקסט עם סימנים דיאקריטיים או ביפנית, השתמשו ב-mb_strtolower במקום ב-strtolower.

array_unique על מערך רב ממדי

בלי דגל, array_unique ממירה כל שורה למחרוזת "Array", כך שכל השורות נראות זהות ורק הראשונה שורדת, עם אזהרת "Array to string conversion" לכל שורה. העבירו SORT_REGULAR כדי להשוות שורות שלמות. כדי לשמור שורה אחת לכל ערך של שדה בודד, array_column עם null ומפתח אינדקס פשוטה יותר.

<?php
$signups = [
    ["email" => "ada@example.com", "plan" => "free"],
    ["email" => "bob@example.com", "plan" => "pro"],
    ["email" => "ada@example.com", "plan" => "free"],
    ["email" => "ada@example.com", "plan" => "pro"],
];

// Exact duplicate rows removed
print_r(array_unique($signups, SORT_REGULAR));

// One row per email: the last row for each email wins
print_r(array_values(array_column($signups, null, 'email')));

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

מציאה וספירה של ערכים כפולים

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

<?php
$votes = ["red", "blue", "red", "green", "blue", "red"];

$counts = array_count_values($votes);
print_r($counts);

$duplicates = array_keys(array_filter($counts, fn($n) => $n > 1));
echo "Duplicated: " . implode(", ", $duplicates) . "\n";

echo count($votes) === count(array_unique($votes))
    ? "No duplicates\n"
    : "Has duplicates\n";

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

ערכים ייחודיים מהר יותר במערכים גדולים

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

<?php
$ids = [];
for ($i = 0; $i < 200000; $i++) {
    $ids[] = $i % 1000;
}

$start = hrtime(true);
$a = array_unique($ids);
$t1 = (hrtime(true) - $start) / 1e6;

$start = hrtime(true);
$b = array_keys(array_flip($ids));
$t2 = (hrtime(true) - $start) / 1e6;

echo count($a), " unique values with array_unique\n";
echo count($b), " unique values with array_keys(array_flip())\n";
printf("array_unique: %.1f ms, array_flip: %.1f ms\n", $t1, $t2);

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