Bạn có nên tránh các vòng lặp trong Python không?

Question

Bây giờ là năm

const checkEveryValueGreaterThanForty = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i] <= 40) return false;
  }
  return true;
};

const checkEveryWordLongerThanSix = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i].length <= 6) return false;
  }
  return true;
};

// Most devs already know to use Array.prototype.sort(), consider this
// a more extreme example of what enigmatic for loop code can look like
function bubbleSort(myArray) {
  let isSorted = false;
  while (!isSorted) {
    isSorted = true;
    for (let i = 1; i < myArray.length; i++) {
      if (myArray[i - 1] > myArray[i]) {
        isSorted = false;
        [myArray[i - 1], myArray[i]] = [myArray[i], myArray[i - 1]];
      }
    }
  }
  return myArray;
}

6, và tôi vẫn thấy nhiều nhà phát triển JavaScript sử dụng và thậm chí khuyến nghị sử dụng vòng lặp

const checkEveryValueGreaterThanForty = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i] <= 40) return false;
  }
  return true;
};

const checkEveryWordLongerThanSix = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i].length <= 6) return false;
  }
  return true;
};

// Most devs already know to use Array.prototype.sort(), consider this
// a more extreme example of what enigmatic for loop code can look like
function bubbleSort(myArray) {
  let isSorted = false;
  while (!isSorted) {
    isSorted = true;
    for (let i = 1; i < myArray.length; i++) {
      if (myArray[i - 1] > myArray[i]) {
        isSorted = false;
        [myArray[i - 1], myArray[i]] = [myArray[i], myArray[i - 1]];
      }
    }
  }
  return myArray;
}

7. Bản thân bạn thậm chí có thể đang sử dụng vòng lặp

const checkEveryValueGreaterThanForty = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i] <= 40) return false;
  }
  return true;
};

const checkEveryWordLongerThanSix = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i].length <= 6) return false;
  }
  return true;
};

// Most devs already know to use Array.prototype.sort(), consider this
// a more extreme example of what enigmatic for loop code can look like
function bubbleSort(myArray) {
  let isSorted = false;
  while (!isSorted) {
    isSorted = true;
    for (let i = 1; i < myArray.length; i++) {
      if (myArray[i - 1] > myArray[i]) {
        isSorted = false;
        [myArray[i - 1], myArray[i]] = [myArray[i], myArray[i - 1]];
      }
    }
  }
  return myArray;
}

7 một cách thường xuyên. Đây là lý do tại sao bạn không nên và những gì bạn nên sử dụng thay thế

Nội dung chính Show

Tại sao bạn không nên sử dụng vòng lặp const checkEveryValueGreaterThanForty = myArray => { for (let i = 0; i < myArray.length; i++) { if (myArray[i] <= 40) return false; } return true; }; const checkEveryWordLongerThanSix = myArray => { for (let i = 0; i < myArray.length; i++) { if (myArray[i].length <= 6) return false; } return true; }; // Most devs already know to use Array.prototype.sort(), consider this // a more extreme example of what enigmatic for loop code can look like function bubbleSort(myArray) { let isSorted = false; while (!isSorted) { isSorted = true; for (let i = 1; i < myArray.length; i++) { if (myArray[i - 1] > myArray[i]) { isSorted = false; [myArray[i - 1], myArray[i]] = [myArray[i], myArray[i - 1]]; } } } return myArray; } 7?
Bạn nên sử dụng cái gì thay thế?
1. Thiếu rõ ràng
2. Phản ứng phụ
3. đột biến có thể
Điểm mấu chốt
Bạn có nên sử dụng vòng lặp for trong Python không?
Tại sao bạn không nên sử dụng vòng lặp for?
Bạn có nên tránh các vòng lặp lồng nhau không?
Sự thay thế tốt nhất cho vòng lặp Python là gì?

