سرور مجازی NVMe

شمارش تعداد رخدادهای عنصر در آرایه جاوا اسکریپت هنگام کار با آرایه‌ها در جاوا اسکریپت، اغلب با موقعیت‌هایی مواجه می‌شویم که از ما می‌خواهند تعداد وقوع یک عنصر خاص در آن آرایه را بشماریم – این عنصر می‌تواند یک رشته، شی، عدد یا حتی یک بولی باشد. . در این مقاله به چند روش برای شمارش می پردازیم…

JavaScript (JS)برنامه نویسی

توسط مهران در دی ۱۹, ۱۴۰۲

سرفصلهای مطلب

زمان لازم برای مطالعه: 6 دقیقه

معرفی

هنگام کار با آرایه‌ها در جاوا اسکریپت، اغلب با موقعیت‌هایی مواجه می‌شویم که از ما می‌خواهند تعداد رخدادهای یک عنصر خاص در آن آرایه را بشماریم – این عنصر می‌تواند یک رشته، شی، عدد یا حتی یک بولی باشد.

در این مقاله، چندین روش برای شمارش تعداد دفعات یک عنصر یا همه عناصر در یک آرایه جاوا اسکریپت را بررسی خواهیم کرد. ما همچنین نگاهی به روش شمارش تعداد وقوع عناصر در آرایه ای از آرایه ها با مسطح کردن آرایه خواهیم داشت.

روش شمارش وقایع عنصر با استفاده از حلقه ها

این for حلقه یکی از روش های استاندارد برای حلقه زدن از طریق یک آرایه است. این به ما اجازه می دهد تا روی هر عنصر یک آرایه حلقه بزنیم و آن را با عنصری که به دنبال آن هستیم مقایسه کنیم. به این ترتیب، ما می توانیم تعداد وقوع آن عنصر را در یک آرایه بشماریم. همچنین می‌توانیم از آن برای شمارش تعداد رخدادهای همه عناصر در آرایه استفاده کنیم، اما در ادامه این مقاله به این مورد خواهیم پرداخت. در حال حاضر، فرض می کنیم که می خواهیم تعداد وقوع یک عنصر خاص را پیدا کنیم.

بهترین راه حل: برای-از حلقه

بدیهی است ، JavaScript دارای داخلی است for حلقه ما می توانیم استفاده کنیم، اما، برای آسان تر کردن کارها، می توانیم از اصلاح آن استفاده کنیم – the for-of حلقه به این ترتیب، به جای دسترسی به هر عنصر توسط شاخص آن در آرایه، می توانیم به مقدار خود عنصر دسترسی پیدا کنیم.

توجه داشته باشید: JavaScript ES2015 معرفی کرد for-of حلقه جایگزینی برای array.forEach() روشی که قبلاً برای تکرار روی هر عنصر آرایه و اعمال برخی تغییرات در هر یک از آنها استفاده می شد. تفاوت اصلی بین for-of و forEach() این است که اولین مورد با آن سازگار است async کارکرد. در این مقاله، ما ترجیح داده‌ایم که در درجه اول از آن استفاده کنیم for-of حلقه به جای forEach() این روش فقط برای ایمن بودن در یک سناریوی ناهمزمان است، اما اگر با آن اذیت نمی‌شوید، راحت از آن استفاده کنید forEach() بجای!

اول از همه، بیایید نگاهی به چند بار بیاندازیم یک عنصر خاص رخ می دهد در یک آرایه برای انجام این کار ، ما باید تنظیم کنیم counter متغیر به 0، سپس از طریق آرایه حلقه کنید و آن را افزایش دهید counter هر بار که عنصر مورد نظر خود را پیدا می کنیم توسط یکی. وقتی در کل آرایه حلقه می کنیم ، counter تعداد دفعات عنصر مورد جستجو را ذخیره می کند:

const allStudentsAge = (19, 22, 18, 19, 16, 18, 19, 21, 24);
let target = 19;

let counter = 0;
for (studentAge of allStudentsAge) {
  if (studentAge == target) {
        counter++;
    }
};

console.log(counter); // 3

شرایطی که ما داریم آرایه ای از آرایه ها کمی پیچیده تر است در آن صورت، ابتدا باید آرایه را مسطح کنیم تا تمام عناصر با استفاده از آرایه در یک آرایه قرار گیرند flat() روش:

const allStudentsAge = (
    (1, 19),
    (3, 4),
    (5, 19),
    (7, 8, 19),
    (10, 11, 12, 13, 14, 15),
    (19, 22, 18, 19, 16, 18, 19, 21, 24)
);

let target = 19;

let counter = 0;
for (studentAge of allStudentsAge.flat()) {
  if (studentAge == target) {
        counter++;
    }
};

console.log(counter); // 6

این همچنین برای آرایه ها کار می کند عناصر انواع مختلف داده. بیایید یک آرایه نمونه با انواع داده های مختلف ایجاد کنیم و بررسی کنیم که آیا می توانیم تعداد وقوع یک عنصر خاص را بشماریم یا خیر:

const myArray = (false, 24, "English", false, "english", 22, 19, false, "English", 19);

اکنون می‌توانیم یک تابع قابل استفاده مجدد ایجاد کنیم که تعداد رخدادهای عنصر داده شده در آرایه داده شده را می‌شمارد:

const checkOccurrence = (array, element) => {
    let counter = 0;
    for (item of array.flat()) {
        if (item == element) {
            counter++;
        }
    };
    console.log(counter);
};

بیایید بررسی کنیم که آیا تابعی که ایجاد کرده ایم واقعاً کار می کند یا خیر:

checkOccurrence(myArray, false); // 3
checkOccurrence(myArray, 19); // 2
checkOccurrence(myArray, "english"); // 1

ما تأیید کردیم که سه نمونه از عنصر وجود دارد false و دو مورد از عنصر 19، که درست است، اما چرا فقط یک عنصر وجود دارد "english" به جای سه؟ این ناشی از حساسیت به حروف کوچک و بزرگ از تابعی که ایجاد کرده‌ایم – بهترین راه برای حل این موضوع این است که تمام عناصر رشته را قبل از شمارش به حروف بزرگ (یا کوچک) تبدیل کنیم:

const checkOccurrence = (array, element) => {
    let counter = 0;
    for (item of array.flat()) {
        if (typeof item === "string") {
            let newItem = item.toLowerCase();
            if (newItem == element) {
                counter++;
            }
        } else {
            if (item == element) {
                counter++;
            }
        }
    };
    console.log(counter);
};

وقتی اکنون وقایع عنصر را حساب می کنیم "english"، checkOccurrence() تابع برمی گردد 3 زیرا دیگر حساس به مورد نیست:

checkOccurrence(myArray, "english"); // 3

جایگزین شماره 1: برای حلقه

اگر به دلایلی نیاز به دسترسی به شاخص هر عنصر در یک آرایه دارید، می توانید از Basic نیز استفاده کنید for حلقه به جای for-of :

const checkOccurrence = (array, element) => {
    let counter = 0;
    for (let i = 0; i <= array.length; i++) {
        if (array(i) == element) {
            counter++;
        }
    }
    console.log(counter);
};

می‌توانیم بررسی کنیم که این همان نتیجه‌ای را به ما می‌دهد که با همان تابع ایجاد شده است for-of حلقه:

checkOccurrence(myArray, false); // 3
checkOccurrence(myArray, 19); // 2
checkOccurrence(myArray, "english"); // 1

جایگزین شماره 2: برای هر() روش

یکی دیگر از جایگزین های ممکن استفاده از forEach() روش تکرار روی تمام عناصر یک آرایه:

const checkOccurrence = (array, element) => {
    let counter = 0;
    array.forEach()for (let i = 0; i <= array.length; i++) {
        if (array(i) == element) {
            counter++;
        }
    }
    console.log(counter);
};

این کار همان نتیجه عملکردهای قبلی را برای ما به ارمغان می آورد، اما باز هم، هنگام استفاده از آن مراقب باشید forEach() روش در یک محیط ناهمزمان:

checkOccurrence(myArray, false); // 3
checkOccurrence(myArray, 19); // 2
checkOccurrence(myArray, "english"); // 1

تعداد وقوع همه عناصر را بررسی کنید

تا کنون، روش شمارش موارد را دیده ایم یک عنصر خاص. حال، بیایید ببینیم که چگونه می توان موارد را شمارش کرد همه عناصر و هم عنصر و هم تعداد رخدادها را به عنوان یک شی برمی گرداند.

پیشنهاد می‌کنیم بخوانید: محاسبه ریشه مربع یک عدد در پایتون

برای شروع، یک شی خالی برای ذخیره هر عنصر آرایه به عنوان کلید و تعداد رخدادها به عنوان مقدار می سازیم. سپس با استفاده از آرایه را حلقه می کنیم for-of حلقه، و روی در هر تکرار، اگر عنصر خاصی از قبل در شی وجود داشته باشد، تعداد آن را افزایش می‌دهیم یا تعداد آن را روی 1 در غیر این صورت:

const myArray = (false, 24, "English", false, "english", 22, 19, false, "English", 19);

let counter = {};
for (element of myArray.flat()) {
    if (counter(element)) {
        counter(element) += 1;
    } else {
        counter(element) = 1;
    }
};
console.log(counter);

کد قبلی شیء حاوی تعداد دفعات هر عنصر را در خروجی می دهد myArray:

{
    "19": 2,
    "22": 1,
    "24": 1,
    "English": 2,
    "english": 1,
    "false": 3
}

فرض کنید هنوز هم می خواهیم اجتناب از حساسیت به حروف کوچک و بزرگ، می توانیم کاری شبیه به این انجام دهیم:

const myArray = (false, 24, "English", false, "english", 22, 19, false, "English", 19);

let counter = {};
for (element of myArray.flat()) {
    if (typeof element === "string") {
        let newItem = element.toLowerCase();
        if (counter(newItem)) {
            counter(newItem) += 1;
        } else {
            counter(newItem) = 1;
        }
    } else {
        if (counter(element)) {
            counter(element) += 1;
        } else {
            counter(element) = 1;
        }
    }
});
console.log(counter);

با این کار شیء زیر را خروجی می دهید:

{
    "19": 2,
    "22": 1,
    "24": 1,
    "false": 3,
    "english": 3
}

روش شمارش اتفاقات عناصر با استفاده از کاهش دادن()

reduce() یک روش قدرتمند است که با استفاده از آن می توان به راحتی تعداد رخدادهای هر عنصر در یک آرایه را با تنها بدست آورد چند خط کد. تابع callback و مقدار اولیه را می پذیرد که برای ما یک شی خالی است تا بتوانیم بعداً آن را پر کنیم:

const myArray = (false, 24, "English", false, "english", 22, 19, false, "English", 19);

let countObject = myArray.reduce(function (
    count,
    currentValue
) {
    return (
        count(currentValue) ? ++count(currentValue) : (count(currentValue) = 1),
        count
    );
},
{});

console.log(countObject);

این یک شی حاوی عناصر به عنوان کلید و تعداد رخدادها به عنوان مقادیر را خروجی می دهد:

{
    "19": 2,
    "22": 1,
    "24": 1,
    "false": 3,
    "English": 2,
    "english": 1
}

روش شمارش رخدادهای عنصر با استفاده از فیلتر() روش

در قسمت قبل روش استفاده از حلقه ها و reduce() روشی برای موقعیت های مختلف که در آن ممکن است بخواهیم تعداد رخداد عناصر در یک آرایه جاوا اسکریپت را بشماریم. جدای از حلقه ها و reduce()، همچنین می توانیم از روش های دیگری مانند filter()، برای تعیین تعداد وقوع یک عنصر خاص در یک آرایه.

پیشنهاد می‌کنیم بخوانید: سخت افزار برای استخراج اتریوم

برای انجام این کار، آن را فیلتر می کنیم و سپس یک آرایه را پر می کند روی شرطی که از آن طول را با استفاده از عبارت بدست می آوریم length ویژگی:

const myArray = (false, 24, "English", false, "english", 22, 19, false, "English", 19);

const itemCounter = (array, item) => {
    return array.filter((currentItem) => currentItem == item).length;
};

console.log(itemCounter(myArray, 19)); // 2

استفاده کردن لوداش برای شمارش رخدادهای عنصر

احتمالاً بهتر است بسته های اضافی را فقط به منظور شمارش عناصر در یک آرایه نصب نکنیم، اما اگر قبلاً از لوداش کتابخانه در پروژه ما، استفاده از آن برای شمارش عناصر ضرری ندارد. این .countBy() متد در Lodash یک آرایه را می پذیرد و یک شی را برمی گرداند. این شی شامل عناصر و تعداد آنها به عنوان جفت کلید-مقدار است:

const myArray = (false, 24, "English", false, "english", 22, 19, false, "English", 19);

let lodash = _;
let elementOccurrences = _.countBy(myArray);
console.log(elementOccurrences);

این یک شی به ما می دهد:

{
    "19": 2,
    "22": 1,
    "24": 1,
    "false": 3,
    "English": 2,
    "english": 1
}

نتیجه

اگر نیاز به شمارش تعداد وقوع عناصر در یک آرایه دارید، احتمالا بهترین گزینه استفاده از for-of حلقه همانطور که در این مقاله نشان داده شده است. آن است async امن است، اما هنوز یک راه بسیار ساده برای تکرار در کل آرایه و شمارش عناصر مورد نظر است. ما همچنین نگاهی به سایر رویکردهای جایگزین – اساسی – انداخته‌ایم for حلقه، forEach()، و filter() روش.

اگر نیاز دارید به تعداد دفعات هر عنصر در یک آرایه نگاهی بیندازید، ما همچنین شما را تحت پوشش قرار داده ایم – می توانید دوباره از for-of حلقه همچنین، می توانید استفاده کنید reduce() روش، یا لوداش کتابخانه

منتشر شده در 1403-01-09 04:58:03

امتیاز شما به این مطلب