programming javascript Reduce js Count Object JavaScript

Hướng dẫn how do you count the number of occurrences of an element in an array in javascript? - làm thế nào để bạn đếm số lần xuất hiện của một phần tử trong một mảng trong javascript?

Giới thiệu

Khi làm việc với các mảng trong JavaScript, chúng tôi thường gặp các tình huống yêu cầu chúng tôi đếm số lần xuất hiện của một yếu tố cụ thể trong mảng đó - phần tử này có thể là một chuỗi, đối tượng, số hoặc thậm chí là boolean.

Trong bài viết này, chúng tôi sẽ xem qua một số phương pháp để đếm số lần xuất hiện của một phần tử hoặc tất cả các phần tử trong một mảng JavaScript. Chúng ta cũng sẽ xem xét cách đếm số lượng phần tử xuất hiện trong một mảng mảng bằng cách làm phẳng mảng trước.

Cách đếm các phần tử xuất hiện bằng cách sử dụng các vòng lặp

Vòng lặp

const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];

0 là một trong những phương pháp tiêu chuẩn để lặp qua một mảng. Nó cho phép chúng ta lặp qua từng phần tử của một mảng và so sánh nó với phần tử chúng ta đang tìm kiếm. Bằng cách đó, chúng ta có thể đếm số lần xuất hiện của phần tử đó trong một mảng. Chúng tôi cũng có thể sử dụng nó để đếm số lần xuất hiện của tất cả các yếu tố trong mảng, nhưng chúng tôi sẽ đề cập đến trường hợp đó sau trong bài viết này. Hiện tại, hãy giả sử chúng tôi muốn tìm số lần xuất hiện của yếu tố cụ thể.

Giải pháp tốt nhất: For-Of Loop

Rõ ràng, JavaScript có vòng lặp

const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];

0 tích hợp mà chúng ta có thể sử dụng, nhưng, để làm cho mọi thứ trở nên dễ dàng hơn một chút, chúng ta có thể sử dụng sửa đổi của nó - vòng lặp

const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];

2. Theo cách đó, thay vì truy cập vào từng phần tử bằng chỉ mục của nó trong mảng, chúng ta có thể truy cập giá trị của chính phần tử.

Lưu ý: JavaScript ES2015 đã giới thiệu vòng lặp

const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];

2. Đây là một giải pháp thay thế cho phương pháp
const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];
4, trước đây được sử dụng để lặp lại từng phần tử của một mảng và áp dụng một số thay đổi cho mỗi trong số chúng. Sự khác biệt chính giữa
const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];
2 và
const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];
6 là đầu tiên tương thích với các hàm
const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];
7. Trong bài viết này, chúng tôi đã chọn sử dụng chủ yếu vòng lặp
const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];
2 thay vì phương pháp
const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];
6 chỉ để an toàn trong một kịch bản không đồng bộ, nhưng nếu bạn không bận tâm đến điều đó, hãy thoải mái sử dụng
const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];
6! JavaScript ES2015 introduced the

const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];

2 loop. It is an alternative to

const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];

4 method, previously used to iterate over each element of an array and apply some changes to each of them. The primary difference between

const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];

2 and

const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];

6 is that the first is compatible with

const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];

7 functions. In this article, we've opted to primarily use the

const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];

2 loop instead of the

const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];

6 method just to be safe in an asynchronous scenario, but if you are not bothered with that, feel free to use

const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];

6 instead!

Trước hết, chúng ta hãy xem bao nhiêu lần một yếu tố cụ thể xảy ra trong một mảng. Để thực hiện điều này, chúng ta cần đặt biến

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

1 thành

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

2, sau đó lặp qua mảng và tăng

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

1 mỗi lần chúng ta tìm thấy phần tử chúng ta đang tìm kiếm. Khi chúng tôi lặp qua toàn bộ mảng,

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

1 sẽ lưu trữ số lần xuất hiện của phần tử chúng tôi đang tìm kiếm:

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

Một tình huống mà chúng ta có một mảng mảng phức tạp hơn một chút. Trong trường hợp đó, trước tiên chúng ta sẽ phải làm phẳng mảng để tất cả các phần tử đi vào một mảng bằng phương pháp

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

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

Điều này cũng hoạt động cho các mảng với các yếu tố của các loại dữ liệu khác nhau. Hãy tạo một mảng ví dụ với các loại dữ liệu khác nhau và kiểm tra xem liệu chúng ta có thể đếm số lần xuất hiện của một yếu tố nhất định không:

const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];

Bây giờ, chúng ta có thể tạo một hàm có thể tái sử dụng để đếm số lần xuất hiện của phần tử đã cho trong mảng đã cho:

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

Hãy kiểm tra xem chức năng chúng tôi đã tạo có thực sự hoạt động không:

checkOccurrence[myArray, false]; // 3
checkOccurrence[myArray, 19]; // 2
checkOccurrence[myArray, "english"]; // 1

Chúng tôi đã xác minh rằng có ba trường hợp của phần tử

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

6 và hai trường hợp của phần tử

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

7, điều này là chính xác, nhưng tại sao chỉ có một lần xuất hiện của phần tử

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

8 thay vì ba? Điều này là do độ nhạy trường hợp của hàm chúng tôi đã tạo - cách tốt nhất để giải quyết điều này là chuyển đổi tất cả các thành phần chuỗi thành chữ hoa [hoặc chữ thường] trước khi đếm chúng:

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];
};

Khi chúng ta đếm các sự xuất hiện của phần tử

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

8, hàm

checkOccurrence[myArray, false]; // 3
checkOccurrence[myArray, 19]; // 2
checkOccurrence[myArray, "english"]; // 1

