programming javascript

Truyền đối số cho hàm khác javascript

Trong JavaScript, các chức năng được coi là công dân hạng nhất. Chúng ta có thể coi các hàm là các giá trị và gán chúng cho một biến khác, chuyển chúng làm đối số cho một hàm khác hoặc thậm chí trả về chúng từ một hàm khác

Khả năng các hàm này hoạt động như các hàm hạng nhất là thứ cung cấp năng lượng cho các hàm bậc cao hơn trong JavaScript

Về cơ bản, một hàm lấy một hàm khác làm đối số hoặc trả về một hàm được gọi là hàm bậc cao hơn

Hãy đi sâu một chút để xem cả hai loại thực hiện, đó là

Truyền một hàm làm đối số cho một hàm khác
Trả về một hàm từ một hàm khác

Cách truyền một hàm làm đối số cho một hàm khác

Trong phần này, chúng ta sẽ xem cách chúng ta có thể gửi một hàm dưới dạng đối số và cuối cùng là cách nó giúp chúng ta viết mã sạch hơn

Xem xét đoạn mã sau mà chúng ta muốn tạo một hàm chấp nhận một mảng làm đối số. Nó lọc ra tất cả các số lẻ từ nó và trả về tất cả các số đã lọc

Chức năng sẽ trông giống như thế này

const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];

function filterOdd[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 !== 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterOdd[arr]];

// Output:
// [ 1, 3, 5, 7, 9, 11 ]

Hàm trên trả về mảng đã lọc

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

8 trong đó chúng tôi có tất cả các số lẻ, như mong đợi

Bây giờ, giả sử chúng ta cũng muốn tạo một hàm lọc ra và trả về tất cả các số chẵn. Chúng ta rất có thể tiếp tục và tạo chức năng sau để đạt được điều này

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

Một lần nữa, như mong đợi, chúng ta sẽ nhận được đầu ra mong muốn của một mảng với tất cả các số chẵn trong đó –

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

Nhưng lưu ý rằng chúng tôi đang viết rất nhiều mã trùng lặp theo cách tiếp cận này. Cả hai hàm trên đều thực hiện rất nhiều việc chung, chẳng hạn như chấp nhận mảng ban đầu, tạo một mảng mới để lưu trữ mảng đã lọc, lặp qua toàn bộ mảng chính và cuối cùng trả về mảng đã lọc

Sự khác biệt duy nhất giữa cả hai chức năng là logic mà chúng sử dụng để lọc ra mảng ban đầu

Đối với hàm

function filterFunction[arr, callback] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    callback[arr[i]] ? filteredArr.push[arr[i]] : null;
  }
  return filteredArr;
}

0, chúng ta sử dụng logic của

function filterFunction[arr, callback] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    callback[arr[i]] ? filteredArr.push[arr[i]] : null;
  }
  return filteredArr;
}

1 trong khi ở hàm

function filterFunction[arr, callback] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    callback[arr[i]] ? filteredArr.push[arr[i]] : null;
  }
  return filteredArr;
}

2, chúng ta sử dụng logic

function filterFunction[arr, callback] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    callback[arr[i]] ? filteredArr.push[arr[i]] : null;
  }
  return filteredArr;
}

3 để lọc ra mảng ban đầu

Đây là nơi chúng ta có thể hưởng lợi từ việc sử dụng các hàm bậc cao hơn. Mục đích chính là tạo một hàm để thực hiện tất cả những thứ chung mà chúng ta đã làm trong hai hàm trên và chuyển riêng phần logic làm đối số cho hàm này. Hãy xem làm thế nào chúng ta có thể thực hiện điều này

Hãy tạo hàm thực hiện tất cả những nội dung phổ biến mà chúng ta đã thực hiện trong hàm

function filterFunction[arr, callback] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    callback[arr[i]] ? filteredArr.push[arr[i]] : null;
  }
  return filteredArr;
}

0 và

function filterFunction[arr, callback] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    callback[arr[i]] ? filteredArr.push[arr[i]] : null;
  }
  return filteredArr;
}

2. Điều này sẽ đi một cái gì đó như thế này

function filterFunction[arr, callback] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    callback[arr[i]] ? filteredArr.push[arr[i]] : null;
  }
  return filteredArr;
}

Bỏ qua tham số

function filterFunction[arr, callback] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    callback[arr[i]] ? filteredArr.push[arr[i]] : null;
  }
  return filteredArr;
}

6 ngay bây giờ. Lưu ý rằng trong phiên bản

function filterFunction[arr, callback] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    callback[arr[i]] ? filteredArr.push[arr[i]] : null;
  }
  return filteredArr;
}

7 mới, chúng ta giữ tất cả các bước chung, đó là chấp nhận mảng ban đầu, tạo một mảng mới để lưu trữ mảng đã lọc, lặp qua toàn bộ mảng chính và cuối cùng trả về mảng đã lọc mà chúng ta đã thực hiện trong

