Phạm vi trong JavaScript là gì?

Bạn đã bao giờ có nhiệm vụ tạo danh sách các số từ đầu đến giá trị cuối chưa? . Có một số cách để giải quyết tình trạng khó khăn này. cho vòng lặp, đệ quy, phương thức

function range(start, end) {
if(start === end) return [start];
// recursive case
}

1, tham số bước, tạo chuỗi ký tự, v.v.

Vì vậy, chúng ta cần tạo một hàm phạm vi lấy giá trị bắt đầu và kết thúc, đồng thời trả về danh sách các số trong phạm vi đó. Cách rõ ràng nhất là sử dụng vòng lặp for

cho vòng lặp

Chúng ta lấy giá trị đầu và cuối làm tham số hàm, tạo một mảng trống, sau đó sử dụng vòng lặp for từ giá trị đầu đến cuối để thêm các phần tử vào cuối mảng

function range(start, end) {
const ans = [ ];
for (let i = start; i <= end; i++) {
ans.push(i);
}
return ans;
}
const myArray = range(5, 10);
console.log(myArray);

//Output: [ 5, 6, 7, 8, 9, 10 ]

đệ quy

Thông thường, khi giá trị bắt đầu bằng giá trị kết thúc, câu trả lời là [bắt đầu]

function range(start, end) {
if(start === end) return [start];
// recursive case
}

Giả sử

function range(start, end) {
if(start === end) return [start];
// recursive case
}

2 hoạt động trong một tình huống bắt đầu và kết thúc khác nhau. Làm thế nào để chúng tôi giải quyết vấn đề? . e. bằng cách gọi hàm

function range(start, end) {
if(start === end) return [start];
// recursive case
}

4, chúng ta điền vào mảng các phần tử từ đầu đến cuối

function range(start, end) {
if(start === end) return [start];
return [start, ...range(start + 1, end)];
}
const dates = range(2010, 2020);
console.log(dates);

//Output:
// [
// 2010, 2011, 2012,
// 2013, 2014, 2015,
// 2016, 2017, 2018,
// 2019, 2020
// ]

Đây là một giải pháp thanh lịch hơn. Nhưng chúng ta có thể đi xa hơn nữa nếu chúng ta sử dụng hàm tạo mới

function range(start, end) {
if(start === end) return [start];
// recursive case
}

5, tạo ra một mảng có n phần tử. Đồng thời, chúng tôi sẽ làm cho mã của chúng tôi rõ ràng và đầy đủ hơn

Bản đồ phương thức()

Vì vậy, chúng tôi đã xây dựng một mảng với độ dài nhất định. Bây giờ nếu chúng ta có một danh sách gồm n phần tử, chúng ta có thể tạo một phạm vi từ nó bằng cách ánh xạ mọi phần tử vào chỉ mục của nó áp dụng

function range(start, end) {
if(start === end) return [start];
// recursive case
}

6. Nhưng mảng vẫn chưa có giá trị phần tử để lặp lại nên hàm map() không hoạt động. Hãy sử dụng phương thức

function range(start, end) {
if(start === end) return [start];
// recursive case
}

7 để điền vào các phần tử mảng các giá trị không xác định. Bây giờ chúng ta có thể sử dụng

function range(start, end) {
if(start === end) return [start];
// recursive case
}

6

Phương thức

function range(start, end) {
if(start === end) return [start];
// recursive case
}

6 tạo một mảng mới chứa đầy các giá trị là kết quả của việc gọi hàm đã cho một lần cho mỗi phần tử mảng. Nó chấp nhận tối đa 3 tham số. phần tử, chỉ số, mảng

Bây giờ nếu chúng ta chỉ định 2 tham số giữ chỗ (“______7_______0” để bỏ qua giá trị ban đầu của phần tử và chỉ mục), chúng ta có thể gán giá trị mới cho phần tử. Sử dụng chức năng mũi tên.

function range(start, end) {
if(start === end) return [start];
return [start, ...range(start + 1, end)];
}
const dates = range(2010, 2020);
console.log(dates);

//Output:
// [
// 2010, 2011, 2012,
// 2013, 2014, 2015,
// 2016, 2017, 2018,
// 2019, 2020
// ]