Tại sao bạn không nên sử dụng vòng lặp const checkEveryValueGreaterThanForty = myArray => { for (let i = 0; i < myArray.length; i++) { if (myArray[i] <= 40) return false; } return true; }; const checkEveryWordLongerThanSix = myArray => { for (let i = 0; i < myArray.length; i++) { if (myArray[i].length <= 6) return false; } return true; }; // Most devs already know to use Array.prototype.sort(), consider this // a more extreme example of what enigmatic for loop code can look like function bubbleSort(myArray) { let isSorted = false; while (!isSorted) { isSorted = true; for (let i = 1; i < myArray.length; i++) { if (myArray[i - 1] > myArray[i]) { isSorted = false; [myArray[i - 1], myArray[i]] = [myArray[i], myArray[i - 1]]; } } } return myArray; } 7?

const checkEveryValueGreaterThanForty = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i] <= 40) return false;
  }
  return true;
};

const checkEveryWordLongerThanSix = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i].length <= 6) return false;
  }
  return true;
};

// Most devs already know to use Array.prototype.sort(), consider this
// a more extreme example of what enigmatic for loop code can look like
function bubbleSort(myArray) {
  let isSorted = false;
  while (!isSorted) {
    isSorted = true;
    for (let i = 1; i < myArray.length; i++) {
      if (myArray[i - 1] > myArray[i]) {
        isSorted = false;
        [myArray[i - 1], myArray[i]] = [myArray[i], myArray[i - 1]];
      }
    }
  }
  return myArray;
}

7 vòng lặp và cách sử dụng chúng phần lớn là sự kế thừa từ các ngôn ngữ mệnh lệnh, đặc biệt là C-like và các dẫn xuất của chúng. Trong khi họ khá linh hoạt, họ có nhiều sai sót

Hãy bắt đầu với sự rõ ràng. Hãy đối mặt với nó, các vòng lặp

const checkEveryValueGreaterThanForty = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i] <= 40) return false;
  }
  return true;
};

const checkEveryWordLongerThanSix = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i].length <= 6) return false;
  }
  return true;
};

// Most devs already know to use Array.prototype.sort(), consider this
// a more extreme example of what enigmatic for loop code can look like
function bubbleSort(myArray) {
  let isSorted = false;
  while (!isSorted) {
    isSorted = true;
    for (let i = 1; i < myArray.length; i++) {
      if (myArray[i - 1] > myArray[i]) {
        isSorted = false;
        [myArray[i - 1], myArray[i]] = [myArray[i], myArray[i - 1]];
      }
    }
  }
  return myArray;
}

7 không tạo ra các khối mã đẹp nhất và chỉ tăng độ xấu khi chúng càng lớn. Trong các thuật toán phức tạp, chúng có thể nhanh chóng trở nên bí ẩn, gần như không thể đọc được ngoại trừ nhận xét. Và mặc dù nhận xét là một phép lịch sự được mong đợi, nhưng có một lý do tại sao tài liệu xấu lại là một trò đùa thường xuyên giữa các nhà phát triển

Thứ hai, vòng lặp

const checkEveryValueGreaterThanForty = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i] <= 40) return false;
  }
  return true;
};

const checkEveryWordLongerThanSix = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i].length <= 6) return false;
  }
  return true;
};

// Most devs already know to use Array.prototype.sort(), consider this
// a more extreme example of what enigmatic for loop code can look like
function bubbleSort(myArray) {
  let isSorted = false;
  while (!isSorted) {
    isSorted = true;
    for (let i = 1; i < myArray.length; i++) {
      if (myArray[i - 1] > myArray[i]) {
        isSorted = false;
        [myArray[i - 1], myArray[i]] = [myArray[i], myArray[i - 1]];
      }
    }
  }
  return myArray;
}

7 làm tăng khả năng xảy ra tác dụng phụ không mong muốn. Vòng lặp

const checkEveryValueGreaterThanForty = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i] <= 40) return false;
  }
  return true;
};

const checkEveryWordLongerThanSix = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i].length <= 6) return false;
  }
  return true;
};

