Vòng lặp for theo thứ tự giảm dần javascript

Như tên gợi ý, phương thức này đảo ngược thứ tự của các phần tử mảng bằng cách sửa đổi mảng hiện có

cú pháp

array.reverse()

Ví dụ.

arr = [1,2,3,4];
arr.reverse();
console.log(arr);

//Output: [ 4, 3, 2, 1 ]

Sử dụng vòng lặp For giảm dần

arr = [1, 2, 3, 4];
arr1 = [];
for (let i = arr.length - 1; i >= 0; i--) {
    arr1.push(arr[i]);
}
console.log(arr1);

//Output: [4, 3, 2, 1]

Trong ví dụ trên, chúng ta sử dụng một vòng lặp giảm dần để duyệt qua mảng arr từ phía sau và lưu từng phần tử vào mảng mới arr1. Phương pháp này không sửa đổi mảng ban đầu

Sử dụng Phương thức Unshift()

arr = [1, 2, 3, 4];
arr1 = [];
arr.forEach(element => {
    arr1.unshift(element)
});
console.log(arr1);

//Output: [4, 3, 2, 1]

Phương pháp này rất giống với phương pháp trước và không sửa đổi mảng ban đầu. Thay vì sử dụng vòng lặp for, phương thức này sử dụng phương thức forEach() & unshift(). Phương thức forEach() thực hiện thao tác cho từng phần tử của mảng và phương thức unshift thêm phần tử mới vào đầu mảng

Không sử dụng mảng mới hoặc phương thức reverse()

Trong hai phương pháp trước, chúng tôi đã không sửa đổi mảng hiện có và lưu trữ các phần tử bị đảo ngược trong một mảng mới. Bây giờ, chúng ta sẽ xem làm thế nào một người có thể đảo ngược và sửa đổi một mảng hiện có mà không cần sử dụng phương pháp đảo ngược

arr = [1, 2, 3, 4];
for (let i = 0; i < Math.floor(arr.length / 2); i++) {
    [arr[i], arr[arr.length - 1 - i]] = [arr[arr.length - 1 - i], arr[i]];
}
console.log(arr);

//Output: [4, 3, 2, 1]

Trong phương pháp này, chúng ta chỉ duyệt qua một nửa chiều dài của mảng đã cho và hoán đổi các phần tử theo khoảng cách bằng nhau từ phần tử đầu tiên và phần tử cuối cùng i, e, phần tử đầu tiên với phần tử cuối cùng và phần tử thứ hai với phần tử cuối cùng thứ hai, v.v.

Phương thức

arr = [1,2,3,4];
arr.reverse();
console.log(arr);

//Output: [ 4, 3, 2, 1 ]

6 trả về các khóa được sắp xếp theo cách giống như đã cho bằng cách lặp qua các thuộc tính của đối tượng theo cách thủ công

Chúng tôi đã sử dụng Mảng. phương thức đảo ngược để đảo ngược mảng khóa

Phương thức

arr = [1,2,3,4];
arr.reverse();
console.log(arr);

//Output: [ 4, 3, 2, 1 ]

7 đảo vị trí các phần tử trong mảng và trả về kết quả

Nó không liên quan trong trường hợp này, nhưng lưu ý rằng phương thức

arr = [1,2,3,4];
arr.reverse();
console.log(arr);

//Output: [ 4, 3, 2, 1 ]

7 thay đổi nội dung của mảng ban đầu

Để tránh làm thay đổi mảng ban đầu, bạn thường phải tạo một bản sao trước khi gọi phương thức

arr = [1,2,3,4];
arr.reverse();
console.log(arr);

//Output: [ 4, 3, 2, 1 ]

7

CÂU HỎI–Nếu điều kiện dừng là BẰNG HOẶC LỚN HƠN 0, thì khi vòng lặp for bắt đầu, biến đã LỚN HƠN 0, vậy tại sao nó lại tiếp tục?

var vacationSpots = ['Paris', 'New York', 'Barcelona'];

for (var i = vacationSpots.length - 1; i >= 0; i--) {
	console.log('I would love to visit ' + vacationSpots[i]);
}

Ví dụ

const trái cây = ["Chuối", "Cam", "Táo", "Xoài"];
trái cây. đảo ngược();

Tự mình thử »

---

Định nghĩa và cách sử dụng

Phương thức

arr = [1,2,3,4];
arr.reverse();
console.log(arr);

//Output: [ 4, 3, 2, 1 ]

7 đảo ngược thứ tự các phần tử trong mảng

Phương thức

arr = [1,2,3,4];
arr.reverse();
console.log(arr);

//Output: [ 4, 3, 2, 1 ]

7 ghi đè lên mảng ban đầu

---

cú pháp

Giá trị trả về

Mảng sau khi đảo ngược

---

Hỗ trợ trình duyệt

arr = [1,2,3,4];
arr.reverse();
console.log(arr);

//Output: [ 4, 3, 2, 1 ]

7 là một tính năng ECMAScript1 (ES1)

ES1 (JavaScript 1997) được hỗ trợ đầy đủ trên mọi trình duyệt

ChromeEdgeFirefoxSafariOperaIECóCóCóCóCóCó

Hầu hết các nhà phát triển JS đều biết rằng việc tránh gọi Array sẽ hiệu quả hơn. độ dài trên mỗi lần lặp của một vòng lặp

for( i = 0; i < myArray.length; i++ )

Có một số cách xung quanh điều này. Phổ biến nhất là lưu trữ độ dài

for( i = 0, len = myArray.length; i < len; i++ )

Tôi thấy sẽ thanh lịch hơn một chút khi sử dụng trình vòng lặp giảm dần, khi tôi có thể

________số 8

Điều này có thể được đơn giản hóa hơn nữa để

for( i = myArray.length; --i >= 0; )

hoặc tốt hơn

arr = [1,2,3,4];
arr.reverse();
console.log(arr);

//Output: [ 4, 3, 2, 1 ]

0

Các nhà phát triển mới làm quen sẽ có thể tìm ra điều gì đang xảy ra, nhưng luôn thận trọng khi đi chệch khỏi cú pháp chuẩn

nhưng lý do cho điều này có thể khá phức tạp (chỉ đề cập đến, có các vấn đề về tiền xử lý lệnh của bộ xử lý và xử lý bộ đệm trong trò chơi)

Về ngôn ngữ cấp cao, như JavaScript như bạn đã hỏi, bạn có thể tối ưu hóa mọi thứ nếu dựa vào các thư viện, hàm tích hợp để lặp. Hãy để họ quyết định cách thực hiện tốt nhất

Do đó, trong JavaScript, tôi khuyên bạn nên sử dụng một cái gì đó như

arr = [1,2,3,4];
arr.reverse();
console.log(arr);

//Output: [ 4, 3, 2, 1 ]

1

Nó cũng ít bị lỗi hơn và các trình duyệt có cơ hội tối ưu hóa mã của bạn

[NHẬN XÉT. không chỉ trình duyệt mà bạn cũng có không gian để tối ưu hóa dễ dàng, chỉ cần xác định lại hàm

arr = [1, 2, 3, 4];
arr1 = [];
for (let i = arr.length - 1; i >= 0; i--) {
    arr1.push(arr[i]);
}
console.log(arr1);

//Output: [4, 3, 2, 1]

3 (phụ thuộc vào trình duyệt) để nó sử dụng thủ thuật tốt nhất mới nhất. . ) @MỘT. M. K. nói rằng trong những trường hợp đặc biệt, nên sử dụng

arr = [1, 2, 3, 4];
arr1 = [];
for (let i = arr.length - 1; i >= 0; i--) {
    arr1.push(arr[i]);
}
console.log(arr1);

//Output: [4, 3, 2, 1]

4 hoặc