0 trả về

checkOccurrence[myArray, false]; // 3
checkOccurrence[myArray, 19]; // 2
checkOccurrence[myArray, "english"]; // 1

1 vì nó không còn nhạy cảm trường hợp:

checkOccurrence[myArray, "english"]; // 3

Thay thế #1: cho vòng lặp

Nếu bạn cần truy cập chỉ mục của từng phần tử trong một mảng vì một số lý do, bạn cũng có thể sử dụng vòng lặp

const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];

0 cơ bản thay vì

const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];

const checkOccurrence = [array, element] => {
    let counter = 0;
    for [let i = 0; i  {
    let counter = 0;
    array.forEach[]for [let i = 0; i  {
    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];
};

0 là một phương pháp mạnh mẽ có thể được sử dụng để dễ dàng nhận được số lần xuất hiện của mỗi phần tử trong một mảng chỉ có một vài dòng mã. Nó chấp nhận hàm gọi lại và giá trị ban đầu, đối với chúng tôi là một đối tượng trống để chúng tôi có thể điền vào sau:

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

Điều này sẽ xuất ra một đối tượng chứa các phần tử dưới dạng các khóa và số lần xuất hiện dưới dạng giá trị:

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

Cách đếm các phần tử xuất hiện bằng phương thức bộ lọc []

Trong phần trước, chúng tôi đã thấy cách sử dụng các vòng lặp và phương thức

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];
};

0 cho các tình huống khác nhau mà chúng tôi có thể muốn đếm số lần xuất hiện của các phần tử trong một mảng JavaScript. Ngoài các vòng lặp và

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];
};

0, chúng ta cũng có thể sử dụng các phương pháp khác, chẳng hạn như

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];
};

3, để xác định số lần xuất hiện của một phần tử cụ thể trong một mảng.

Để thực hiện điều này, chúng tôi sẽ lọc nó và sau đó nó sẽ điền vào một mảng dựa trên điều kiện, từ đó chúng tôi sẽ có được độ dài bằng thuộc tính

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];
};

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

Sử dụng Lodash để đếm phần tử xuất hiện

Có lẽ tốt nhất là không cài đặt các gói bổ sung chỉ với mục đích đếm các phần tử trong một mảng, nhưng nếu chúng tôi đã sử dụng thư viện Lodash trong dự án của chúng tôi, sẽ không có hại gì khi sử dụng nó để đếm các phần tử. Phương thức

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];
};

5 trong Lodash chấp nhận một mảng và trả về một đối tượng. Đối tượng này chứa các phần tử và số lượng của chúng là các cặp giá trị khóa:

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

Điều này sẽ cung cấp cho chúng tôi một đối tượng:

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

Sự kết luận

Nếu bạn cần đếm số lần xuất hiện của các phần tử trong một mảng, có lẽ đặt cược tốt nhất của bạn là sử dụng vòng lặp

const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];

2 như trong bài viết này. Đó là an toàn

const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];

7, nhưng vẫn là một cách rất đơn giản để lặp lại toàn bộ các yếu tố mong muốn và số lượng. Chúng tôi cũng đã xem xét các phương pháp thay thế khác - phương pháp

const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];

0 cơ bản,

const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];

6 và

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];
};

Nếu bạn cần xem xét số lần xuất hiện của mỗi phần tử trong một mảng, chúng tôi cũng đã bảo vệ bạn - bạn có thể sử dụng lại vòng lặp

const myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];

2. Ngoài ra, bạn có thể sử dụng phương thức

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];
};

0 hoặc thư viện Lodash.

Làm thế nào để bạn đếm sự xuất hiện của một phần tử trong một mảng?

Chương trình Java để đếm số lần xuất hiện của một yếu tố trong .....

nhập java.util.scanner ;.

lớp công khai Count_occurrence ..

Công khai tĩnh chính Main [Chuỗi [] Args].

int n, x, đếm = 0, i = 0 ;.

Máy quét S = Máy quét mới [Hệ thống. In] ;.

Hệ thống. ngoài. in ["Nhập số của các phần tử bạn muốn trong mảng:"] ;.

Làm thế nào để bạn tính các sự xuất hiện trong JavaScript?

Trong JavaScript, chúng ta có thể đếm chuỗi xuất hiện trong một chuỗi bằng cách đếm số lần chuỗi có trong chuỗi. JavaScript cung cấp một hàm khớp [], được sử dụng để tạo tất cả các lần xuất hiện của một chuỗi trong một mảng.counting the number of times the string present in the string. JavaScript provides a function match[], which is used to generate all the occurrences of a string in an array.

Làm thế nào bạn sẽ tính toán có bao nhiêu yếu tố trong một mảng trong JavaScript?

Sự mô tả.Thuộc tính độ dài mảng JavaScript trả về một số nguyên 32 bit không dấu, chỉ định số lượng phần tử trong một mảng ..

Cú pháp.Cú pháp của nó như sau - mảng.length ..

Giá trị trả về.Trả về chiều dài của mảng ..

Thí dụ.Hãy thử ví dụ sau.....

Đầu ra.mảng.length là: 3 ..

Làm thế nào để bạn đếm số lần xuất hiện của các tên lặp lại trong một mảng các đối tượng trong Java?

Trong phương pháp này, chúng tôi làm theo các bước dưới đây.Tạo một mảng đầu ra trống.Sử dụng foreach lặp lại mảng đầu vào.Nếu có, thì hãy lặp lại mảng đầu ra và tìm kiếm nếu khóa của lần lặp hiện tại bằng với phím của vòng lặp mảng đầu vào thì tăng sự xuất hiện lên 1.