programming javascript

Javascript đếm số lần xuất hiện trong mảng đối tượng

Cú pháp gán phá hủy là một biểu thức JavaScript cho phép giải nén các giá trị từ mảng hoặc thuộc tính từ các đối tượng thành các biến riêng biệt. Thay vì gắn bó với biến đối tượng hiện có, chúng ta có thể đổi tên chúng theo sở thích của riêng mình

Trong bài viết này, chúng ta sẽ tìm hiểu cách đếm theo các thuộc tính của một mảng các đối tượng chỉ sử dụng một dòng mã trong JavaScript. Đây là đoạn mã JavaScript một dòng sử dụng một trong những tính năng phổ biến nhất của ES6 => Arrow Function

Hãy xác định chức năng ngắn này

const countBy = [arr, prop] => arr.reduce[[prev, curr] => [prev[curr[prop]] = ++prev[curr[prop]] || 1, prev], {}];

Giả sử sau đây là mảng của chúng ta -

var details = [
   {
      studentName: "John",
      studentAge: 23
   },
   {
      studentName: "David",
      studentAge: 24
   },
   {
      studentName: "John",
      studentAge: 21
   },
   {
      studentName: "John",
      studentAge: 25
   },
   {
      studentName: "Bob",
      studentAge: 22
   },
   {
      studentName: "David",
      studentAge: 20
   }
]

Chúng ta cần đếm số lần xuất hiện của các tên lặp đi lặp lại i. e. đầu ra phải là

John: 3
David: 2
Bob: 1

Đối với điều này, bạn có thể sử dụng khái niệm giảm[]

Thí dụ

Sau đây là mã -

var details = [
   {
      studentName: "John",
      studentAge: 23
   },
   {
      studentName: "David",
      studentAge: 24
   },
   {
      studentName: "John",
      studentAge: 21
   },
   {
      studentName: "John",
      studentAge: 25
   },
   {
      studentName: "Bob",
      studentAge: 22
   },
   {
      studentName: "David",
      studentAge: 20
   }
]
var output = Object.values[details.reduce[[obj, { studentName }] => {
   if [obj[studentName] === undefined]
      obj[studentName] = { studentName: studentName, occurrences: 1 };
   else
      obj[studentName].occurrences++;
   return obj;
}, {}]];
console.log[output];

Để chạy chương trình trên, bạn cần sử dụng lệnh sau -

node fileName.js.

Ở đây, tên tệp của tôi là demo282. js. Điều này sẽ tạo ra đầu ra sau trên bảng điều khiển -

PS C:\Users\Amit\javascript-code> node demo282.js
[
   { studentName: 'John', occurrences: 3 },
   { studentName: 'David', occurrences: 2 },
   { studentName: 'Bob', occurrences: 1 }
]

Biết cách lặp nhanh qua một mảng và đếm các đối tượng rất đơn giản. Phương thức

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

let counter = 0;
for [let i = 0; i < storage.length; i++] {
  if [storage[i].status === '0'] counter++;
}

console.log[counter]; // 6

0 sẽ cho bạn biết tổng số giá trị trong mảng, nhưng nếu bạn chỉ muốn đếm những giá trị đó dựa trên các điều kiện nhất định thì sao?

Ví dụ, hãy tưởng tượng bạn có một mảng như thế này

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

Và bạn chỉ muốn đếm số đối tượng có ____6_______1 được đặt thành ____6_______2

Giống như mọi thứ trong lập trình, có một số cách để làm điều này. Chúng ta sẽ đi qua một số phương pháp phổ biến dưới đây

Sử dụng vòng lặp

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

let counter = 0;
for [let i = 0; i < storage.length; i++] {
  if [storage[i].status === '0'] counter++;
}

console.log[counter]; // 6

Có lẽ cách dễ nhất là khai báo một biến

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

let counter = 0;
for [let i = 0; i < storage.length; i++] {
  if [storage[i].status === '0'] counter++;
}

console.log[counter]; // 6

4, lặp qua mảng và lặp lại

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

let counter = 0;
for [let i = 0; i < storage.length; i++] {
  if [storage[i].status === '0'] counter++;
}

console.log[counter]; // 6

4 chỉ khi

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

let counter = 0;
for [let i = 0; i < storage.length; i++] {
  if [storage[i].status === '0'] counter++;
}

console.log[counter]; // 6

1 bằng với

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

let counter = 0;
for [let i = 0; i < storage.length; i++] {
  if [storage[i].status === '0'] counter++;
}

console.log[counter]; // 6

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

let counter = 0;
for [let i = 0; i < storage.length; i++] {
  if [storage[i].status === '0'] counter++;
}

console.log[counter]; // 6

Bạn có thể đơn giản hóa điều này một chút bằng cách sử dụng vòng lặp

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

let counter = 0;
for [let i = 0; i < storage.length; i++] {
  if [storage[i].status === '0'] counter++;
}

console.log[counter]; // 6

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

let counter = 0;
for [const obj of storage] {
  if [obj.status === '0'] counter++;
}

console.log[counter]; // 6

Ngoài ra, bạn có thể tạo một hàm để làm điều tương tự nếu bạn có các mảng đối tượng khác để đếm theo điều kiện

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

function statusCounter[inputs] {
  let counter = 0;
  for [const input of inputs] {
    if [input.status === '0'] counter += 1;
  }
  return counter;
}

statusCounter[storage]; // 6

Sử dụng các phương thức mảng

JavaScript bao gồm một loạt các phương thức hữu ích khi làm việc với mảng. Mỗi cái có thể được xâu chuỗi thành một mảng và truyền các tham số khác nhau để làm việc trong khi lặp qua các phần tử trong mảng

Hai cái chúng ta sẽ xem xét là

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

let counter = 0;
for [let i = 0; i < storage.length; i++] {
  if [storage[i].status === '0'] counter++;
}

console.log[counter]; // 6

9 và

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

let counter = 0;
for [const obj of storage] {
  if [obj.status === '0'] counter++;
}

console.log[counter]; // 6

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

let counter = 0;
for [let i = 0; i < storage.length; i++] {
  if [storage[i].status === '0'] counter++;
}

console.log[counter]; // 6

Phương thức bộ lọc thực hiện điều đó – nó lặp qua từng phần tử trong mảng và lọc ra tất cả các phần tử không đáp ứng [các] điều kiện mà bạn cung cấp. Sau đó, nó trả về một mảng mới với tất cả các phần tử trả về true dựa trên [các] điều kiện của bạn

Ví dụ

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

const count = storage.filter[function[item]{
  if [item.status === 0] {
    return true;
  } else {
    return false;
  }
}];

/*
[
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' }
] 
*/

Bây giờ bạn đã lọc ra đối tượng có

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

let counter = 0;
for [const obj of storage] {
  if [obj.status === '0'] counter++;
}

console.log[counter]; // 6

2, chỉ cần gọi phương thức

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

let counter = 0;
for [let i = 0; i < storage.length; i++] {
  if [storage[i].status === '0'] counter++;
}

console.log[counter]; // 6

0 trên mảng mới để lấy tổng số đối tượng có

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

let counter = 0;
for [const obj of storage] {
  if [obj.status === '0'] counter++;
}

console.log[counter]; // 6

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

const count = storage.filter[function[item]{
  if [item.status === 0] {
    return true;
  } else {
    return false;
  }
}].length; // 6

Nhưng điều này có thể được rút ngắn rất nhiều với cú pháp ES6

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

const count = storage.filter[item => item.status === '0'].length; // 6

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

let counter = 0;
for [const obj of storage] {
  if [obj.status === '0'] counter++;
}

console.log[counter]; // 6

Hãy coi phương thức

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

let counter = 0;
for [const obj of storage] {
  if [obj.status === '0'] counter++;
}

console.log[counter]; // 6

0 giống như một con dao của quân đội Thụy Sĩ – nó cực kỳ linh hoạt và cho phép bạn lấy một mảng làm đầu vào và chuyển đổi nó thành bất kỳ thứ gì. Thậm chí tốt hơn, như

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

let counter = 0;
for [let i = 0; i < storage.length; i++] {
  if [storage[i].status === '0'] counter++;
}

console.log[counter]; // 6

9, phương thức này trả về một mảng mới, giữ nguyên mảng ban đầu

Bạn có thể đọc thêm về

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

let counter = 0;
for [const obj of storage] {
  if [obj.status === '0'] counter++;
}

console.log[counter]; // 6

0 trong bài viết này

Đối với mục đích của chúng tôi, chúng tôi muốn lấy một mảng, kiểm tra nội dung của nó và tạo ra một số. Đây là một cách đơn giản để làm điều đó

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

const count = storage.reduce[[counter, obj] => {
  if [obj.status === '0'] counter += 1
  return counter;
}, 0]; // 6

Bạn có thể đơn giản hóa hơn nữa bằng cách sử dụng cú pháp ES6 và toán tử bậc ba

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

const count = storage.reduce[[counter, obj] => obj.status === '0' ? counter += 1 : counter, 0]; // 6

Và thậm chí nhiều hơn một chút bằng cách sử dụng phá hủy đối tượng

const storage = [
  { data: '1', status: '0' },
  { data: '2', status: '0' },
  { data: '3', status: '0' },
  { data: '4', status: '0' },
  { data: '5', status: '0' },
  { data: '6', status: '0' },
  { data: '7', status: '1' },
];

const count = storage.reduce[[counter, { status }] => status === '0' ? counter += 1 : counter, 0]; // 6

Vì vậy, đó là một số cách để duyệt qua các phần tử của một mảng và đếm chúng theo điều kiện. Bây giờ hãy ra khỏi đó và đếm với sự tự tin

QUẢNG CÁO

Nếu bài viết này hữu ích, hãy tweet nó

Học cách viết mã miễn phí. Chương trình giảng dạy mã nguồn mở của freeCodeCamp đã giúp hơn 40.000 người có được việc làm với tư cách là nhà phát triển. Bắt đầu

Làm cách nào để đếm số lần xuất hiện của một phần tử trong một mảng trong JavaScript?

Để đếm số lần xuất hiện của phần tử trong một mảng, hãy sử dụng phương thức “filter[]” với thuộc tính “length”, phương thức “reduce[]”, vòng lặp “for” hoặc . .

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

Trong JavaScript, chúng ta có thể đếm số lần xuất hiện của chuỗi trong một chuỗi bằng cách đếm số lần chuỗi xuất hiện trong chuỗi . JavaScript cung cấp một hàm match[], được sử dụng để tạo ra tất cả các lần xuất hiện của một chuỗi trong một mảng.

Làm cách nào để kiểm tra sự xuất hiện của một phần tử trong một mảng trong JavaScript?

Trong đoạn mã trên, chúng tôi đã sử dụng thư viện JavaScript lodash chấp nhận một mảng và kiểm tra sự xuất hiện của từng phần tử trong mảng. Các. Phương thức CountBy[] của Lodash lấy các giá trị của mảng JS và trả về một đối tượng mới . Đối tượng bao gồm từng phần tử và số lượng của nó trong các cặp khóa-giá trị.

Làm cách nào để đếm các giá trị trùng lặp trong một mảng đối tượng trong JavaScript?

Đếm số trùng lặp trong một mảng bằng JavaScript .

Để đếm các bản sao trong một mảng

Sử dụng phương thức reduce[] để đếm các bản sao trong một mảng, truyền cho nó một đối tượng trống làm giá trị ban đầu cho bộ tích lũy. .

Bất cứ thứ gì chúng ta trả về từ hàm gọi lại đều được chuyển thành bộ tích lũy trong lần lặp tiếp theo

Thí dụ

Sử dụng các phương thức mảng

Làm cách nào để đếm số lần xuất hiện của một phần tử trong một mảng trong JavaScript?

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

Làm cách nào để kiểm tra sự xuất hiện của một phần tử trong một mảng trong JavaScript?

Làm cách nào để đếm các giá trị trùng lặp trong một mảng đối tượng trong JavaScript?

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề