Hướng dẫn how do you count occurrences in javascript? - làm thế nào để bạn đếm số lần xuất hiện trong javascript?

Đây là chức năng nhanh nhất!

Tại sao nó nhanh hơn?

• Không kiểm tra char bởi char [với 1 ngoại lệ]
• Sử dụng một thời gian và gia số 1 var [số char Count var] so với A để kiểm tra độ dài và tăng 2 vars [thường là var i và var với số lượng char]
• Sử dụng cách ít vars
• Không sử dụng regex!
• Sử dụng chức năng [hy vọng] được tối ưu hóa cao

• Tất cả các hoạt động đều được kết hợp như chúng có thể, tránh bị chậm lại do nhiều hoạt động

  String.prototype.timesCharExist=function[c]{var t=0,l=0,c=[c+''][0];while[l=this.indexOf[c,l]+1]++t;return t};
  

Đây là phiên bản chậm và dễ đọc hơn:

    String.prototype.timesCharExist = function [ chr ] {
        var total = 0, last_location = 0, single_char = [ chr + '' ][0];
        while[ last_location = this.indexOf[ single_char, last_location ] + 1 ]
        {
            total = total + 1;
        }
        return total;
    };

Cái này chậm hơn vì bộ đếm, tên var dài và lạm dụng 1 var.

Để sử dụng nó, bạn chỉ cần làm điều này:

    'The char "a" only shows up twice'.timesCharExist['a'];

Chỉnh sửa: [2013/12/16]

Đừng sử dụng với Opera 12.16 trở lên! Sẽ mất gần 2,5 lần so với giải pháp Regex!

Trên Chrome, giải pháp này sẽ mất từ ​​14ms đến 20ms cho 1.000.000 ký tự.

Giải pháp Regex mất 11-14ms cho cùng một lượng.

Sử dụng một hàm [bên ngoài

    'The char "a" only shows up twice'.timesCharExist['a'];

Đây là mã được sử dụng:

    String.prototype.timesCharExist=function[c]{var t=0,l=0,c=[c+''][0];while[l=this.indexOf[c,l]+1]++t;return t};

    var x=Array[100001].join['1234567890'];

    console.time['proto'];x.timesCharExist['1'];console.timeEnd['proto'];

    console.time['regex'];x.match[/1/g].length;console.timeEnd['regex'];

    var timesCharExist=function[x,c]{var t=0,l=0,c=[c+''][0];while[l=x.indexOf[c,l]+1]++t;return t;};

    console.time['func'];timesCharExist[x,'1'];console.timeEnd['func'];

Kết quả của tất cả các giải pháp nên là 100.000!

Lưu ý: Nếu bạn muốn chức năng này đếm nhiều hơn 1 char, hãy thay đổi ở đâu

    'The char "a" only shows up twice'.timesCharExist['a'];

    'The char "a" only shows up twice'.timesCharExist['a'];

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

    'The char "a" only shows up twice'.timesCharExist['a'];

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

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

    'The char "a" only shows up twice'.timesCharExist['a'];

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

    'The char "a" only shows up twice'.timesCharExist['a'];

    String.prototype.timesCharExist=function[c]{var t=0,l=0,c=[c+''][0];while[l=this.indexOf[c,l]+1]++t;return t};

    var x=Array[100001].join['1234567890'];

    console.time['proto'];x.timesCharExist['1'];console.timeEnd['proto'];

    console.time['regex'];x.match[/1/g].length;console.timeEnd['regex'];

    var timesCharExist=function[x,c]{var t=0,l=0,c=[c+''][0];while[l=x.indexOf[c,l]+1]++t;return t;};

    console.time['func'];timesCharExist[x,'1'];console.timeEnd['func'];

    'The char "a" only shows up twice'.timesCharExist['a'];

    String.prototype.timesCharExist=function[c]{var t=0,l=0,c=[c+''][0];while[l=this.indexOf[c,l]+1]++t;return t};

    var x=Array[100001].join['1234567890'];

    console.time['proto'];x.timesCharExist['1'];console.timeEnd['proto'];

    console.time['regex'];x.match[/1/g].length;console.timeEnd['regex'];

    var timesCharExist=function[x,c]{var t=0,l=0,c=[c+''][0];while[l=x.indexOf[c,l]+1]++t;return t;};

    console.time['func'];timesCharExist[x,'1'];console.timeEnd['func'];

    String.prototype.timesCharExist=function[c]{var t=0,l=0,c=[c+''][0];while[l=this.indexOf[c,l]+1]++t;return t};

    var x=Array[100001].join['1234567890'];

    console.time['proto'];x.timesCharExist['1'];console.timeEnd['proto'];

    console.time['regex'];x.match[/1/g].length;console.timeEnd['regex'];

    var timesCharExist=function[x,c]{var t=0,l=0,c=[c+''][0];while[l=x.indexOf[c,l]+1]++t;return t;};

    console.time['func'];timesCharExist[x,'1'];console.timeEnd['func'];

    'The char "a" only shows up twice'.timesCharExist['a'];

    String.prototype.timesCharExist=function[c]{var t=0,l=0,c=[c+''][0];while[l=this.indexOf[c,l]+1]++t;return t};

    var x=Array[100001].join['1234567890'];

    console.time['proto'];x.timesCharExist['1'];console.timeEnd['proto'];

    console.time['regex'];x.match[/1/g].length;console.timeEnd['regex'];

    var timesCharExist=function[x,c]{var t=0,l=0,c=[c+''][0];while[l=x.indexOf[c,l]+1]++t;return t;};

    console.time['func'];timesCharExist[x,'1'];console.timeEnd['func'];

    String.prototype.timesCharExist=function[c]{var t=0,l=0,c=[c+''][0];while[l=this.indexOf[c,l]+1]++t;return t};

    var x=Array[100001].join['1234567890'];

    console.time['proto'];x.timesCharExist['1'];console.timeEnd['proto'];

    console.time['regex'];x.match[/1/g].length;console.timeEnd['regex'];

    var timesCharExist=function[x,c]{var t=0,l=0,c=[c+''][0];while[l=x.indexOf[c,l]+1]++t;return t;};

    console.time['func'];timesCharExist[x,'1'];console.timeEnd['func'];

    'The char "a" only shows up twice'.timesCharExist['a'];

    String.prototype.timesCharExist=function[c]{var t=0,l=0,c=[c+''][0];while[l=this.indexOf[c,l]+1]++t;return t};

    var x=Array[100001].join['1234567890'];

    console.time['proto'];x.timesCharExist['1'];console.timeEnd['proto'];

    console.time['regex'];x.match[/1/g].length;console.timeEnd['regex'];

    var timesCharExist=function[x,c]{var t=0,l=0,c=[c+''][0];while[l=x.indexOf[c,l]+1]++t;return t;};

    console.time['func'];timesCharExist[x,'1'];console.timeEnd['func'];

    'The char "a" only shows up twice'.timesCharExist['a'];

    String.prototype.timesCharExist=function[c]{var t=0,l=0,c=[c+''][0];while[l=this.indexOf[c,l]+1]++t;return t};

    var x=Array[100001].join['1234567890'];

    console.time['proto'];x.timesCharExist['1'];console.timeEnd['proto'];

    console.time['regex'];x.match[/1/g].length;console.timeEnd['regex'];

    var timesCharExist=function[x,c]{var t=0,l=0,c=[c+''][0];while[l=x.indexOf[c,l]+1]++t;return t;};

    console.time['func'];timesCharExist[x,'1'];console.timeEnd['func'];

    String.prototype.timesCharExist=function[c]{var t=0,l=0,c=[c+''][0];while[l=this.indexOf[c,l]+1]++t;return t};

    var x=Array[100001].join['1234567890'];

    console.time['proto'];x.timesCharExist['1'];console.timeEnd['proto'];

    console.time['regex'];x.match[/1/g].length;console.timeEnd['regex'];

    var timesCharExist=function[x,c]{var t=0,l=0,c=[c+''][0];while[l=x.indexOf[c,l]+1]++t;return t;};

    console.time['func'];timesCharExist[x,'1'];console.timeEnd['func'];

    'The char "a" only shows up twice'.timesCharExist['a'];

    String.prototype.timesCharExist=function[c]{var t=0,l=0,c=[c+''][0];while[l=this.indexOf[c,l]+1]++t;return t};

    var x=Array[100001].join['1234567890'];

    console.time['proto'];x.timesCharExist['1'];console.timeEnd['proto'];

    console.time['regex'];x.match[/1/g].length;console.timeEnd['regex'];

    var timesCharExist=function[x,c]{var t=0,l=0,c=[c+''][0];while[l=x.indexOf[c,l]+1]++t;return t;};

    console.time['func'];timesCharExist[x,'1'];console.timeEnd['func'];

    String.prototype.timesCharExist=function[c]{var t=0,l=0,c=[c+''][0];while[l=this.indexOf[c,l]+1]++t;return t};

    var x=Array[100001].join['1234567890'];

    console.time['proto'];x.timesCharExist['1'];console.timeEnd['proto'];

    console.time['regex'];x.match[/1/g].length;console.timeEnd['regex'];

    var timesCharExist=function[x,c]{var t=0,l=0,c=[c+''][0];while[l=x.indexOf[c,l]+1]++t;return t;};

    console.time['func'];timesCharExist[x,'1'];console.timeEnd['func'];

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

    String.prototype.timesCharExist=function[c]{var t=0,l=0,c=[c+''][0];while[l=this.indexOf[c,l]+1]++t;return t};

    var x=Array[100001].join['1234567890'];

    console.time['proto'];x.timesCharExist['1'];console.timeEnd['proto'];

    console.time['regex'];x.match[/1/g].length;console.timeEnd['regex'];

    var timesCharExist=function[x,c]{var t=0,l=0,c=[c+''][0];while[l=x.indexOf[c,l]+1]++t;return t;};

    console.time['func'];timesCharExist[x,'1'];console.timeEnd['func'];

    String.prototype.timesCharExist=function[c]{var t=0,l=0,c=[c+''][0];while[l=this.indexOf[c,l]+1]++t;return t};

    var x=Array[100001].join['1234567890'];

    console.time['proto'];x.timesCharExist['1'];console.timeEnd['proto'];

    console.time['regex'];x.match[/1/g].length;console.timeEnd['regex'];

    var timesCharExist=function[x,c]{var t=0,l=0,c=[c+''][0];while[l=x.indexOf[c,l]+1]++t;return t;};

    console.time['func'];timesCharExist[x,'1'];console.timeEnd['func'];

    String.prototype.timesCharExist=function[c]{var t=0,l=0,c=[c+''][0];while[l=this.indexOf[c,l]+1]++t;return t};

    var x=Array[100001].join['1234567890'];

    console.time['proto'];x.timesCharExist['1'];console.timeEnd['proto'];

    console.time['regex'];x.match[/1/g].length;console.timeEnd['regex'];

    var timesCharExist=function[x,c]{var t=0,l=0,c=[c+''][0];while[l=x.indexOf[c,l]+1]++t;return t;};

    console.time['func'];timesCharExist[x,'1'];console.timeEnd['func'];

    String.prototype.timesCharExist=function[c]{var t=0,l=0,c=[c+''][0];while[l=this.indexOf[c,l]+1]++t;return t};

    var x=Array[100001].join['1234567890'];

    console.time['proto'];x.timesCharExist['1'];console.timeEnd['proto'];

    console.time['regex'];x.match[/1/g].length;console.timeEnd['regex'];

    var timesCharExist=function[x,c]{var t=0,l=0,c=[c+''][0];while[l=x.indexOf[c,l]+1]++t;return t;};

    console.time['func'];timesCharExist[x,'1'];console.timeEnd['func'];

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 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

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 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

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

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

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 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

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

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

    String.prototype.timesCharExist = function [ chr ] {
        var total = 0, last_location = 0, single_char = [ chr + '' ][0];
        while[ last_location = this.indexOf[ single_char, last_location ] + 1 ]
        {
            total = total + 1;
        }
        return total;
    };

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

    'The char "a" only shows up twice'.timesCharExist['a'];

    'The char "a" only shows up twice'.timesCharExist['a'];

    String.prototype.timesCharExist = function [ chr ] {
        var total = 0, last_location = 0, single_char = [ chr + '' ][0];
        while[ last_location = this.indexOf[ single_char, last_location ] + 1 ]
        {
            total = total + 1;
        }
        return total;
    };

Chúng ta có thể kiểm tra xem điều này có cho chúng ta kết quả tương tự như cùng một chức năng được tạo bằng vòng lặp

    'The char "a" only shows up twice'.timesCharExist['a'];

Phương thức thay thế #2: foreach []

Một giải pháp thay thế khả thi khác là sử dụng phương thức

    String.prototype.timesCharExist=function[c]{var t=0,l=0,c=[c+''][0];while[l=this.indexOf[c,l]+1]++t;return t};

    var x=Array[100001].join['1234567890'];

    console.time['proto'];x.timesCharExist['1'];console.timeEnd['proto'];

    console.time['regex'];x.match[/1/g].length;console.timeEnd['regex'];

    var timesCharExist=function[x,c]{var t=0,l=0,c=[c+''][0];while[l=x.indexOf[c,l]+1]++t;return t;};

    console.time['func'];timesCharExist[x,'1'];console.timeEnd['func'];

    String.prototype.timesCharExist = function [ chr ] {
        var total = 0, last_location = 0, single_char = [ chr + '' ][0];
        while[ last_location = this.indexOf[ single_char, last_location ] + 1 ]
        {
            total = total + 1;
        }
        return total;
    };

Điều này sẽ mang lại cho chúng ta kết quả tương tự như các chức năng trước đó, nhưng, một lần nữa, hãy cẩn thận khi sử dụng phương pháp

    String.prototype.timesCharExist=function[c]{var t=0,l=0,c=[c+''][0];while[l=this.indexOf[c,l]+1]++t;return t};

    var x=Array[100001].join['1234567890'];

    console.time['proto'];x.timesCharExist['1'];console.timeEnd['proto'];

    console.time['regex'];x.match[/1/g].length;console.timeEnd['regex'];

    var timesCharExist=function[x,c]{var t=0,l=0,c=[c+''][0];while[l=x.indexOf[c,l]+1]++t;return t;};

    console.time['func'];timesCharExist[x,'1'];console.timeEnd['func'];

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

Kiểm tra số lần xuất hiện của tất cả các yếu tố

Cho đến nay, chúng tôi đã thấy cách đếm sự xuất hiện của một yếu tố cụ thể. Bây giờ, chúng ta hãy xem cách đếm sự xuất hiện của tất cả các phần tử và trả về cả phần tử và số lần xuất hiện dưới dạng đối tượng.

Để bắt đầu, chúng tôi sẽ tạo một đối tượng trống để lưu trữ từng phần tử mảng làm khóa và số lần xuất hiện dưới dạng giá trị. Sau đó, chúng tôi sẽ lặp qua mảng bằng cách sử dụng vòng lặp

    'The char "a" only shows up twice'.timesCharExist['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

Kiểm tra hướng dẫn thực hành của chúng tôi, thực tế để học Git, với các thực hành tốt nhất, các tiêu chuẩn được công nghiệp chấp nhận và bao gồm bảng gian lận. Ngừng các lệnh git googling và thực sự tìm hiểu nó!

    String.prototype.timesCharExist = function [ chr ] {
        var total = 0, last_location = 0, single_char = [ chr + '' ][0];
        while[ last_location = this.indexOf[ single_char, last_location ] + 1 ]
        {
            total = total + 1;
        }
        return total;
    };

Mã trước sẽ xuất ra đối tượng chứa số lần xuất hiện của từng phần tử trong

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

    String.prototype.timesCharExist = function [ chr ] {
        var total = 0, last_location = 0, single_char = [ chr + '' ][0];
        while[ last_location = this.indexOf[ single_char, last_location ] + 1 ]
        {
            total = total + 1;
        }
        return total;
    };

Giả sử chúng ta vẫn muốn tránh sự nhạy cảm của trường hợp, chúng ta có thể làm điều gì đó như sau:

    String.prototype.timesCharExist = function [ chr ] {
        var total = 0, last_location = 0, single_char = [ chr + '' ][0];
        while[ last_location = this.indexOf[ single_char, last_location ] + 1 ]
        {
            total = total + 1;
        }
        return total;
    };

Điều này sẽ xuất ra đối tượng bên dưới:

    String.prototype.timesCharExist = function [ chr ] {
        var total = 0, last_location = 0, single_char = [ chr + '' ][0];
        while[ last_location = this.indexOf[ single_char, last_location ] + 1 ]
        {
            total = total + 1;
        }
        return total;
    };

Cách đếm các yếu tố xảy ra bằng cách sử dụng giảm []

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

    String.prototype.timesCharExist = function [ chr ] {
        var total = 0, last_location = 0, single_char = [ chr + '' ][0];
        while[ last_location = this.indexOf[ single_char, last_location ] + 1 ]
        {
            total = total + 1;
        }
        return total;
    };

Đ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ị:

    'The char "a" only shows up twice'.timesCharExist['a'];

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

Để 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 myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];

    'The char "a" only shows up twice'.timesCharExist['a'];

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 myArray = [false, 24, "English", false, "english", 22, 19, false, "English", 19];

    'The char "a" only shows up twice'.timesCharExist['a'];

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

    'The char "a" only shows up twice'.timesCharExist['a'];

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

    'The char "a" only shows up twice'.timesCharExist['a'];

    String.prototype.timesCharExist=function[c]{var t=0,l=0,c=[c+''][0];while[l=this.indexOf[c,l]+1]++t;return t};

    var x=Array[100001].join['1234567890'];

    console.time['proto'];x.timesCharExist['1'];console.timeEnd['proto'];

    console.time['regex'];x.match[/1/g].length;console.timeEnd['regex'];

    var timesCharExist=function[x,c]{var t=0,l=0,c=[c+''][0];while[l=x.indexOf[c,l]+1]++t;return t;};

    console.time['func'];timesCharExist[x,'1'];console.timeEnd['func'];

    'The char "a" only shows up twice'.timesCharExist['a'];

    String.prototype.timesCharExist=function[c]{var t=0,l=0,c=[c+''][0];while[l=this.indexOf[c,l]+1]++t;return t};

    var x=Array[100001].join['1234567890'];

    console.time['proto'];x.timesCharExist['1'];console.timeEnd['proto'];

    console.time['regex'];x.match[/1/g].length;console.timeEnd['regex'];

    var timesCharExist=function[x,c]{var t=0,l=0,c=[c+''][0];while[l=x.indexOf[c,l]+1]++t;return t;};

    console.time['func'];timesCharExist[x,'1'];console.timeEnd['func'];

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

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

    'The char "a" only shows up twice'.timesCharExist['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

Làm thế nào để bạn đếm một cái gì đó trong JavaScript?

Có một phương pháp đếm trong JavaScript?

Làm cách nào để đếm số lần một từ xuất hiện trong JavaScript?