Làm cách nào để tìm phần tử đầu tiên của mảng khớp với điều kiện boolean trong JavaScript?

Tôi đang tự hỏi liệu có một cách được biết đến, tích hợp / thanh lịch để tìm phần tử đầu tiên của mảng JS phù hợp với một điều kiện nhất định không. Tương đương AC # sẽ là List.Find .

Cho đến nay tôi đã sử dụng kết hợp hai chức năng như thế này:

// Returns the first element of an array that satisfies given predicate
Array.prototype.findFirst = function (predicateCallback) {
    if (typeof predicateCallback !== 'function') {
        return undefined;
    }

    for (var i = 0; i < arr.length; i++) {
        if (i in this && predicateCallback(this[i])) return this[i];
    }

    return undefined;
};

// Check if element is not undefined && not null
isNotNullNorUndefined = function (o) {
    return (typeof (o) !== 'undefined' && o !== null);
};

Và sau đó tôi có thể sử dụng:

var result = someArray.findFirst(isNotNullNorUndefined);

Nhưng vì có rất nhiều phương thức mảng kiểu chức năng trong ECMAScript , có lẽ có một cái gì đó ngoài kia đã như thế này? Tôi tưởng tượng rất nhiều người phải thực hiện những thứ như thế này mọi lúc ...

Vì ES6 có findphương thức riêng cho mảng; điều này dừng liệt kê mảng một khi nó tìm thấy kết quả khớp đầu tiên và trả về giá trị.

const result = someArray.find(isNotNullNorUndefined);

Câu trả lời cũ:

Tôi phải đăng câu trả lời để dừng những filterđề xuất này :-)

vì có rất nhiều phương thức mảng kiểu chức năng trong ECMAScript, có lẽ có một cái gì đó ngoài kia đã như thế này?

Bạn có thể sử dụng somephương thức Array để lặp lại mảng cho đến khi một điều kiện được đáp ứng (và sau đó dừng lại). Thật không may, nó sẽ chỉ trả về cho dù điều kiện được đáp ứng một lần, không phải bởi yếu tố nào (hoặc ở chỉ số nào) mà nó được đáp ứng. Vì vậy, chúng tôi phải sửa đổi nó một chút:

function find(arr, test, ctx) {
    var result = null;
    arr.some(function(el, i) {
        return test.call(ctx, el, i, arr) ? ((result = el), true) : false;
    });
    return result;
}

var result = find(someArray, isNotNullNorUndefined);

Kể từ ECMAScript 6, bạn có thể sử dụng Array.prototype.findcho việc này. Điều này được triển khai và hoạt động trong Firefox (25.0), Chrome (45.0), Edge (12) và Safari (7.1), nhưng không có trong Internet Explorer hoặc một loạt các nền tảng cũ hoặc không phổ biến khác .

Ví dụ, biểu thức dưới đây ước tính 106.

[100,101,102,103,104,105,106,107,108,109].find(function (el) {
    return el > 105;
});

Nếu bạn muốn sử dụng ngay bây giờ nhưng cần hỗ trợ cho IE hoặc các trình duyệt không hỗ trợ khác, bạn có thể sử dụng shim. Tôi đề nghị es6-shim . MDN cũng cung cấp một shim nếu vì lý do nào đó bạn không muốn đưa toàn bộ es6-shim vào dự án của mình. Để có khả năng tương thích tối đa, bạn muốn es6-shim, vì không giống như phiên bản MDN, nó phát hiện các triển khai gốc lỗi findvà ghi đè lên chúng (xem nhận xét bắt đầu "Làm việc xung quanh các lỗi trong Array # find và Array # find Index" và các dòng ngay sau nó) .

Điều gì về việc sử dụng bộ lọc và nhận chỉ mục đầu tiên từ mảng kết quả?

var result = someArray.filter(isNotNullNorUndefined)[0];

Bây giờ, rõ ràng là JavaScript không cung cấp giải pháp nào như vậy; Đây là hai dẫn xuất gần nhất, đầu tiên hữu ích nhất:

1. Array.prototype.some(fn)đưa ra hành vi mong muốn dừng lại khi một điều kiện được đáp ứng, nhưng chỉ trả về cho dù một phần tử có mặt hay không; không khó để áp dụng một số mánh khóe, chẳng hạn như giải pháp được đưa ra bởi câu trả lời của Berg .

2. Array.prototype.filter(fn)[0]làm cho một lớp lót tuyệt vời nhưng kém hiệu quả nhất, bởi vì bạn vứt bỏ N - 1các yếu tố chỉ để có được những gì bạn cần.

Các phương thức tìm kiếm truyền thống trong JavaScript được đặc trưng bằng cách trả về chỉ mục của phần tử được tìm thấy thay vì chính phần tử hoặc -1. Điều này tránh phải chọn giá trị trả về từ miền của tất cả các loại có thể; một chỉ mục chỉ có thể là một số và các giá trị âm không hợp lệ.