// Most devs already know to use Array.prototype.sort(), consider this
// a more extreme example of what enigmatic for loop code can look like
function bubbleSort(myArray) {
  let isSorted = false;
  while (!isSorted) {
    isSorted = true;
    for (let i = 1; i < myArray.length; i++) {
      if (myArray[i - 1] > myArray[i]) {
        isSorted = false;
        [myArray[i - 1], myArray[i]] = [myArray[i], myArray[i - 1]];
      }
    }
  }
  return myArray;
}

7--và vòng lặp

const checkEveryValueGreaterThanForty = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i] <= 40) return false;
  }
  return true;
};

const checkEveryWordLongerThanSix = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i].length <= 6) return false;
  }
  return true;
};

// Most devs already know to use Array.prototype.sort(), consider this
// a more extreme example of what enigmatic for loop code can look like
function bubbleSort(myArray) {
  let isSorted = false;
  while (!isSorted) {
    isSorted = true;
    for (let i = 1; i < myArray.length; i++) {
      if (myArray[i - 1] > myArray[i]) {
        isSorted = false;
        [myArray[i - 1], myArray[i]] = [myArray[i], myArray[i - 1]];
      }
    }
  }
  return myArray;
}

4-- được gọi là câu lệnh điều khiển, nghĩa là chúng phải được đặt bên trong một hàm và không thể được sử dụng dưới dạng độc lập. Điều này vốn đã làm tăng khả năng bạn sẽ thao túng các biến nằm ngoài phạm vi của vòng lặp. Thật không may, điều này mâu thuẫn với các mô hình lập trình hiện đại hơn trong lập trình hàm, đặc biệt loại trừ bất kỳ thứ gì liên quan đến vòng lặp

const checkEveryValueGreaterThanForty = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i] <= 40) return false;
  }
  return true;
};

const checkEveryWordLongerThanSix = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i].length <= 6) return false;
  }
  return true;
};

// Most devs already know to use Array.prototype.sort(), consider this
// a more extreme example of what enigmatic for loop code can look like
function bubbleSort(myArray) {
  let isSorted = false;
  while (!isSorted) {
    isSorted = true;
    for (let i = 1; i < myArray.length; i++) {
      if (myArray[i - 1] > myArray[i]) {
        isSorted = false;
        [myArray[i - 1], myArray[i]] = [myArray[i], myArray[i - 1]];
      }
    }
  }
  return myArray;
}

7 trở thành một hàm thuần túy

Thứ ba, vì lý do chính xác như trên, các vòng lặp

const checkEveryValueGreaterThanForty = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i] <= 40) return false;
  }
  return true;
};

const checkEveryWordLongerThanSix = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i].length <= 6) return false;
  }
  return true;
};

// Most devs already know to use Array.prototype.sort(), consider this
// a more extreme example of what enigmatic for loop code can look like
function bubbleSort(myArray) {
  let isSorted = false;
  while (!isSorted) {
    isSorted = true;
    for (let i = 1; i < myArray.length; i++) {
      if (myArray[i - 1] > myArray[i]) {
        isSorted = false;
        [myArray[i - 1], myArray[i]] = [myArray[i], myArray[i - 1]];
      }
    }
  }
  return myArray;
}

7 có xu hướng yêu cầu đột biến ở một số dạng. Trong nhiều trường hợp, điều này cũng không thể tránh khỏi bởi vì tất cả các vòng lặp

const checkEveryValueGreaterThanForty = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i] <= 40) return false;
  }
  return true;
};

const checkEveryWordLongerThanSix = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i].length <= 6) return false;
  }
  return true;
};

// Most devs already know to use Array.prototype.sort(), consider this
// a more extreme example of what enigmatic for loop code can look like
function bubbleSort(myArray) {
  let isSorted = false;
  while (!isSorted) {
    isSorted = true;
    for (let i = 1; i < myArray.length; i++) {
      if (myArray[i - 1] > myArray[i]) {
        isSorted = false;
        [myArray[i - 1], myArray[i]] = [myArray[i], myArray[i - 1]];
      }
    }
  }
  return myArray;
}