arr = [1,2,3,4];
arr.reverse();
console.log(arr);

//Output: [ 4, 3, 2, 1 ]

20. Nếu bạn làm điều đó, hãy đặt nó sau bức màn. Quá mức cần thiết là thêm các tùy chọn vào

arr = [1, 2, 3, 4];
arr1 = [];
for (let i = arr.length - 1; i >= 0; i--) {
    arr1.push(arr[i]);
}
console.log(arr1);

//Output: [4, 3, 2, 1]

3 để chọn thuật toán lặp. ]

Ngoài ra, đối với các ngôn ngữ cấp thấp, cách tốt nhất là sử dụng một số chức năng thư viện thông minh cho các hoạt động lặp, phức tạp nếu có thể

Những thư viện đó cũng có thể đặt mọi thứ (đa luồng) sau lưng bạn và các lập trình viên chuyên biệt cũng luôn cập nhật chúng

Tôi đã xem xét kỹ lưỡng hơn một chút và hóa ra là trong C/C++, ngay cả đối với các phép toán 5e9 = (50.000x100.000), không có sự khác biệt giữa tăng và giảm nếu thử nghiệm được thực hiện theo một hằng số . (Kết quả JsPerf đôi khi không nhất quán nhưng nhìn chung đều giống nhau. bạn không thể tạo ra sự khác biệt lớn. )
Vì vậy,

arr = [1,2,3,4];
arr.reverse();
console.log(arr);

//Output: [ 4, 3, 2, 1 ]

22 tình cờ trở thành một thứ khá "sang trọng". Nó chỉ khiến bạn trông giống như một lập trình viên giỏi hơn. . )

Mặt khác, để hủy đăng ký trong tình huống 5e9 này, tôi đã giảm thời gian từ 12 giây xuống còn 2. 5 giây khi tôi đi qua 10 giây và đến 2. 1 giây khi tôi đi qua 20 giây. Nó không có tối ưu hóa, và tối ưu hóa đã rút ngắn mọi thứ xuống một khoảng thời gian ngắn không thể đo lường được. . ) (Việc hủy đăng ký có thể được thực hiện theo cách của tôi ở trên hoặc sử dụng

arr = [1, 2, 3, 4];
arr1 = [];
for (let i = arr.length - 1; i >= 0; i--) {
    arr1.push(arr[i]);
}
console.log(arr1);

//Output: [4, 3, 2, 1]

6, nhưng điều đó không mang lại hiệu quả trong JavaScript. )

Tất cả trong tất cả. giữ sự khác biệt của

arr = [1,2,3,4];
arr.reverse();
console.log(arr);

//Output: [ 4, 3, 2, 1 ]

24/

arr = [1, 2, 3, 4];
arr1 = [];
for (let i = arr.length - 1; i >= 0; i--) {
    arr1.push(arr[i]);
}
console.log(arr1);

//Output: [4, 3, 2, 1]

6 và

arr = [1, 2, 3, 4];
arr1 = [];
for (let i = arr.length - 1; i >= 0; i--) {
    arr1.push(arr[i]);
}
console.log(arr1);

//Output: [4, 3, 2, 1]

8/

arr = [1, 2, 3, 4];
arr1 = [];
for (let i = arr.length - 1; i >= 0; i--) {
    arr1.push(arr[i]);
}
console.log(arr1);

//Output: [4, 3, 2, 1]

6 đối với các cuộc phỏng vấn xin việc, tuân theo

arr = [1,2,3,4];
arr.reverse();
console.log(arr);

//Output: [ 4, 3, 2, 1 ]

28 hoặc các chức năng thư viện phức tạp khác nếu có. ;)

Làm cách nào để sử dụng vòng lặp for theo thứ tự ngược lại trong JavaScript?

Tại sao vòng lặp ngược?

Vòng lặp nào nhanh hơn trong JavaScript?

Làm cách nào để đảo ngược thứ tự của một mảng trong JavaScript?