programming javascript

Hướng dẫn find negative number in array javascript - tìm số âm trong mảng javascript

Tôi có nhiệm vụ: Viết hàm getnegativenumbers [mảng] như một đối số lấy mảng. Hàm phải trả về một mảng mới chỉ điền vào số âm.function getNegativeNumbers [array] which as an argument take array. The function has to return a new array filled only negative numbers.

Tôi đã thực hiện giải pháp này, nhưng tôi hỏi về các phương pháp khác nhau.

var myArray = [4, -5, 0, 2, -67, 8, 10, -34 ];

function getNegativeNumbers[array] {

    var negatives = [];

    for [var i = 0; i < array.length; i++] {
        if [array[i] < 0] {
            negatives.push[array[i]];
        }
    }
    return negatives;

}
console.log[getNegativeNumbers[myArray]];

Đã hỏi ngày 6 tháng 7 năm 2017 lúc 13:23Jul 6, 2017 at 13:23

Hãy thử theo sau

var myArray = [4, -5, 0, 2, -67, 8, 10, -34];

function getNegativeNumbers[array] {
  return array.filter[function[value] {
    return value < 0;
  }];
}
console.log[getNegativeNumbers[myArray]];

ES6

var myArray = [4, -5, 0, 2, -67, 8, 10, -34];

function getNegativeNumbers[array] {
  return array.filter[value => value < 0];
}
console.log[getNegativeNumbers[myArray]];

Để tham khảo - Bộ lọc

Đã trả lời ngày 6 tháng 7 năm 2017 lúc 13:26Jul 6, 2017 at 13:26

Nikhil Aggarwalnikhil AggarwalNikhil Aggarwal

Phim thương hiệu vàng 27,9k44 gold badges40 silver badges58 bronze badges

Sử dụng

var myArray = [4, -5, 0, 2, -67, 8, 10, -34];

function getNegativeNumbers[array] {
  return array.filter[function[value] {
    return value < 0;
  }];
}
console.log[getNegativeNumbers[myArray]];

6 để tạo một mảng số âm mới:

var myArray = [4, -5, 0, 2, -67, 8, 10, -34 ];

var result = myArray.filter[function[number] {
  return number < 0;
}];

console.log[result];

Đã trả lời ngày 6 tháng 7 năm 2017 lúc 13:25Jul 6, 2017 at 13:25

Ori droriori droriOri Drori

174K29 Huy hiệu vàng205 Huy hiệu bạc195 Huy hiệu Đồng29 gold badges205 silver badges195 bronze badges

Sử dụng Array.Filter

var myArray = [4, -5, 0, 2, -67, 8, 10, -34 ];

var negatives = myArray.filter[e => e < 0];

console.log[negatives];

Đã trả lời ngày 6 tháng 7 năm 2017 lúc 13:27Jul 6, 2017 at 13:27

Các giải pháp cuối cùng

Hãy cùng xem xét các giải pháp cuối cùng của chúng tôi mà không cần nhận xét, và làm sạch một số cú pháp của chúng tôi:
NHIỆM VỤ HOÀN THÀNH
Mặc dù
```
1  value < 0];
}
console.log[getNegativeNumbers[myArray]];
```
1 và vào cuối
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34 ];

var result = myArray.filter[function[number] {
  return number < 0;
}];

console.log[result];
```
3, chúng ta có thể lặp lại thông qua
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34 ];

var result = myArray.filter[function[number] {
  return number < 0;
}];

console.log[result];
```
3 và kiểm tra xem
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34 ];

var negatives = myArray.filter[e => e < 0];

console.log[negatives];
```
8 và nếu vậy, tăng bộ đếm của chúng ta.
Nếu
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34 ];

var negatives = myArray.filter[e => e < 0];

console.log[negatives];
```
9, thì
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34];

function getNegativeNumbers[array] {
  return array.filter[value => value < 0];
}
console.log[getNegativeNumbers[myArray]];
```
6 phải là một số dương [hoặc 0] và vì
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34 ];

var result = myArray.filter[function[number] {
  return number < 0;
}];

console.log[result];
```
3 được sắp xếp theo thứ tự không tăng, chúng tôi sẽ không tìm thấy số âm nữa trong
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34 ];

var result = myArray.filter[function[number] {
  return number < 0;
}];

console.log[result];
```
3 và phần còn lại của mảng phụ phải được lấp đầy bằng số dương.
Một khi
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34 ];

var negatives = myArray.filter[e => e < 0];

console.log[negatives];
```
9, chúng ta có thể thoát ra khỏi lần lặp.
Vấn đề duy nhất với giải pháp này là chúng ta sẽ cần phải tổ chức một lần lặp để truy cập
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34];

function getNegativeNumbers[array] {
  return array.filter[value => value < 0];
}
console.log[getNegativeNumbers[myArray]];
```
6 và trong trường hợp xấu nhất, nó sẽ chạy trong thời gian
```
[ -15, -8 ]
```
5.
Tôi nghĩ chúng ta có thể làm tốt hơn.
Giải pháp số 2: Lặp lại đơn
Vì vậy, thứ tự không tăng của
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34];

function getNegativeNumbers[array] {
  return array.filter[value => value < 0];
}
console.log[getNegativeNumbers[myArray]];
```
1 chỉ quan trọng trong bối cảnh của các hàng và cột. Chà, vì tất cả những gì chúng ta cần làm là xác định xem một số có âm hay không, đơn hàng không thực sự quan trọng. Điều gì sẽ xảy ra nếu chúng ta ném ra tất cả các hàng và cột và chỉ làm phẳng ma trận?

Nếu chúng ta làm phẳng
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34];

function getNegativeNumbers[array] {
  return array.filter[value => value < 0];
}
console.log[getNegativeNumbers[myArray]];
```
1 và đặt ma trận phẳng thành một biến có tên là một cái gì đó như
```
[ -15, -8 ]
```
8, chúng ta có thể sử dụng một lần lặp duy nhất để lặp qua
```
[ -15, -8 ]
```
8 và chạy cùng một câu lệnh
```
m == grid.length
```
0 như chúng ta đã làm trong giải pháp đầu tiên. Điều đó có nghĩa là chúng ta sẽ cần kiểm tra từng yếu tố mà không thể thoát ra khỏi lần lặp.
Chúng tôi có thể sắp xếp
```
[ -15, -8 ]
```
8, nhưng nếu chúng tôi gọi
```
m == grid.length
```
2 trên
```
[ -15, -8 ]
```
8 để làm như vậy, chúng tôi thực sự sẽ tăng độ phức tạp thời gian của chúng tôi vì
```
m == grid.length
```
2 thường sử dụng các phương thức hợp nhất và sắp xếp nhanh tùy thuộc vào môi trường thời gian chạy của bạn. Cả hai phương pháp thường chạy trong thời gian
```
m == grid.length
```
5, mặc dù Sắp xếp hợp nhất sẽ kết thúc trong thời gian
```
[ -15, -8 ]
```
5 nếu
```
[ -15, -8 ]
```
8 bắt đầu ngày càng lớn.
Vì vậy, nó thực sự sẽ nhanh hơn để chúng tôi lặp lại thông qua mảng phẳng chưa được phân loại do ràng buộc của chúng tôi
```
m == grid.length
```
8.
Chúng ta cũng có thể sử dụng
```
m == grid.length
```
9 thay vì
```
n == grid[i].length
```
0 vì đây là cách hiệu quả hơn để làm phẳng một mảng khi chúng ta không biết độ dài của một mảng trước đó.
Mã giả
Bây giờ chúng tôi đã làm việc thông qua một vài giải pháp, hãy thử viết một số mã giả trước khi đặt bất cứ thứ gì vào mã:
Giải pháp số 1: Lặp lại lồng nhau
Giải pháp số 2: Lặp lại đơn
Nice.
Vì vậy, thứ tự không tăng của
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34];

function getNegativeNumbers[array] {
  return array.filter[value => value < 0];
}
console.log[getNegativeNumbers[myArray]];
```
1 chỉ quan trọng trong bối cảnh của các hàng và cột. Chà, vì tất cả những gì chúng ta cần làm là xác định xem một số có âm hay không, đơn hàng không thực sự quan trọng. Điều gì sẽ xảy ra nếu chúng ta ném ra tất cả các hàng và cột và chỉ làm phẳng ma trận?
Nếu chúng ta làm phẳng
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34];

function getNegativeNumbers[array] {
  return array.filter[value => value < 0];
}
console.log[getNegativeNumbers[myArray]];
```
1 và đặt ma trận phẳng thành một biến có tên là một cái gì đó như
```
[ -15, -8 ]
```
8, chúng ta có thể sử dụng một lần lặp duy nhất để lặp qua
```
[ -15, -8 ]
```
8 và chạy cùng một câu lệnh
```
m == grid.length
```
0 như chúng ta đã làm trong giải pháp đầu tiên. Điều đó có nghĩa là chúng ta sẽ cần kiểm tra từng yếu tố mà không thể thoát ra khỏi lần lặp.
Giải pháp số 1: Lặp lại lồng nhau
Nếu chúng ta không muốn đột biến
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34];

function getNegativeNumbers[array] {
  return array.filter[value => value < 0];
}
console.log[getNegativeNumbers[myArray]];
```
1, chúng ta có thể sử dụng thứ tự của một ma trận nhất định cho lợi thế của chúng ta. Vì
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34];

function getNegativeNumbers[array] {
  return array.filter[value => value < 0];
}
console.log[getNegativeNumbers[myArray]];
```
1 được sắp xếp theo thứ tự không tăng, cả khôn ngoan hàng và cột, chúng tôi có thể lặp qua mỗi mảng phụ của
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34];

function getNegativeNumbers[array] {
  return array.filter[value => value < 0];
}
console.log[getNegativeNumbers[myArray]];
```
1 bắt đầu từ phần tử cuối cùng trong
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34];

function getNegativeNumbers[array] {
  return array.filter[value => value < 0];
}
console.log[getNegativeNumbers[myArray]];
```
1. Đó là nơi chúng tôi rất có thể tìm thấy một mảng con với các số âm trong đó. Chúng ta cũng có thể bắt đầu với phần tử cuối cùng trong mỗi mảng phụ
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34];

function getNegativeNumbers[array] {
  return array.filter[value => value < 0];
}
console.log[getNegativeNumbers[myArray]];
```
6 vì đó là nơi rất có thể chúng ta cũng sẽ tìm thấy một số âm.
Bắt đầu vào cuối
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34];

function getNegativeNumbers[array] {
  return array.filter[value => value < 0];
}
console.log[getNegativeNumbers[myArray]];
```
1 và vào cuối
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34 ];

var result = myArray.filter[function[number] {
  return number < 0;
}];

console.log[result];
```
3, chúng ta có thể lặp lại thông qua
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34 ];

var result = myArray.filter[function[number] {
  return number < 0;
}];

console.log[result];
```
3 và kiểm tra xem
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34 ];

var negatives = myArray.filter[e => e < 0];

console.log[negatives];
```
8 và nếu vậy, tăng bộ đếm của chúng ta.
Nếu
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34 ];

var negatives = myArray.filter[e => e < 0];

console.log[negatives];
```
9, thì
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34];

function getNegativeNumbers[array] {
  return array.filter[value => value < 0];
}
console.log[getNegativeNumbers[myArray]];
```
6 phải là một số dương [hoặc 0] và vì
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34 ];

var result = myArray.filter[function[number] {
  return number < 0;
}];

console.log[result];
```
3 được sắp xếp theo thứ tự không tăng, chúng tôi sẽ không tìm thấy số âm nữa trong
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34 ];

var result = myArray.filter[function[number] {
  return number < 0;
}];

console.log[result];
```
3 và phần còn lại của mảng phụ phải được lấp đầy bằng số dương.
Một khi
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34 ];

var negatives = myArray.filter[e => e < 0];

console.log[negatives];
```
9, chúng ta có thể thoát ra khỏi lần lặp.
Vấn đề duy nhất với giải pháp này là chúng ta sẽ cần phải tổ chức một lần lặp để truy cập
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34];

function getNegativeNumbers[array] {
  return array.filter[value => value < 0];
}
console.log[getNegativeNumbers[myArray]];
```
6 và trong trường hợp xấu nhất, nó sẽ chạy trong thời gian
```
[ -15, -8 ]
```
5.
Nice.
Giải pháp số 2: Lặp lại đơn
Vì vậy, thứ tự không tăng của
```
var myArray = [4, -5, 0, 2, -67, 8, 10, -34];

function getNegativeNumbers[array] {
  return array.filter[value => value < 0];
}
console.log[getNegativeNumbers[myArray]];
```
1 chỉ quan trọng trong bối cảnh của các hàng và cột. Chà, vì tất cả những gì chúng ta cần làm là xác định xem một số có âm hay không, đơn hàng không thực sự quan trọng. Điều gì sẽ xảy ra nếu chúng ta ném ra tất cả các hàng và cột và chỉ làm phẳng ma trận?
Tiếp theo, hãy để Lừa thiết lập vòng lặp
```
1 
					


						



							
						

  

				
```

Toplist mới

Top 4 uống nước chanh sả mật ong có tác dụng gì 2023

5 tháng trước

Top 10 bài tập làm văn số 5 lớp 7 de 4 2023

5 tháng trước

Top 3 vừa chơi đã có tài khoản vương giả chap 1 2023

5 tháng trước

Top 6 anh sẽ on thôi cover phạm nguyên ngọc lyrics 2023

5 tháng trước

Mã giả

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề