איך לבדוק אם מערך מכיל ערך ב-JavaScript וב-jQuery

הדרך המהירה ביותר לבדוק אם ערך קיים במערך ב-JavaScript היא באמצעות המתודה includes(). היא מחזירה true או false, ופועלת בכל הדפדפנים המודרניים:

const fruits = ['apple', 'banana', 'mango'];

fruits.includes('banana'); // true
fruits.includes('grape');  // false

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

אם עדיין אינכם מכירים מערכים, התחילו עם המדריך למערכים ב-JavaScript.

שימוש במתודה includes()

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

תחביר

array.includes(valueToFind[, fromIndex])

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

const numbers = [1, 2, 3, 4, 5];
const value = 3;

if (numbers.includes(value)) {
    console.log(`${value} exists in the array.`);
} else {
    console.log(`${value} does not exist in the array.`);
}
// Result: 3 exists in the array.

המתודה includes() משווה ערכים בהשוואה מחמירה, לכן '3' ו-3 אינם נחשבים זהים. בניגוד ל-indexOf(), היא כן מזהה ערכי NaN.

גם למחרוזות יש מתודת includes() משלהן: 'Catch Me If You Can'.includes('Me') מחזירה true. במחרוזות היא מאתרת כל רצף תווים (substring), ולא רק ערך שלם.

שימוש ב-indexOf() כדי לקבל את המיקום

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

תחביר

array.indexOf(searchElement[, fromIndex])

הנה דוגמה:

const moviesList = ['The Godfather', 'Forrest Gump', 'The Matrix', 'Inception', 'Catch Me If You Can', 'Pulp Fiction'];

moviesList.indexOf('Pulp Fiction');
// Result: 5
moviesList.indexOf('The Nun');
// Result: -1

// As an existence check, compare against -1
if (moviesList.indexOf('Inception') !== -1) {
    console.log('Found it');
}

בדומה ל-includes(), גם indexOf() משתמשת בהשוואה מחמירה, אבל אינה מזהה NaN: הביטוי [NaN].indexOf(NaN) מחזיר -1.

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

בדיקת מערך אובייקטים עם some() ו-find()

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

במקום זאת, העבירו פונקציית callback שבודקת את המאפיין שמעניין אתכם. המתודה Array.some() מחזירה true אם לפחות אלמנט אחד עומד בתנאי:

const users = [
    { name: 'Alice', age: 25 },
    { name: 'Bob', age: 30 },
    { name: 'Charlie', age: 35 }
];

const hasBob = users.some(u => u.name === 'Bob');
console.log(hasBob);
// Result: true

המתודה Array.find() מחזירה את האלמנט התואם הראשון עצמו, או undefined אם אין התאמה:

const user = users.find(u => u.name === 'Bob');
console.log(user);
// Result: { name: 'Bob', age: 30 }

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

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

המתודה includes() רגישה לאותיות גדולות וקטנות (case-sensitive), לכן 'Apple' לא יתאים ל-'apple'. לבדיקה שאינה תלויה ברישיות, השתמשו ב-some() והמירו את שני הצדדים לאותיות קטנות:

const tags = ['JavaScript', 'CSS', 'WordPress'];
const search = 'css';

tags.some(tag => tag.toLowerCase() === search.toLowerCase());
// Result: true

כדי לבדוק כמה ערכים בו-זמנית, שלבו את includes() עם every() (כולם חייבים להופיע) או עם some() (מספיק שאחד מהם יופיע):

const skills = ['html', 'css', 'javascript'];

['html', 'css'].every(s => skills.includes(s));
// Result: true (all exist)

['php', 'css'].some(s => skills.includes(s));
// Result: true (at least one exists)

חיפוש מהיר במערכים גדולים בעזרת Set

כל קריאה ל-includes() סורקת את המערך מתחילתו. לבדיקה אחת זה בסדר גמור, אבל אם אתם בודקים ערכים רבים מול אותו מערך גדול, הסריקות החוזרות כבר מורגשות.

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

const allowedIds = new Set([101, 205, 309, 412 /* ...thousands more */]);

allowedIds.has(309); // true
allowedIds.has(999); // false

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

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

שימוש בלולאת for

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

function contains(arr, value) {
    for (let i = 0; i < arr.length; i++) {
        if (arr[i] === value) {
            return true;
        }
    }
    return false;
}

contains(['The Matrix', 'Inception'], 'Inception'); // true
contains(['The Matrix', 'Inception'], 'Avatar');    // false

המתודה includes() עושה את אותו הדבר בשורה אחת, ולכן עדיף להשתמש בה, אלא אם הלולאה צריכה לעשות יותר מהשוואה.

שימוש ב-jQuery.inArray()

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

תחביר

jQuery.inArray(value, array[, fromIndex])

הנה דוגמה:

const arr = [4, 'Pete', 8, 'John'];

$.inArray('John', arr);    // 3
$.inArray(4, arr);         // 0
$.inArray('Karl', arr);    // -1
$.inArray('Pete', arr, 2); // -1 (the search starts at index 2)

אותה מלכודת של indexOf() קיימת גם כאן, וזו הטעות הנפוצה ביותר בשימוש ב-inArray():

// Wrong: 'John' at index 0 is falsy, a miss (-1) is truthy
if ($.inArray('John', arr)) { ... }

// Right
if ($.inArray('John', arr) !== -1) { ... }

שימו לב: בניגוד למה שנכתב במדריכים רבים, inArray() אינה מתודה לחיפוש במחרוזות. כשמעבירים לה מחרוזת, היא מאתרת רק תווים בודדים: $.inArray('Me', 'Catch Me') מחזירה -1. לחיפוש בטקסט השתמשו במתודת includes() של מחרוזות.

עבור מערך אובייקטים ב-jQuery השתמשו ב-$.grep(), שמחזירה את האלמנטים התואמים:

const hasBob = $.grep(users, u => u.name === 'Bob').length > 0;
// Result: true

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

באיזו מתודה כדאי להשתמש?

הנה השוואה קצרה:

שאלות נפוצות

שאלות נפוצות על בדיקת ערכים במערכי JavaScript:

סיכום

לבדיקה פשוטה השתמשו ב-includes(). עברו ל-indexOf() כשאתם צריכים את המיקום, ל-some() או find() כשהמערך מכיל אובייקטים, ול-Set כשאתם מבצעים בדיקות רבות מול אותם נתונים. המתודה jQuery.inArray() עדיין עובדת בפרויקטים של jQuery, כל עוד אתם משווים את התוצאה שלה מול -1.

בקוד שלי אני משתמש קודם כל ב-includes(), ועובר ל-some() ברגע שהמערך מכיל אובייקטים. למידע נוסף על עבודה עם מערכים, תנו מבט בפוסט על מיון מערכים ב-JavaScript.