Cả hai giải pháp trên đều không hỗ trợ tìm kiếm bù, vì vậy tôi đã quyết định viết bài này:

(function(ns) {
  ns.search = function(array, callback, offset) {
    var size = array.length;

    offset = offset || 0;
    if (offset >= size || offset <= -size) {
      return -1;
    } else if (offset < 0) {
      offset = size - offset;
    }

    while (offset < size) {
      if (callback(array[offset], offset, array)) {
        return offset;
      }
      ++offset;
    }
    return -1;
  };
}(this));

search([1, 2, NaN, 4], Number.isNaN); // 2
search([1, 2, 3, 4], Number.isNaN); // -1
search([1, NaN, 3, NaN], Number.isNaN, 2); // 3

Tóm lược:

• Để tìm phần tử đầu tiên trong một mảng phù hợp với điều kiện boolean, chúng ta có thể sử dụng ES6 find()
• find()được đặt trên Array.prototypeđể nó có thể được sử dụng trên mọi mảng.
• find()thực hiện một cuộc gọi lại trong đó một booleanđiều kiện được kiểm tra. Hàm trả về giá trị (không phải chỉ mục!)

Thí dụ:

const array = [4, 33, 8, 56, 23];

const found = array.find((element) => {
  return element > 50;
});

console.log(found);   //  56

Nếu bạn đang sử dụng, underscore.jsbạn có thể sử dụng chức năng findvà indexOfchức năng của nó để có được chính xác những gì bạn muốn:

var index = _.indexOf(your_array, _.find(your_array, function (d) {
    return d === true;
}));

Tài liệu:

• http://underscorejs.org/#find
• http://underscorejs.org/#indexOf

Kể từ ES 2015, Array.prototype.find()cung cấp chức năng chính xác này.

Đối với các trình duyệt không hỗ trợ tính năng này, Mozilla Developer Network đã cung cấp một polyfill (được dán bên dưới):

if (!Array.prototype.find) {
  Array.prototype.find = function(predicate) {
    if (this === null) {
      throw new TypeError('Array.prototype.find called on null or undefined');
    }
    if (typeof predicate !== 'function') {
      throw new TypeError('predicate must be a function');
    }
    var list = Object(this);
    var length = list.length >>> 0;
    var thisArg = arguments[1];
    var value;

    for (var i = 0; i < length; i++) {
      value = list[i];
      if (predicate.call(thisArg, value, i, list)) {
        return value;
      }
    }
    return undefined;
  };
}

Array.prototype.find () thực hiện điều đó, thêm thông tin: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find

foundElement = myArray[myArray.findIndex(element => //condition here)];

Tôi đã lấy cảm hứng từ nhiều nguồn trên internet để tìm ra giải pháp dưới đây. Muốn tính đến cả một số giá trị mặc định và cung cấp một cách để so sánh từng mục cho một cách tiếp cận chung mà điều này giải quyết.

Cách sử dụng: (đưa ra giá trị "Thứ hai")

var defaultItemValue = { id: -1, name: "Undefined" };
var containers: Container[] = [{ id: 1, name: "First" }, { id: 2, name: "Second" }];
GetContainer(2).name;

Thực hiện:

class Container {
    id: number;
    name: string;
}

public GetContainer(containerId: number): Container {
  var comparator = (item: Container): boolean => {
      return item.id == containerId;
    };
    return this.Get<Container>(this.containers, comparator, this.defaultItemValue);
  }

private Get<T>(array: T[], comparator: (item: T) => boolean, defaultValue: T): T {
  var found: T = null;
  array.some(function(element, index) {
    if (comparator(element)) {
      found = element;
      return true;
    }
  });

  if (!found) {
    found = defaultValue;
  }

  return found;
}

Không có chức năng tích hợp trong Javascript để thực hiện tìm kiếm này.

Nếu bạn đang sử dụng jQuery, bạn có thể làm một jQuery.inArray(element,array).

Một cách ít thanh lịch hơn sẽ có throwtất cả các thông báo lỗi đúng (dựa trên Array.prototype.filter) nhưng sẽ dừng lặp lại trên kết quả đầu tiên là

function findFirst(arr, test, context) {
    var Result = function (v, i) {this.value = v; this.index = i;};
    try {
        Array.prototype.filter.call(arr, function (v, i, a) {
            if (test(v, i, a)) throw new Result(v, i);
        }, context);
    } catch (e) {
        if (e instanceof Result) return e;
        throw e;
    }
}

Sau đó, ví dụ là

findFirst([-2, -1, 0, 1, 2, 3], function (e) {return e > 1 && e % 2;});
// Result {value: 3, index: 5}
findFirst([0, 1, 2, 3], 0);               // bad function param
// TypeError: number is not a function
findFirst(0, function () {return true;}); // bad arr param
// undefined
findFirst([1], function (e) {return 0;}); // no match
// undefined

Nó hoạt động bằng cách kết thúc filterbằng cách sử dụng throw.