Một giải pháp thay thế hai chiều hy vọng nhanh hơn
2 / Object.defineProperty[Array.prototype,'bidirectionalIndexOf',{value:function[b,c,d,e]{
for[c=this.length,d=c*1; c--; ]{
if[this[c]==b] return c; //or this[c]===b
if[this[e=d-1-c] == b] return e; //or this[e=d-1-c]===b
}
return -1
},writable:false, enumerable:false}];
// Usage
array.bidirectionalIndexOf['value'];
3Object.defineProperty[Array.prototype,'bidirectionalIndexOf',{value:function[b,c,d,e]{
for[c=this.length,d=c*1; c--; ]{
if[this[c]==b] return c; //or this[c]===b
if[this[e=d-1-c] == b] return e; //or this[e=d-1-c]===b
}
return -1
},writable:false, enumerable:false}];
// Usage
array.bidirectionalIndexOf['value'];
2015
Mặc dù phương pháp mới
Object.defineProperty[Array.prototype,'bidirectionalIndexOf',{value:function[b,c,d,e]{
for[c=this.length,d=c*1; c--; ]{
if[this[c]==b] return c; //or this[c]===b
if[this[e=d-1-c] == b] return e; //or this[e=d-1-c]===b
}
return -1
},writable:false, enumerable:false}];
// Usage
array.bidirectionalIndexOf['value'];
4 rất đẹp, nhưng hỗ trợ về cơ bản là không.Đó là một thời gian dài mà tôi đã nghĩ ra một cách để thay thế các chức năng chậm ____ 12/________ 13.
Một cách biểu diễn đã được tìm thấy, nhìn vào các câu trả lời hàng đầu. Từ những người tôi đã chọn hàm
Object.defineProperty[Array.prototype,'bidirectionalIndexOf',{value:function[b,c,d,e]{
for[c=this.length,d=c*1; c--; ]{
if[this[c]==b] return c; //or this[c]===b
if[this[e=d-1-c] == b] return e; //or this[e=d-1-c]===b
}
return -1
},writable:false, enumerable:false}];
// Usage
array.bidirectionalIndexOf['value'];
7 được đăng bởi @Damir Zekic, đây là loại nhanh nhất. Nhưng nó cũng nói rằng các điểm chuẩn là từ năm 2008 và đã lỗi thời.Tôi cũng thích
Object.defineProperty[Array.prototype,'bidirectionalIndexOf',{value:function[b,c,d,e]{
for[c=this.length,d=c*1; c--; ]{
if[this[c]==b] return c; //or this[c]===b
if[this[e=d-1-c] == b] return e; //or this[e=d-1-c]===b
}
return -1
},writable:false, enumerable:false}];
// Usage
array.bidirectionalIndexOf['value'];
8 hơn Object.defineProperty[Array.prototype,'bidirectionalIndexOf',{value:function[b,c,d,e]{
for[c=this.length,d=c*1; c--; ]{
if[this[c]==b] return c; //or this[c]===b
if[this[e=d-1-c] == b] return e; //or this[e=d-1-c]===b
}
return -1
},writable:false, enumerable:false}];
// Usage
array.bidirectionalIndexOf['value'];
9, nhưng không phải là một lý do cụ thể, tôi đã kết thúc việc viết chức năng với một vòng lặp. Nó cũng có thể được thực hiện với một function bidirectionalIndexOf[a, b, c, d]{
c=a.length; d=c-1;
while[c--]{
if[b===a[c]] return c;
if[b===a[d-c]] return d-c;
}
return c
}
// Usage
bidirectionalIndexOf[array,'value'];
0.Tôi đã tò mò nếu lần lặp lại chậm hơn nhiều nếu tôi kiểm tra cả hai mặt của mảng trong khi thực hiện nó. Rõ ràng là không, và vì vậy chức năng này nhanh hơn khoảng hai lần so với những người được bỏ phiếu hàng đầu. Rõ ràng nó cũng nhanh hơn người bản địa. Đây là trong một môi trường thế giới thực, nơi bạn không bao giờ biết liệu giá trị bạn đang tìm kiếm có ở đầu hay ở cuối mảng không.
Khi bạn biết bạn vừa đẩy một mảng có giá trị, sử dụng Lastindexof vẫn có thể là giải pháp tốt nhất, nhưng nếu bạn phải đi qua các mảng lớn và kết quả có thể ở khắp mọi nơi, đây có thể là một giải pháp vững chắc để làm cho mọi thứ nhanh hơn.
Hai chiều ________ 12/________ 13
function bidirectionalIndexOf[a, b, c, d, e]{
for[c=a.length,d=c*1; c--; ]{
if[a[c]==b] return c; //or this[c]===b
if[a[e=d-1-c]==b] return e; //or a[e=d-1-c]===b
}
return -1
}
//Usage
bidirectionalIndexOf[array,'value'];
Kiểm tra hiệu suất
//jsbench.me/7el1b8dj80
Như một bài kiểm tra, tôi đã tạo một mảng với các mục nhập 100k.
Ba truy vấn: Ở đầu, ở giữa và ở cuối mảng.
Tôi hy vọng bạn cũng tìm thấy điều này thú vị và kiểm tra hiệu suất.
Lưu ý: Như bạn có thể thấy tôi đã sửa đổi một chút hàm
Object.defineProperty[Array.prototype,'bidirectionalIndexOf',{value:function[b,c,d,e]{
for[c=this.length,d=c*1; c--; ]{
if[this[c]==b] return c; //or this[c]===b
if[this[e=d-1-c] == b] return e; //or this[e=d-1-c]===b
}
return -1
},writable:false, enumerable:false}];
// Usage
array.bidirectionalIndexOf['value'];
7 để phản ánh đầu ra Object.defineProperty[Array.prototype,'bidirectionalIndexOf',{value:function[b,c,d,e]{
for[c=this.length,d=c*1; c--; ]{
if[this[c]==b] return c; //or this[c]===b
if[this[e=d-1-c] == b] return e; //or this[e=d-1-c]===b
}
return -1
},writable:false, enumerable:false}];
// Usage
array.bidirectionalIndexOf['value'];
2 & Object.defineProperty[Array.prototype,'bidirectionalIndexOf',{value:function[b,c,d,e]{
for[c=this.length,d=c*1; c--; ]{
if[this[c]==b] return c; //or this[c]===b
if[this[e=d-1-c] == b] return e; //or this[e=d-1-c]===b
}
return -1
},writable:false, enumerable:false}];
// Usage
array.bidirectionalIndexOf['value'];
3 [về cơ bản function bidirectionalIndexOf[a, b, c, d]{
c=a.length; d=c-1;
while[c--]{
if[b===a[c]] return c;
if[b===a[d-c]] return d-c;
}
return c
}
// Usage
bidirectionalIndexOf[array,'value'];
6 với function bidirectionalIndexOf[a, b, c, d]{
c=a.length; d=c-1;
while[c--]{
if[b===a[c]] return c;
if[b===a[d-c]] return d-c;
}
return c
}
// Usage
bidirectionalIndexOf[array,'value'];
7 và function bidirectionalIndexOf[a, b, c, d]{
c=a.length; d=c-1;
while[c--]{
if[b===a[c]] return c;
if[b===a[d-c]] return d-c;
}
return c
}
// Usage
bidirectionalIndexOf[array,'value'];
8 với function bidirectionalIndexOf[a, b, c, d]{
c=a.length; d=c-1;
while[c--]{
if[b===a[c]] return c;
if[b===a[d-c]] return d-c;
}
return c
}
// Usage
bidirectionalIndexOf[array,'value'];
9]. Điều đó không gây hại cho nó.Biến thể nguyên mẫu mảng
Object.defineProperty[Array.prototype,'bidirectionalIndexOf',{value:function[b,c,d,e]{
for[c=this.length,d=c*1; c--; ]{
if[this[c]==b] return c; //or this[c]===b
if[this[e=d-1-c] == b] return e; //or this[e=d-1-c]===b
}
return -1
},writable:false, enumerable:false}];
// Usage
array.bidirectionalIndexOf['value'];
Hàm cũng có thể dễ dàng sửa đổi để trả về đúng hoặc sai hoặc thậm chí đối tượng, chuỗi hoặc bất cứ điều gì nó là.
Và đây là biến thể
Object.defineProperty[Array.prototype,'bidirectionalIndexOf',{value:function[b,c,d,e]{
for[c=this.length,d=c*1; c--; ]{
if[this[c]==b] return c; //or this[c]===b
if[this[e=d-1-c] == b] return e; //or this[e=d-1-c]===b
}
return -1
},writable:false, enumerable:false}];
// Usage
array.bidirectionalIndexOf['value'];
8:function bidirectionalIndexOf[a, b, c, d]{
c=a.length; d=c-1;
while[c--]{
if[b===a[c]] return c;
if[b===a[d-c]] return d-c;
}
return c
}
// Usage
bidirectionalIndexOf[array,'value'];
Sao có thể như thế được?
Tôi nghĩ rằng tính toán đơn giản để có được chỉ số được phản ánh trong một mảng đơn giản đến mức nhanh hơn hai lần so với thực hiện một lần lặp vòng lặp thực tế.
Dưới đây là một ví dụ phức tạp thực hiện ba kiểm tra cho mỗi lần lặp, nhưng điều này chỉ có thể với tính toán dài hơn gây ra sự chậm lại của mã.
//web.archive.org/web/20151019160219///jsperf.com/bidirectionalindexof/2
Tóm tắt: Trong hướng dẫn này, bạn sẽ học cách kiểm tra xem một mảng có chứa giá trị trong JavaScript không.: in this tutorial, you’ll learn how to check if an array contains a value in JavaScript.
Một giá trị trong JavaScript có thể là nguyên thủy như một số hoặc chuỗi. Hoặc nó có thể là một đối tượng.
Hướng dẫn này cho thấy bạn kiểm tra xem một mảng có chứa giá trị không, là giá trị hoặc đối tượng nguyên thủy.
Để kiểm tra xem một mảng có chứa giá trị nguyên thủy không, bạn có thể sử dụng phương thức mảng như
1Code language: JavaScript [javascript]
const colors = ['red', 'green', 'blue']; const result = colors.includes['red']; console.log[result]; // true
Ví dụ sau sử dụng phương thức
1 để kiểm tra xem mảngCode language: JavaScript [javascript]
const colors = ['red', 'green', 'blue']; const result = colors.includes['red']; console.log[result]; // true
3 có chứaCode language: JavaScript [javascript]
const colors = ['red', 'green', 'blue']; const result = colors.includes['red']; console.log[result]; // true
4 không:Code language: JavaScript [javascript]
const colors = ['red', 'green', 'blue']; const result = colors.includes['red']; console.log[result]; // true
Code language: JavaScript [javascript]
const colors = ['red', 'green', 'blue']; const result = colors.includes['red']; console.log[result]; // true
Nếu bạn muốn ingore các trường hợp thư khi kiểm tra, bạn có thể:
- Đầu tiên, hãy trả về một mảng mới chứa tất cả các phần tử bằng chữ thường bằng các phương thức
5 và
Code language: JavaScript [javascript]const colors = ['red', 'green', 'blue']; const result = colors.includes['red']; console.log[result]; // true
6.
Code language: JavaScript [javascript]const colors = ['red', 'green', 'blue']; const result = colors.includes['red']; console.log[result]; // true
- Sau đó, sử dụng phương pháp
7 để kiểm tra.
Code language: JavaScript [javascript]const colors = ['red', 'green', 'blue']; const result = colors.includes['red']; console.log[result]; // true
Ví dụ sau minh họa các bước:
Code language: JavaScript [javascript]
const colors = ['Red', 'GREEN', 'Blue']; const result = colors.map[e => e.toLocaleLowerCase[]] .includes['green']; console.log[result]; // true
Trong ví dụ này, mảng
3 không chứaCode language: JavaScript [javascript]
const colors = ['red', 'green', 'blue']; const result = colors.includes['red']; console.log[result]; // true
9 nhưngCode language: JavaScript [javascript]
const colors = ['red', 'green', 'blue']; const result = colors.includes['red']; console.log[result]; // true
0.Code language: JavaScript [javascript]
const colors = ['Red', 'GREEN', 'Blue']; const result = colors.map[e => e.toLocaleLowerCase[]] .includes['green']; console.log[result]; // true
Đầu tiên, phương thức
5 tạo ra mọi phần tử trong chữ thường mảngCode language: JavaScript [javascript]
const colors = ['red', 'green', 'blue']; const result = colors.includes['red']; console.log[result]; // true
3 và trả về một mảng mới. Sau đó, phương thứcCode language: JavaScript [javascript]
const colors = ['red', 'green', 'blue']; const result = colors.includes['red']; console.log[result]; // true
7 trả về
const colors = ['red', 'green', 'blue']; const result = colors.includes['red']; console.log[result]; // true
Code language: JavaScript [javascript]
function bidirectionalIndexOf[a, b, c, d]{
c=a.length; d=c-1;
while[c--]{
if[b===a[c]] return c;
if[b===a[d-c]] return d-c;
}
return c
}
// Usage
bidirectionalIndexOf[array,'value'];
6 vì mảng kết quả chứa phần tử 9.Code language: JavaScript [javascript]
const colors = ['red', 'green', 'blue']; const result = colors.includes['red']; console.log[result]; // true
2] Kiểm tra xem một mảng có chứa số không
Ví dụ sau đây cho thấy cách sử dụng phương thức
7 để kiểm tra xem một mảng có chứa số không:Code language: JavaScript [javascript]
const colors = ['red', 'green', 'blue']; const result = colors.includes['red']; console.log[result]; // true
Code language: JavaScript [javascript]
const ratings = [1,2,3,4,5]; let result = ratings.includes[4]; console.log[result]; // true result = ratings.includes[6]; console.log[result]; // false
3] Kiểm tra xem một mảng có chứa một đối tượng không
Ví dụ sau sử dụng phương thức
7 để kiểm tra xem một mảng có chứa đối tượng không:Code language: JavaScript [javascript]
const colors = ['red', 'green', 'blue']; const result = colors.includes['red']; console.log[result]; // true
Code language: JavaScript [javascript]
const john = { 'name': 'John Doe', 'email': '' }; const jane = { 'name': 'Jane Doe', 'email': '' }; const list = [john, jane]; let result = list.includes[john]; console.log[result]; // true
Trong ví dụ này,
8 trả vềCode language: JavaScript [javascript]
const colors = ['Red', 'GREEN', 'Blue']; const result = colors.map[e => e.toLocaleLowerCase[]] .includes['green']; console.log[result]; // true
function bidirectionalIndexOf[a, b, c, d]{
c=a.length; d=c-1;
while[c--]{
if[b===a[c]] return c;
if[b===a[d-c]] return d-c;
}
return c
}
// Usage
bidirectionalIndexOf[array,'value'];
6 vì mảng 0 chứa tham chiếu đối tượngCode language: JavaScript [javascript]
const ratings = [1,2,3,4,5]; let result = ratings.includes[4]; console.log[result]; // true result = ratings.includes[6]; console.log[result]; // false
1.Code language: JavaScript [javascript]
const ratings = [1,2,3,4,5]; let result = ratings.includes[4]; console.log[result]; // true result = ratings.includes[6]; console.log[result]; // false
Trong thực tế, thay vì tìm kiếm một sự từ chối, bạn thường tìm kiếm các đối tượng theo giá trị tài sản của chúng. Ví dụ sau đây đã giành được công việc:
Code language: JavaScript [javascript]
const list = [{ 'name': 'John Doe', 'email': '' }, { 'name': 'Jane Doe', 'email': '' }]; let result = list.includes[{ 'name': 'John Doe', 'email': '' }]; console.log[result]; // false
Trong ví dụ này, đối tượng sau:
Code language: JavaScript [javascript]
{ 'name': 'John Doe', 'email': '' }
Trông giống như yếu tố đầu tiên trong mảng
0. Tuy nhiên, phương thứcCode language: JavaScript [javascript]
const ratings = [1,2,3,4,5]; let result = ratings.includes[4]; console.log[result]; // true result = ratings.includes[6]; console.log[result]; // false
7 trả vềCode language: JavaScript [javascript]
const colors = ['red', 'green', 'blue']; const result = colors.includes['red']; console.log[result]; // true
function bidirectionalIndexOf[a, b, c, d]{
c=a.length; d=c-1;
while[c--]{
if[b===a[c]] return c;
if[b===a[d-c]] return d-c;
}
return c
}
// Usage
bidirectionalIndexOf[array,'value'];
8 vì 0 không chứa một tham chiếu đến đối tượng được tìm kiếm.Code language: JavaScript [javascript]
const ratings = [1,2,3,4,5]; let result = ratings.includes[4]; console.log[result]; // true result = ratings.includes[6]; console.log[result]; // false
Để kiểm tra xem một mảng có chứa một đối tượng không, bạn làm theo các bước sau:
- Đầu tiên, tạo một hàm trợ giúp so sánh hai đối tượng với các thuộc tính của chúng.
- Thứ hai, sử dụng phương thức
6 để tìm đối tượng được tìm kiếm bằng các giá trị thuộc tính.
Code language: JavaScript [javascript]const ratings = [1,2,3,4,5]; let result = ratings.includes[4]; console.log[result]; // true result = ratings.includes[6]; console.log[result]; // false
Để so sánh các đối tượng với các giá trị thuộc tính, bạn sử dụng hàm trợ giúp sau:
Code language: JavaScript [javascript]
const isEqual = [first, second] => { return JSON.stringify[first] === JSON.stringify[second]; }
Hàm
7 trả vềCode language: JavaScript [javascript]
const ratings = [1,2,3,4,5]; let result = ratings.includes[4]; console.log[result]; // true result = ratings.includes[6]; console.log[result]; // false
function bidirectionalIndexOf[a, b, c, d]{
c=a.length; d=c-1;
while[c--]{
if[b===a[c]] return c;
if[b===a[d-c]] return d-c;
}
return c
}
// Usage
bidirectionalIndexOf[array,'value'];
6 nếu các đối tượng 9 vàCode language: JavaScript [javascript]
const ratings = [1,2,3,4,5]; let result = ratings.includes[4]; console.log[result]; // true result = ratings.includes[6]; console.log[result]; // false
0 có cùng số lượng thuộc tính có cùng giá trị.Code language: JavaScript [javascript]
const john = { 'name': 'John Doe', 'email': '' }; const jane = { 'name': 'Jane Doe', 'email': '' }; const list = [john, jane]; let result = list.includes[john]; console.log[result]; // true
Và giới hạn của hàm
7 là thứ tự các thuộc tính của các đối tượng được so sánh phải giống nhau.Code language: JavaScript [javascript]
const ratings = [1,2,3,4,5]; let result = ratings.includes[4]; console.log[result]; // true result = ratings.includes[6]; console.log[result]; // false
Lưu ý rằng một số thư viện cung cấp chức năng cho phép bạn so sánh hai đối tượng với các giá trị thuộc tính của chúng.
Ví dụ: lodash có phương thức _.isequal [] cho phép bạn so sánh các đối tượng nếu chúng bằng với hiệu suất tốt hơn so với sử dụng
2.Code language: JavaScript [javascript]
const john = { 'name': 'John Doe', 'email': '' }; const jane = { 'name': 'Jane Doe', 'email': '' }; const list = [john, jane]; let result = list.includes[john]; console.log[result]; // true
Sau đây sử dụng phương thức
6 để khớp với mọi phần tử của một mảng với đối tượng được tìm kiếm:Code language: JavaScript [javascript]
const ratings = [1,2,3,4,5]; let result = ratings.includes[4]; console.log[result]; // true result = ratings.includes[6]; console.log[result]; // false
Object.defineProperty[Array.prototype,'bidirectionalIndexOf',{value:function[b,c,d,e]{
for[c=this.length,d=c*1; c--; ]{
if[this[c]==b] return c; //or this[c]===b
if[this[e=d-1-c] == b] return e; //or this[e=d-1-c]===b
}
return -1
},writable:false, enumerable:false}];
// Usage
array.bidirectionalIndexOf['value'];
0Đặt nó tất cả cùng nhau:
Object.defineProperty[Array.prototype,'bidirectionalIndexOf',{value:function[b,c,d,e]{
for[c=this.length,d=c*1; c--; ]{
if[this[c]==b] return c; //or this[c]===b
if[this[e=d-1-c] == b] return e; //or this[e=d-1-c]===b
}
return -1
},writable:false, enumerable:false}];
// Usage
array.bidirectionalIndexOf['value'];
1Bản tóm tắt
- Đối với các giá trị nguyên thủy, hãy sử dụng phương thức
1 để kiểm tra xem một mảng có chứa giá trị không.
Code language: JavaScript [javascript]const colors = ['red', 'green', 'blue']; const result = colors.includes['red']; console.log[result]; // true
- Đối với các đối tượng, hãy sử dụng hàm trợ giúp
7 để so sánh các đối tượng và phương thức
Code language: JavaScript [javascript]const ratings = [1,2,3,4,5]; let result = ratings.includes[4]; console.log[result]; // true result = ratings.includes[6]; console.log[result]; // false
6 để kiểm tra xem mảng có chứa đối tượng không.
Code language: JavaScript [javascript]const ratings = [1,2,3,4,5]; let result = ratings.includes[4]; console.log[result]; // true result = ratings.includes[6]; console.log[result]; // false
Hướng dẫn này có hữu ích không?