function filterFunction[arr, callback] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    callback[arr[i]] ? filteredArr.push[arr[i]] : null;
  }
  return filteredArr;
}

Bây giờ, tham số

function filterFunction[arr, callback] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    callback[arr[i]] ? filteredArr.push[arr[i]] : null;
  }
  return filteredArr;
}

6 về cơ bản chấp nhận logic sẽ không là gì ngoài một hàm khác chứa logic lọc. Để lọc các số lẻ và số chẵn tương ứng, đây là các hàm logic chúng ta cần viết

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

Đó là nó. Bây giờ chúng ta chỉ cần truyền mảng chính, cùng với hàm logic cho

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

61 của chúng ta như thế này

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

Bằng cách này, chúng tôi đang chuyển các hàm logic như

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

62 hoặc

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

63 làm đối số cho một hàm khác

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

Về cơ bản, chúng tôi đang trừu tượng hóa logic lọc chính từ chức năng chính. Giờ đây, chúng tôi có thể chuyển bất kỳ logic lọc nào khác mà chúng tôi muốn tới

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

61 mà không cần thay đổi nó

Ví dụ chúng ta muốn lọc ra một số lớn hơn 5 thì chỉ cần viết logic lọc như sau

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

và chuyển nó làm đối số cho

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

Chúng ta cũng có thể truyền hàm logic dưới dạng hàm mũi tên và nhận được kết quả tương tự – nghĩa là, truyền

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

67 thay cho

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

68 sẽ cho chúng ta kết quả tương tự

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

Cách tạo Polyfill

Chúng ta biết rằng JavaScript cung cấp cho chúng ta một số hàm bậc cao có sẵn như

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

69,

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

80,

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

81, v.v. Chúng ta có thể tạo lại việc thực hiện các chức năng này của riêng mình không?

Chúng tôi đã tạo chức năng lọc của mình trong phần trên. Hãy tạo nguyên mẫu mảng của hàm

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

61 để chúng ta có thể sử dụng nó với bất kỳ mảng nào. Điều này sẽ trông giống như thế này

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

Trong đoạn mã trên,

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

83 đề cập đến mảng mà nguyên mẫu được gọi. Vì vậy, nếu chúng ta viết một cái gì đó như

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

thì

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

83 sẽ tham chiếu đến mảng

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

Bây giờ chúng ta có thể sử dụng

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

61 giống như chúng ta sử dụng hàm

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

80 có sẵn trong JS. Chúng ta có thể viết một cái gì đó như thế này

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

tương tự như gọi hàm

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

80 sẵn có

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

Cả hai lệnh gọi hàm trên [tức là

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

89 và

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

30] sẽ cho chúng ta cùng một đầu ra, chẳng hạn như

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

Tương tự, chúng ta cũng có thể chuyển một hàm mũi tên trong triển khai nguyên mẫu của mình vì chúng ta có thể chuyển vào hàm

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

80 có sẵn

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

Theo một cách nào đó, chúng tôi đã viết một polyfill cho hàm

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

80 sẵn có

Chuỗi chức năng

Chúng tôi cũng có thể triển khai chức năng xâu chuỗi với triển khai nguyên mẫu của mình giống như chúng tôi có thể thực hiện với chức năng

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

80 sẵn có. Trước tiên hãy lọc ra tất cả các số lớn hơn 5. Sau đó từ kết quả ta sẽ lọc ra toàn các số chẵn. Nó sẽ trông giống như thế này

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

Đây là cách chúng ta có thể sử dụng các hàm bậc cao hơn trong JS để viết mã theo chế độ mô-đun, sạch hơn và dễ bảo trì hơn

Tiếp theo, hãy xem cách chúng ta có thể trả về một hàm từ một hàm khác

Cách trả về một hàm từ một hàm khác trong JavaScript

Chúng ta có thể trả về một hàm từ một hàm khác vì chúng ta coi các hàm trong JavaScript là các giá trị. Hãy xem điều này thông qua một ví dụ

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

Trong đoạn mã trên, khi chúng ta gọi hàm

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

35 với một đối số, nó sẽ bật đối số đó và cuối cùng trả về một hàm ẩn danh. Vì vậy, nếu chúng ta gọi hàm

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

36 và lưu trữ kết quả của nó trong một biến và bảng điều khiển ghi nhật ký, chúng ta sẽ nhận được đầu ra sau

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

Bạn có thể thấy rằng

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

37 chứa một hàm ẩn danh mà hàm

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

36 đã trả về

Có hai cách để gọi hàm bên trong này mà chúng ta sẽ khám phá ngay bây giờ

Gọi hàm trả về bằng cách sử dụng một biến

Trong phương thức này, chúng tôi đã lưu trữ hàm trả về trong một biến như được hiển thị ở trên và sau đó gọi biến đó để lần lượt gọi hàm bên trong

Hãy xem nó trong mã

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

Vậy chúng ta sẽ làm gì ở đây?

Chúng tôi đã gọi hàm

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

36 và chuyển

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

50 làm đối số

Chúng tôi đã lưu trữ hàm ẩn danh được trả về trong biến

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

37 và

Chúng tôi đã gọi hàm trả về bên trong bằng cách gọi

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

52 với các đối số được yêu cầu

Gọi hàm trả về bằng cách sử dụng dấu ngoặc kép

Đây là một cách rất phức tạp để gọi hàm trả về bên trong. Chúng tôi sử dụng dấu ngoặc kép

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

53 trong phương pháp này

Hãy xem nó trong mã

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

Bạn có thể nghĩ về điều này theo cách tương tự như ví dụ về chuỗi của chúng tôi ở trên. Chỉ là thay vì xâu chuỗi các hàm, chúng ta xâu chuỗi các đối số

Các đối số trong cặp ngoặc đơn đầu tiên thuộc về hàm bên ngoài, trong khi các đối số trong cặp ngoặc đơn thứ hai thuộc về hàm trả về bên trong

Phương thức

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

36 trả về một hàm như đã giải thích trước đó và hàm được trả về đó được gọi ngay lập tức bằng cách sử dụng dấu ngoặc đơn thứ hai

Như tôi đã đề cập ở trên, đây là một cách rất phức tạp để gọi hàm. Nhưng một khi bạn hiểu rõ về nó, nó sẽ trở thành. cũng khá tự nhiên

Một nơi mà chúng ta có thể thấy loại ký hiệu dấu ngoặc kép này là trong phương thức

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

55 trong thư viện quản lý trạng thái

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

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

function filterEven[arr] {
  const filteredArr = [];
  for [let i = 0; i < arr.length; i++] {
    if [arr[i] % 2 == 0] {
      filteredArr.push[arr[i]];
    }
  }
  return filteredArr;
}
console.log[filterEven[arr]];

// Output:
// [ 2, 4, 6, 8, 10 ]

55 tại đây

Tóm lược

Trong bài viết này, chúng ta đã học

Tại sao các chức năng được gọi là công dân hạng nhất trong JS
chức năng bậc cao hơn là gì
Cách chuyển một hàm làm đối số cho một hàm khác
Cách tạo nguyên mẫu mảng, xâu chuỗi hàm, viết polyfill của riêng chúng tôi cho phương thức filter[] sẵn có
Cách trả về một hàm từ một hàm khác và các cách khác nhau để gọi hàm được trả về

Gói [lại

Cảm ơn vì đã đọc. Tôi thực sự hy vọng bạn thấy bài viết về hàm bậc cao này hữu ích. Hãy theo dõi để biết thêm nội dung tuyệt vời. hòa bình ra. 🖖

đường liên kết mạng xã hội

LinkedIn
Trang mạng
trang blog

QUẢNG CÁO

soham de roy

SDE 2 @ Mastercard • IIT Kanpur • Tech Blogger

Nếu bạn đọc đến đây, hãy tweet cho tác giả để cho họ thấy bạn quan tâm. Tweet một lời cảm ơ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 để chuyển một giá trị từ hàm này sang hàm khác trong JavaScript?

Khi có nhiều chức năng [hầu hết thời gian], cần có một cách để truyền dữ liệu giữa các chức năng. Điều này được thực hiện bằng cách chuyển các giá trị trong ngoặc đơn. myFunction[myData] . Ngay cả khi không có dữ liệu nào được truyền vào, chúng ta vẫn phải khai báo và thực thi các hàm bằng cách sử dụng dấu ngoặc đơn. myFunction[].

Làm cách nào để chuyển nhiều đối số trong hàm JavaScript?

Khi bạn gọi một hàm trong JavaScript, bạn có thể chuyển vào bất kỳ số lượng đối số nào, bất kể khai báo hàm chỉ định điều gì . Không có giới hạn tham số chức năng. Trong hàm trên, nếu chúng ta truyền vào bao nhiêu đối số thì kết quả luôn giống nhau vì nó chỉ nhận 2 tham số đầu tiên.

Tôi có thể sử dụng hàm làm đối số trong JavaScript không?

Việc truyền một hàm làm đối số cho hàm khá giống với việc truyền biến làm đối số cho hàm . vì vậy các biến có thể được trả về từ một hàm.

Đối số chuyển qua trong JavaScript là gì?

Các đối số được truyền theo giá trị . Các đối số JavaScript được truyền theo giá trị. Hàm chỉ biết các giá trị, không biết vị trí của đối số. Nếu một hàm thay đổi giá trị của đối số, thì nó không thay đổi giá trị ban đầu của tham số.