1

Độ dài của mảng được tính theo công thức

function range(start, end) {
if(start === end) return [start];
return [start, ...range(start + 1, end)];
}
const dates = range(2010, 2020);
console.log(dates);

//Output:
// [
// 2010, 2011, 2012,
// 2013, 2014, 2015,
// 2016, 2017, 2018,
// 2019, 2020
// ]

2 và giá trị của phần tử là

function range(start, end) {
if(start === end) return [start];
return [start, ...range(start + 1, end)];
}
const dates = range(2010, 2020);
console.log(dates);

//Output:
// [
// 2010, 2011, 2012,
// 2013, 2014, 2015,
// 2016, 2017, 2018,
// 2019, 2020
// ]

3. Kết quả cuối cùng sẽ như sau

function range(start, end) {
return (new Array(end - start + 1)).fill(undefined).map((_, i) => i + start);
}
var myArray = range(15, 21);
console.log(myArray);

//Output:
// [
// 15, 16, 17, 18,
// 19, 20, 21
// ]

Mảng phương thức. từ()

Phương thức tĩnh

function range(start, end) {
if(start === end) return [start];
// recursive case
}

1 tạo một bản sao mới của một đối tượng giống như mảng hoặc có thể lặp lại. Nó nhận một tham số mapFn có thể, cho phép bạn thực thi hàm map() cho từng phần tử của mảng đã tạo

Hàm mũi tên.

function range(start, end) {
if(start === end) return [start];
return [start, ...range(start + 1, end)];
}
const dates = range(2010, 2020);
console.log(dates);

//Output:
// [
// 2010, 2011, 2012,
// 2013, 2014, 2015,
// 2016, 2017, 2018,
// 2019, 2020
// ]

5. Các tham số trong ngoặc đơn được chuyển đến hàm

function range(start, end) {
if(start === end) return [start];
// recursive case
}

6. Vì vậy, chúng tôi tạo một mảng bằng cách chỉ định độ dài của nó trong dấu ngoặc nhọn

function range(start, end) {
if(start === end) return [start];
return [start, ...range(start + 1, end)];
}
const dates = range(2010, 2020);
console.log(dates);

//Output:
// [
// 2010, 2011, 2012,
// 2013, 2014, 2015,
// 2016, 2017, 2018,
// 2019, 2020
// ]

7 và sau đó áp dụng phương thức map()

function range(start, end) {
const mylength = end - start + 1;
return Array.from({ length: mylength }, (_, i) => start + i);
}
const myArr = range(105, 110);
console.log(myArr);

// Output:
// [ 105, 106, 107, 108, 109, 110 ]

tạo trình tự

Khi xử lý các phạm vi lớn, về cơ bản là tạo ra các mảng lớn, chúng ta có thể tối ưu hóa mức tiêu thụ bộ nhớ bằng cách sử dụng trình tạo. Từ khóa

function range(start, end) {
if(start === end) return [start];
return [start, ...range(start + 1, end)];
}
const dates = range(2010, 2020);
console.log(dates);

//Output:
// [
// 2010, 2011, 2012,
// 2013, 2014, 2015,
// 2016, 2017, 2018,
// 2019, 2020
// ]

8 theo sau là (hàm) xác định hàm tạo

Chức năng này khác với chức năng thông thường ở chỗ bạn có thể thoát ra và vào lại. Đồng thời, bối cảnh của nó, tôi. e. giá trị biến được lưu vào các mục tiếp theo. Câu lệnh suất trả về một giá trị và thoát khỏi hàm, trong khi câu lệnh suất* ủy thác việc thực thi cho một hàm khác. Đây là ví dụ của chúng ta sẽ như thế nào

function* range(start, end) {
for (let i = start; i <= end; i++) {
yield i;
}
}

Chúng ta có thể sử dụng trình tạo này trong

function range(start, end) {
if(start === end) return [start];
return [start, ...range(start + 1, end)];
}
const dates = range(2010, 2020);
console.log(dates);

//Output:
// [
// 2010, 2011, 2012,
// 2013, 2014, 2015,
// 2016, 2017, 2018,
// 2019, 2020
// ]

9 để lặp qua mảng có thể lặp lại, trong trường hợp của chúng tôi là mảng

function range(start, end) {
if(start === end) return [start];
// recursive case
}

2, để xuất kết quả hoặc sử dụng toán tử trải rộng mảng để nhận tất cả các giá trị (điều này tạo ra cùng một mảng như cách tiếp cận không phải trình tạo)

for (const i of range(1, 5)) {
console.log(i);
}
/* Output
1 2 3 4 5 /

[...range(1, 5)] // [1, 2, 3, 4, 5]

Hầu hết các lập trình viên cố gắng tránh vòng lặp for, chúng ta cũng có thể định nghĩa đệ quy trình tạo, đồng thời kiểm tra xem giá trị bắt đầu và kết thúc có giống nhau không. Hãy điền vào mảng bằng cách sử dụng toán tử trải rộng mảng

function* range(start, end) {
yield start;
if (start === end) return;
yield* range(start + 1, end);
}

const myArr = [...range(55, 65)];
console.log(myArr);

//Output:
// [
// 55, 56, 57, 58, 59,
// 60, 61, 62, 63, 64,
// 65
// ]

Hãy thêm tham số bước, tôi. e. mỗi số được tạo tiếp theo sẽ thay đổi bao nhiêu. Chúng ta sử dụng phương thức

function range(start, end) {
if(start === end) return [start];
// recursive case
}

1 với tham số mapFn, độ dài mảng sẽ được tính theo công thức

function range(start, end) {
return (new Array(end - start + 1)).fill(undefined).map((_, i) => i + start);
}
var myArray = range(15, 21);
console.log(myArray);

//Output:
// [
// 15, 16, 17, 18,
// 19, 20, 21
// ]

2, và giá trị phần tử là

function range(start, end) {
return (new Array(end - start + 1)).fill(undefined).map((_, i) => i + start);
}
var myArray = range(15, 21);
console.log(myArray);

//Output:
// [
// 15, 16, 17, 18,
// 19, 20, 21
// ]

3 sẽ được viết bằng arrow function

const range = (start, stop, step) => Array.from({ length: (stop - start) / step + 1}, (_, i) => start + (i * step));

const myArr = range(23, 29, 0.5);

console.log(myArr);

//Output:
// [
// 23, 23.5, 24, 24.5,
// 25, 25.5, 26, 26.5,
// 27, 27.5, 28, 28.5,
// 29
// ]

Bây giờ, hãy thử tạo một chuỗi ký tự, ví dụ: bảng chữ cái. Chúng tôi sẽ sử dụng hàm phạm vi đã có sẵn với tham số bước

Phương thức

function range(start, end) {
return (new Array(end - start + 1)).fill(undefined).map((_, i) => i + start);
}
var myArray = range(15, 21);
console.log(myArray);

//Output:
// [
// 15, 16, 17, 18,
// 19, 20, 21
// ]

4 trả về mã ký tự UTF-16 của chuỗi, là một số nguyên từ 0 đến 65535, tham số chỉ mục xác định vị trí của ký tự. Vì các ký tự A và Z trong bảng Unicode được sắp xếp theo thứ tự nên chúng ta có thể sử dụng mã của chúng làm giá trị bắt đầu và kết thúc cho hàm phạm vi, i. e. lần lượt là 65 và 90

Phương thức tĩnh

function range(start, end) {
return (new Array(end - start + 1)).fill(undefined).map((_, i) => i + start);
}
var myArray = range(15, 21);
console.log(myArray);

//Output:
// [
// 15, 16, 17, 18,
// 19, 20, 21
// ]

5 trả về một chuỗi được tạo từ một chuỗi mã UTF-16. Tham số num1 chỉ định giá trị mã ký tự. Bây giờ, hãy thêm một hàm map() để mỗi mã được trả về bởi hàm phạm vi được chuyển đổi thành một ký tự, tôi. e. thư

Phạm vi cho số JavaScript là gì?

Khái niệm phạm vi trong JavaScript là gì?

Phạm vi () hoạt động như thế nào?

Làm cách nào để lấy phạm vi trong JavaScript?