7 thực sự có thể làm là tạo điều kiện thuận lợi cho việc lặp lại. Bản thân các vòng lặp

const checkEveryValueGreaterThanForty = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i] <= 40) return false;
  }
  return true;
};

const checkEveryWordLongerThanSix = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i].length <= 6) return false;
  }
  return true;
};

// Most devs already know to use Array.prototype.sort(), consider this
// a more extreme example of what enigmatic for loop code can look like
function bubbleSort(myArray) {
  let isSorted = false;
  while (!isSorted) {
    isSorted = true;
    for (let i = 1; i < myArray.length; i++) {
      if (myArray[i - 1] > myArray[i]) {
        isSorted = false;
        [myArray[i - 1], myArray[i]] = [myArray[i], myArray[i - 1]];
      }
    }
  }
  return myArray;
}

7 khá vô dụng, có nghĩa là bạn phải khai báo một biến để thay đổi hoặc thay đổi mảng ban đầu. Một lần nữa, điều này mâu thuẫn với các nguyên tắc lập trình chức năng

Bạn nên sử dụng cái gì thay thế?

Kể từ ES6, các phương thức

const checkEveryValueGreaterThanForty = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i] <= 40) return false;
  }
  return true;
};

const checkEveryWordLongerThanSix = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i].length <= 6) return false;
  }
  return true;
};

// Most devs already know to use Array.prototype.sort(), consider this
// a more extreme example of what enigmatic for loop code can look like
function bubbleSort(myArray) {
  let isSorted = false;
  while (!isSorted) {
    isSorted = true;
    for (let i = 1; i < myArray.length; i++) {
      if (myArray[i - 1] > myArray[i]) {
        isSorted = false;
        [myArray[i - 1], myArray[i]] = [myArray[i], myArray[i - 1]];
      }
    }
  }
  return myArray;
}

9 đã được giới thiệu khiến cho các vòng lặp

const checkEveryValueGreaterThanForty = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i] <= 40) return false;
  }
  return true;
};

const checkEveryWordLongerThanSix = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i].length <= 6) return false;
  }
  return true;
};

// Most devs already know to use Array.prototype.sort(), consider this
// a more extreme example of what enigmatic for loop code can look like
function bubbleSort(myArray) {
  let isSorted = false;
  while (!isSorted) {
    isSorted = true;
    for (let i = 1; i < myArray.length; i++) {
      if (myArray[i - 1] > myArray[i]) {
        isSorted = false;
        [myArray[i - 1], myArray[i]] = [myArray[i], myArray[i - 1]];
      }
    }
  }
  return myArray;
}

7 trở nên lỗi thời theo hầu hết các cách

Hãy tóm tắt lại các lý do chống lại vòng lặp

const checkEveryValueGreaterThanForty = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i] <= 40) return false;
  }
  return true;
};

const checkEveryWordLongerThanSix = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i].length <= 6) return false;
  }
  return true;
};

// Most devs already know to use Array.prototype.sort(), consider this
// a more extreme example of what enigmatic for loop code can look like
function bubbleSort(myArray) {
  let isSorted = false;
  while (!isSorted) {
    isSorted = true;
    for (let i = 1; i < myArray.length; i++) {
      if (myArray[i - 1] > myArray[i]) {
        isSorted = false;
        [myArray[i - 1], myArray[i]] = [myArray[i], myArray[i - 1]];
      }
    }
  }
  return myArray;
}

7 và cách các phương pháp này giải quyết chúng

1. Thiếu rõ ràng

Trong những trường hợp lý tưởng, mã tốt phải hiển nhiên và tự giải thích. Các phương thức mảng đưa chúng ta đến gần hơn với lý tưởng đó, chúng gần như đủ mô tả để đọc như một loại "ngôn ngữ tự nhiên tốc ký" nào đó

myArray.every(value => value > 40);
// Check every element of myArray is greater than 40.

myArray.filter(word => word.length > 6);
// Filter out every element in myArray longer than 6 characters.

myArray.sort();
// Sort myArray (lol)

Tương phản những điều này với tương đương vòng lặp

const checkEveryValueGreaterThanForty = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i] <= 40) return false;
  }
  return true;
};

const checkEveryWordLongerThanSix = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i].length <= 6) return false;
  }
  return true;
};

// Most devs already know to use Array.prototype.sort(), consider this
// a more extreme example of what enigmatic for loop code can look like
function bubbleSort(myArray) {
  let isSorted = false;
  while (!isSorted) {
    isSorted = true;
    for (let i = 1; i < myArray.length; i++) {
      if (myArray[i - 1] > myArray[i]) {
        isSorted = false;
        [myArray[i - 1], myArray[i]] = [myArray[i], myArray[i - 1]];
      }
    }
  }
  return myArray;
}

7 của chúng

const checkEveryValueGreaterThanForty = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i] <= 40) return false;
  }
  return true;
};

const checkEveryWordLongerThanSix = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i].length <= 6) return false;
  }
  return true;
};

// Most devs already know to use Array.prototype.sort(), consider this
// a more extreme example of what enigmatic for loop code can look like
function bubbleSort(myArray) {
  let isSorted = false;
  while (!isSorted) {
    isSorted = true;
    for (let i = 1; i < myArray.length; i++) {
      if (myArray[i - 1] > myArray[i]) {
        isSorted = false;
        [myArray[i - 1], myArray[i]] = [myArray[i], myArray[i - 1]];
      }
    }
  }
  return myArray;
}

Rất tiếc. Như bạn có thể thấy, những thứ này rất xấu, dài và bạn thực sự phải dành thời gian đọc qua toàn bộ để tìm hiểu chuyện gì đang xảy ra. Sử dụng các phương thức mảng cắt chúng thành một dòng đẹp mắt với mục đích có thể nhận ra ngay lập tức

2. Phản ứng phụ

Nhiều phương thức mảng là các hàm bậc cao hơn - chúng nhận hàm gọi lại làm một trong các tham số của chúng. Bằng cách gọi rõ ràng các phương thức cá thể mảng, phép lặp có thể được thực hiện trong một cái gì đó giống như một phạm vi khép kín. Bạn có thể đã nhận thấy điều này trong các ví dụ trước, khi các vòng lặp bên trong các hàm được thay thế bằng các phương thức một dòng

3. đột biến có thể

Các phương thức truy cập rất thuận tiện để sửa đổi một mảng và các phương thức lặp thay thế hầu hết nếu không muốn nói là tất cả các chức năng được cung cấp bởi các vòng lặp

const checkEveryValueGreaterThanForty = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i] <= 40) return false;
  }
  return true;
};

const checkEveryWordLongerThanSix = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i].length <= 6) return false;
  }
  return true;
};

// Most devs already know to use Array.prototype.sort(), consider this
// a more extreme example of what enigmatic for loop code can look like
function bubbleSort(myArray) {
  let isSorted = false;
  while (!isSorted) {
    isSorted = true;
    for (let i = 1; i < myArray.length; i++) {
      if (myArray[i - 1] > myArray[i]) {
        isSorted = false;
        [myArray[i - 1], myArray[i]] = [myArray[i], myArray[i - 1]];
      }
    }
  }
  return myArray;
}

7 mà không cần chạm vào mảng ban đầu

const doubleArrayValues = myArray => {
  const newArray = [];
  for (let i = 0; i < myArray.length; i++) {
    newArray[i] = myArray[i] * 2;
  }
  return newArray;
};

Lưu ý trong ví dụ này, chúng ta phải tạo một biến mới

const doubleArrayValues = myArray => {
  const newArray = [];
  for (let i = 0; i < myArray.length; i++) {
    newArray[i] = myArray[i] * 2;
  }
  return newArray;
};

4. Điều này là cần thiết nếu chúng tôi không muốn thay đổi

const doubleArrayValues = myArray => {
  const newArray = [];
  for (let i = 0; i < myArray.length; i++) {
    newArray[i] = myArray[i] * 2;
  }
  return newArray;
};

5, nhưng ngay cả khi vẫn vậy, chúng tôi vẫn phải thay đổi

const doubleArrayValues = myArray => {
  const newArray = [];
  for (let i = 0; i < myArray.length; i++) {
    newArray[i] = myArray[i] * 2;
  }
  return newArray;
};

4 để thuật toán hoạt động. Điều gì sẽ xảy ra nếu chúng ta thử một phương thức mảng?

________số 8

Chúng tôi đã loại bỏ nhu cầu về một biến mới mà không ảnh hưởng đến mong muốn giữ nguyên mảng ban đầu

Ngoài ra, còn có các phương thức biến đổi như

const doubleArrayValues = myArray => {
  const newArray = [];
  for (let i = 0; i < myArray.length; i++) {
    newArray[i] = myArray[i] * 2;
  }
  return newArray;
};

7,

const doubleArrayValues = myArray => {
  const newArray = [];
  for (let i = 0; i < myArray.length; i++) {
    newArray[i] = myArray[i] * 2;
  }
  return newArray;
};

8 và

const doubleArrayValues = myArray => {
  const newArray = [];
  for (let i = 0; i < myArray.length; i++) {
    newArray[i] = myArray[i] * 2;
  }
  return newArray;
};

9. Điều này mang lại, đặc biệt là khi xâu chuỗi các phương thức, là tính linh hoạt cao hơn trong cách bạn tiếp cận một thuật toán

Điều đó không có nghĩa là bạn không thể biến đổi bằng các phương pháp không biến đổi. Tuy nhiên, bạn phải cố gắng thay đổi mảng ban đầu

const checkEveryValueGreaterThanForty = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i] <= 40) return false;
  }
  return true;
};

const checkEveryWordLongerThanSix = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i].length <= 6) return false;
  }
  return true;
};

// Most devs already know to use Array.prototype.sort(), consider this
// a more extreme example of what enigmatic for loop code can look like
function bubbleSort(myArray) {
  let isSorted = false;
  while (!isSorted) {
    isSorted = true;
    for (let i = 1; i < myArray.length; i++) {
      if (myArray[i - 1] > myArray[i]) {
        isSorted = false;
        [myArray[i - 1], myArray[i]] = [myArray[i], myArray[i - 1]];
      }
    }
  }
  return myArray;
}

2

Hơi thất bại trong mục đích, nhưng một lần nữa, bạn có thể linh hoạt làm như vậy nếu bạn thực sự muốn vì một lý do nào đó (bạn không nên làm vậy)

Điểm mấu chốt

Các phương thức mảng, khi được áp dụng đúng cách, cực kỳ mạnh mẽ và hiển thị tất cả các vòng lặp

const checkEveryValueGreaterThanForty = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i] <= 40) return false;
  }
  return true;
};

const checkEveryWordLongerThanSix = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i].length <= 6) return false;
  }
  return true;
};

// Most devs already know to use Array.prototype.sort(), consider this
// a more extreme example of what enigmatic for loop code can look like
function bubbleSort(myArray) {
  let isSorted = false;
  while (!isSorted) {
    isSorted = true;
    for (let i = 1; i < myArray.length; i++) {
      if (myArray[i - 1] > myArray[i]) {
        isSorted = false;
        [myArray[i - 1], myArray[i]] = [myArray[i], myArray[i - 1]];
      }
    }
  }
  return myArray;
}

7 nhưng đã lỗi thời. Có thể viết các hàm rất thuần túy, không thay đổi bất kỳ mảng hoặc đối tượng nào và không tạo bất kỳ biến hoặc hằng nào. Ví dụ: câu hỏi phỏng vấn Tổng kết hợp phổ biến có thể được giải hoàn toàn chỉ bằng phương pháp mảng và đệ quy

const checkEveryValueGreaterThanForty = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i] <= 40) return false;
  }
  return true;
};

const checkEveryWordLongerThanSix = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i].length <= 6) return false;
  }
  return true;
};

// Most devs already know to use Array.prototype.sort(), consider this
// a more extreme example of what enigmatic for loop code can look like
function bubbleSort(myArray) {
  let isSorted = false;
  while (!isSorted) {
    isSorted = true;
    for (let i = 1; i < myArray.length; i++) {
      if (myArray[i - 1] > myArray[i]) {
        isSorted = false;
        [myArray[i - 1], myArray[i]] = [myArray[i], myArray[i - 1]];
      }
    }
  }
  return myArray;
}

3

Tất nhiên, vòng lặp

const checkEveryValueGreaterThanForty = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i] <= 40) return false;
  }
  return true;
};

const checkEveryWordLongerThanSix = myArray => {
  for (let i = 0; i < myArray.length; i++) {
    if (myArray[i].length <= 6) return false;
  }
  return true;
};

// Most devs already know to use Array.prototype.sort(), consider this
// a more extreme example of what enigmatic for loop code can look like
function bubbleSort(myArray) {
  let isSorted = false;
  while (!isSorted) {
    isSorted = true;
    for (let i = 1; i < myArray.length; i++) {
      if (myArray[i - 1] > myArray[i]) {
        isSorted = false;
        [myArray[i - 1], myArray[i]] = [myArray[i], myArray[i - 1]];
      }
    }
  }
  return myArray;
}

7 vẫn tồn tại là có lý do. Có lẽ bạn có một ứng dụng cụ thể không phù hợp hoặc không thể sử dụng các phương thức mảng. Trong những trường hợp đó, hãy cẩn thận đặt tên thích hợp cho quầy của bạn nếu bạn định sử dụng nó -- đại loại như

myArray.map(value => value * 2);

2 thay vì chỉ

myArray.map(value => value * 2);

3. Trong bất kỳ trường hợp nào khác, hãy thử dùng các phương thức mảng

Bạn có nên sử dụng vòng lặp for trong Python không?

Các vòng lặp rất quan trọng trong Python hoặc trong bất kỳ ngôn ngữ lập trình nào khác vì chúng giúp bạn thực thi lặp đi lặp lại một khối mã . Bạn sẽ thường xuyên phải đối mặt với những tình huống mà bạn cần phải sử dụng đi sử dụng lại một đoạn mã nhưng bạn không muốn viết cùng một dòng mã nhiều lần.

Tại sao bạn không nên sử dụng vòng lặp for?

vòng lặp for--và vòng lặp while-- được gọi là câu lệnh điều khiển, nghĩa là chúng phải được đặt bên trong một hàm và không thể được sử dụng dưới dạng độc lập. Điều này vốn dĩ làm tăng khả năng bạn thao túng các biến nằm ngoài phạm vi của vòng lặp .

Bạn có nên tránh các vòng lặp lồng nhau không?

Vòng lặp lồng nhau có vị trí của chúng trong quá trình phát triển, nhưng nếu bạn không cẩn thận, chúng có thể dẫn đến suy giảm hiệu suất nghiêm trọng do vòng lặp bên trong sẽ chạy một số lượng nhất định . .

Sự thay thế tốt nhất cho vòng lặp Python là gì?

Một cách nhanh hơn để lặp lại trong Python là sử dụng các hàm tích hợp sẵn . Trong ví dụ của chúng tôi, chúng tôi có thể thay thế vòng lặp for bằng hàm tổng. Hàm này sẽ tính tổng các giá trị bên trong dãy số.

programming python

Bạn có nên tránh các vòng lặp trong Python không?

Bạn nên sử dụng cái gì thay thế?

1. Thiếu rõ ràng

2. Phản ứng phụ

3. đột biến có thể

Điểm mấu chốt

Bạn có nên sử dụng vòng lặp for trong Python không?

Tại sao bạn không nên sử dụng vòng lặp for?

Bạn có nên tránh các vòng lặp lồng nhau không?

Sự thay thế tốt nhất cho vòng lặp Python là gì?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội