Source: lib/util/array_utils.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.util.ArrayUtils');
  10. /**
  11.  * @namespace shaka.util.ArrayUtils
  12.  * @summary Array utility functions.
  13.  */
  16. shaka.util.ArrayUtils = class {
  17.   /**
  18.    * Returns whether the two values contain the same value.  This correctly
  19.    * handles comparisons involving NaN.
  20.    * @param {T} a
  21.    * @param {T} b
  22.    * @return {boolean}
  23.    * @template T
  24.    */
  25.   static defaultEquals(a, b) {
  26.     // NaN !== NaN, so we need to special case it.
  27.     if (typeof a === 'number' &&
  28.         typeof b === 'number' && isNaN(a) && isNaN(b)) {
  29.       return true;
  30.     }
  31.     return a === b;
  32.   }
  35.   /**
  36.    * Remove given element from array (assumes no duplicates).
  37.    * @param {!Array.<T>} array
  38.    * @param {T} element
  39.    * @template T
  40.    */
  41.   static remove(array, element) {
  42.     const index = array.indexOf(element);
  43.     if (index > -1) {
  44.       array.splice(index, 1);
  45.     }
  46.   }
  49.   /**
  50.    * Count the number of items in the list that pass the check function.
  51.    * @param {!Array.<T>} array
  52.    * @param {function(T):boolean} check
  53.    * @return {number}
  54.    * @template T
  55.    */
  56.   static count(array, check) {
  57.     let count = 0;
  59.     for (const element of array) {
  60.       count += check(element) ? 1 : 0;
  61.     }
  63.     return count;
  64.   }
  67.   /**
  68.    * Determines if the given arrays contain equal elements in any order.
  69.    *
  70.    * @param {!Array.<T>} a
  71.    * @param {!Array.<T>} b
  72.    * @param {function(T, T):boolean=} compareFn
  73.    * @return {boolean}
  74.    * @template T
  75.    */
  76.   static hasSameElements(a, b, compareFn) {
  77.     if (!compareFn) {
  78.       compareFn = shaka.util.ArrayUtils.defaultEquals;
  79.     }
  80.     if (a.length != b.length) {
  81.       return false;
  82.     }
  84.     const copy = b.slice();
  85.     for (const item of a) {
  86.       const idx = copy.findIndex((other) => compareFn(item, other));
  87.       if (idx == -1) {
  88.         return false;
  89.       }
  90.       // Since order doesn't matter, just swap the last element with
  91.       // this one and then drop the last element.
  92.       copy[idx] = copy[copy.length - 1];
  93.       copy.pop();
  94.     }
  96.     return copy.length == 0;
  97.   }
  100.   /**
  101.    * Determines if the given arrays contain equal elements in the same order.
  102.    *
  103.    * @param {!Array.<T>} a
  104.    * @param {!Array.<T>} b
  105.    * @param {function(T, T):boolean=} compareFn
  106.    * @return {boolean}
  107.    * @template T
  108.    */
  109.   static equal(a, b, compareFn) {
  110.     if (!compareFn) {
  111.       compareFn = shaka.util.ArrayUtils.defaultEquals;
  112.     }
  113.     if (a.length != b.length) {
  114.       return false;
  115.     }
  117.     for (let i = 0; i < a.length; i++) {
  118.       if (!compareFn(a[i], b[i])) {
  119.         return false;
  120.       }
  121.     }
  122.     return true;
  123.   }
  124. };