array

Classes


Public Protected Private

Global Functions

goog.array.binaryInsert(arrayvalueopt_compareFn) boolean
Inserts a value into a sorted array. The array is not modified if the value is already present.
Arguments:
array : Array.<VALUE> | goog.array.ArrayLike
The array to modify.
value : VALUE
The object to insert.
opt_compareFn : function(VALUE, VALUE): number=
Optional comparison function by which the array is ordered. Should take 2 arguments to compare, and return a negative number, zero, or a positive number depending on whether the first argument is less than, equal to, or greater than the second.
Returns: boolean  True if an element was inserted.
code »
goog.array.binaryRemove(arrayvalueopt_compareFn) boolean
Removes a value from a sorted array.
Arguments:
array : !Array.<VALUE> | !goog.array.ArrayLike
The array to modify.
value : VALUE
The object to remove.
opt_compareFn : function(VALUE, VALUE): number=
Optional comparison function by which the array is ordered. Should take 2 arguments to compare, and return a negative number, zero, or a positive number depending on whether the first argument is less than, equal to, or greater than the second.
Returns: boolean  True if an element was removed.
code »
goog.array.binarySearch(arrtargetopt_compareFn) number
Searches the specified array for the specified target using the binary search algorithm. If no opt_compareFn is specified, elements are compared using goog.array.defaultCompare, which compares the elements using the built in < and > operators. This will produce the expected behavior for homogeneous arrays of String(s) and Number(s). The array specified must be sorted in ascending order (as defined by the comparison function). If the array is not sorted, results are undefined. If the array contains multiple instances of the specified target value, any of these instances may be found. Runtime: O(log n)
Arguments:
arr : Array.<VALUE> | goog.array.ArrayLike
The array to be searched.
target : TARGET
The sought value.
opt_compareFn : function(TARGET, VALUE): number=
Optional comparison function by which the array is ordered. Should take 2 arguments to compare, and return a negative number, zero, or a positive number depending on whether the first argument is less than, equal to, or greater than the second.
Returns: number  Lowest index of the target value if found, otherwise (-(insertion point) - 1). The insertion point is where the value should be inserted into arr to preserve the sorted property. Return value >= 0 iff target is found.
code »
goog.array.binarySearch_(arrcompareFnisEvaluatoropt_targetopt_selfObj) number
Implementation of a binary search algorithm which knows how to use both comparison functions and evaluators. If an evaluator is provided, will call the evaluator with the given optional data object, conforming to the interface defined in binarySelect. Otherwise, if a comparison function is provided, will call the comparison function against the given data object. This implementation purposefully does not use goog.bind or goog.partial for performance reasons. Runtime: O(log n)
Arguments:
arr : Array.<VALUE> | goog.array.ArrayLike
The array to be searched.
compareFn : function(TARGET, VALUE): number |  function(this:THIS, VALUE, number, ?): number
Either an evaluator or a comparison function, as defined by binarySearch and binarySelect above.
isEvaluator : boolean
Whether the function is an evaluator or a comparison function.
opt_target : TARGET=
If the function is a comparison function, then this is the target to binary search for.
opt_selfObj : THIS=
If the function is an evaluator, this is an optional this object for the evaluator.
Returns: number  Lowest index of the target value if found, otherwise (-(insertion point) - 1). The insertion point is where the value should be inserted into arr to preserve the sorted property. Return value >= 0 iff target is found.
code »
goog.array.binarySelect(arrevaluatoropt_obj) number
Selects an index in the specified array using the binary search algorithm. The evaluator receives an element and determines whether the desired index is before, at, or after it. The evaluator must be consistent (formally, goog.array.map(goog.array.map(arr, evaluator, opt_obj), goog.math.sign) must be monotonically non-increasing). Runtime: O(log n)
Arguments:
arr : Array.<VALUE> | goog.array.ArrayLike
The array to be searched.
evaluator : function(this:THIS, VALUE, number, ?): number
Evaluator function that receives 3 arguments (the element, the index and the array). Should return a negative number, zero, or a positive number depending on whether the desired index is before, at, or after the element passed to it.
opt_obj : THIS=
The object to be used as the value of 'this' within evaluator.
Returns: number  Index of the leftmost element matched by the evaluator, if such exists; otherwise (-(insertion point) - 1). The insertion point is the index of the first element for which the evaluator returns negative, or arr.length if no such element exists. The return value is non-negative iff a match is found.
code »
goog.array.bucket(arraysorteropt_obj) !Object
Splits an array into disjoint buckets according to a splitting function.
Arguments:
array : Array.<T>
The array.
sorter : function(this:S, T,number,Array.<T>):?
Function to call for every element. This takes 3 arguments (the element, the index and the array) and must return a valid object key (a string, number, etc), or undefined, if that object should not be placed in a bucket.
opt_obj : S=
The object to be used as the value of 'this' within sorter.
Returns: !Object  An object, with keys being all of the unique return values of sorter, and values being arrays containing the items for which the splitter returned that key.
code »
goog.array.clear(arr)
Clears the array.
Arguments:
arr : goog.array.ArrayLike
Array or array like object to clear.
code »
goog.array.clone(arr) !Array.<T>
Does a shallow copy of an array.
Arguments:
arr : Array.<T> | goog.array.ArrayLike
Array or array-like object to clone.
Returns: !Array.<T>  Clone of the input array.
code »
goog.array.compare3(arr1arr2opt_compareFn) number
3-way array compare function.
Arguments:
arr1 : !Array.<VALUE> | !goog.array.ArrayLike
The first array to compare.
arr2 : !Array.<VALUE> | !goog.array.ArrayLike
The second array to compare.
opt_compareFn : function(VALUE, VALUE): number=
Optional comparison function by which the array is to be ordered. Should take 2 arguments to compare, and return a negative number, zero, or a positive number depending on whether the first argument is less than, equal to, or greater than the second.
Returns: number  Negative number, zero, or a positive number depending on whether the first argument is less than, equal to, or greater than the second.
code »
goog.array.concat(var_args) !Array
Returns a new array that is the result of joining the arguments. If arrays are passed then their items are added, however, if non-arrays are passed they will be added to the return array as is. Note that ArrayLike objects will be added as is, rather than having their items added. goog.array.concat([1, 2], [3, 4]) -> [1, 2, 3, 4] goog.array.concat(0, [1, 2]) -> [0, 1, 2] goog.array.concat([1, 2], null) -> [1, 2, null] There is bug in all current versions of IE (6, 7 and 8) where arrays created in an iframe become corrupted soon (not immediately) after the iframe is destroyed. This is common if loading data via goog.net.IframeIo, for example. This corruption only affects the concat method which will start throwing Catastrophic Errors (#-2147418113). See http://endoflow.com/scratch/corrupted-arrays.html for a test case. Internally goog.array should use this, so that all methods will continue to work on these broken array objects.
Arguments:
var_args : ...*
Items to concatenate. Arrays will have each item added, while primitives and objects will be added as is.
Returns: !Array  The new resultant array.
code »
goog.array.contains(arrobj) boolean
Whether the array contains the given object.
Arguments:
arr : goog.array.ArrayLike
The array to test for the presence of the element.
obj : *
The object for which to test.
Returns: boolean  true if obj is present.
code »
goog.array.count(arrfopt_obj) number
Counts the array elements that fulfill the predicate, i.e. for which the callback function returns true. Skips holes in the array.
Arguments:
arr : !(Array.<T> | goog.array.ArrayLike)
Array or array like object over which to iterate.
f : function(this: S, T, number, ?): boolean
The function to call for every element. Takes 3 arguments (the element, the index and the array).
opt_obj : S=
The object to be used as the value of 'this' within f.
Returns: number  The number of the matching elements.
code »
goog.array.defaultCompare(ab) number
Compares its two arguments for order, using the built in < and > operators.
Arguments:
a : VALUE
The first object to be compared.
b : VALUE
The second object to be compared.
Returns: number  A negative number, zero, or a positive number as the first argument is less than, equal to, or greater than the second.
code »
goog.array.defaultCompareEquality(ab) boolean
Compares its two arguments for equality, using the built in === operator.
Arguments:
a : *
The first object to compare.
b : *
The second object to compare.
Returns: boolean  True if the two arguments are equal, false otherwise.
code »
goog.array.equals(arr1arr2opt_equalsFn) boolean
Compares two arrays for equality. Two arrays are considered equal if they have the same length and their corresponding elements are equal according to the comparison function.
Arguments:
arr1 : goog.array.ArrayLike
The first array to compare.
arr2 : goog.array.ArrayLike
The second array to compare.
opt_equalsFn : Function=
Optional comparison function. Should take 2 arguments to compare, and return true if the arguments are equal. Defaults to goog.array.defaultCompareEquality which compares the elements using the built-in '===' operator.
Returns: boolean  Whether the two arrays are equal.
code »
goog.array.every(arrfopt_obj) boolean
Call f for each element of an array. If all calls return true, every() returns true. If any call returns false, every() returns false and does not continue to check the remaining elements. See http://tinyurl.com/developer-mozilla-org-array-every
Arguments:
arr : Array.<T> | goog.array.ArrayLike
Array or array like object over which to iterate.
f : ?function(this:S, T, number, ?) : boolean
The function to call for for every element. This function takes 3 arguments (the element, the index and the array) and should return a boolean.
opt_obj : S=
The object to be used as the value of 'this' within f.
Returns: boolean  false if any element fails the test.
code »
goog.array.extend(arr1var_args)
Extends an array with another array, element, or "array like" object. This function operates 'in-place', it does not create a new Array. Example: var a = []; goog.array.extend(a, [0, 1]); a; // [0, 1] goog.array.extend(a, 2); a; // [0, 1, 2]
Arguments:
arr1 : Array.<VALUE>
The array to modify.
var_args : ...(Array.<VALUE> | VALUE)
The elements or arrays of elements to add to arr1.
code »
goog.array.filter(arrfopt_obj) !Array.<T>
Calls a function for each element in an array, and if the function returns true adds the element to a new array. See http://tinyurl.com/developer-mozilla-org-array-filter
Arguments:
arr : Array.<T> | goog.array.ArrayLike
Array or array like object over which to iterate.
f : ?function(this:S, T, number, ?):boolean
The function to call for every element. This function takes 3 arguments (the element, the index and the array) and must return a Boolean. If the return value is true the element is added to the result array. If it is false the element is not included.
opt_obj : S=
The object to be used as the value of 'this' within f.
Returns: !Array.<T>  a new array in which only elements that passed the test are present.
code »
goog.array.find(arrfopt_obj) ?T
Search an array for the first element that satisfies a given condition and return that element.
Arguments:
arr : Array.<T> | goog.array.ArrayLike
Array or array like object over which to iterate.
f : ?function(this:S, T, number, ?) : boolean
The function to call for every element. This function takes 3 arguments (the element, the index and the array) and should return a boolean.
opt_obj : S=
An optional "this" context for the function.
Returns: ?T  The first array element that passes the test, or null if no element is found.
code »
goog.array.findIndex(arrfopt_obj) number
Search an array for the first element that satisfies a given condition and return its index.
Arguments:
arr : Array.<T> | goog.array.ArrayLike
Array or array like object over which to iterate.
f : ?function(this:S, T, number, ?) : boolean
The function to call for every element. This function takes 3 arguments (the element, the index and the array) and should return a boolean.
opt_obj : S=
An optional "this" context for the function.
Returns: number  The index of the first array element that passes the test, or -1 if no element is found.
code »
goog.array.findIndexRight(arrfopt_obj) number
Search an array (in reverse order) for the last element that satisfies a given condition and return its index.
Arguments:
arr : Array.<T> | goog.array.ArrayLike
Array or array like object over which to iterate.
f : ?function(this:S, T, number, ?) : boolean
The function to call for every element. This function takes 3 arguments (the element, the index and the array) and should return a boolean.
opt_obj : Object=
An optional "this" context for the function.
Returns: number  The index of the last array element that passes the test, or -1 if no element is found.
code »
goog.array.findRight(arrfopt_obj) ?T
Search an array (in reverse order) for the last element that satisfies a given condition and return that element.
Arguments:
arr : Array.<T> | goog.array.ArrayLike
Array or array like object over which to iterate.
f : ?function(this:S, T, number, ?) : boolean
The function to call for every element. This function takes 3 arguments (the element, the index and the array) and should return a boolean.
opt_obj : S=
An optional "this" context for the function.
Returns: ?T  The last array element that passes the test, or null if no element is found.
code »
goog.array.flatten(var_args) !Array
Returns an array consisting of every argument with all arrays expanded in-place recursively.
Arguments:
var_args : ...*
The values to flatten.
Returns: !Array  An array containing the flattened values.
code »
goog.array.forEach(arrfopt_obj)
Calls a function for each element in an array. Skips holes in the array. See http://tinyurl.com/developer-mozilla-org-array-foreach
Arguments:
arr : Array.<T> | goog.array.ArrayLike
Array or array like object over which to iterate.
f : ??function(this: S, T, number, ?):
The function to call for every element. This function takes 3 arguments (the element, the index and the array). The return value is ignored.
opt_obj : S=
The object to be used as the value of 'this' within f.
code »
goog.array.forEachRight(arrfopt_obj)
Calls a function for each element in an array, starting from the last element rather than the first.
Arguments:
arr : Array.<T> | goog.array.ArrayLike
Array or array like object over which to iterate.
f : ??function(this: S, T, number, ?):
The function to call for every element. This function takes 3 arguments (the element, the index and the array). The return value is ignored.
opt_obj : S=
The object to be used as the value of 'this' within f.
code »
goog.array.indexOf(arrobjopt_fromIndex) number
Returns the index of the first element of an array with a specified value, or -1 if the element is not present in the array. See http://tinyurl.com/developer-mozilla-org-array-indexof
Arguments:
arr : Array.<T> | goog.array.ArrayLike
The array to be searched.
obj : T
The object for which we are searching.
opt_fromIndex : number=
The index at which to start the search. If omitted the search starts at index 0.
Returns: number  The index of the first matching array element.
code »
goog.array.insert(arrobj)
Pushes an item into an array, if it's not already in the array.
Arguments:
arr : Array.<T>
Array into which to insert the item.
obj : T
Value to add.
code »
goog.array.insertArrayAt(arrelementsToAddopt_i)
Inserts at the given index of the array, all elements of another array.
Arguments:
arr : goog.array.ArrayLike
The array to modify.
elementsToAdd : goog.array.ArrayLike
The array of elements to add.
opt_i : number=
The index at which to insert the object. If omitted, treated as 0. A negative index is counted from the end of the array.
code »
goog.array.insertAt(arrobjopt_i)
Inserts an object at the given index of the array.
Arguments:
arr : goog.array.ArrayLike
The array to modify.
obj : *
The object to insert.
opt_i : number=
The index at which to insert the object. If omitted, treated as 0. A negative index is counted from the end of the array.
code »
goog.array.insertBefore(arrobjopt_obj2)
Inserts an object into an array before a specified object.
Arguments:
arr : Array.<T>
The array to modify.
obj : T
The object to insert.
opt_obj2 : T=
The object before which obj should be inserted. If obj2 is omitted or not found, obj is inserted at the end of the array.
code »
goog.array.isEmpty(arr) boolean
Whether the array is empty.
Arguments:
arr : goog.array.ArrayLike
The array to test.
Returns: boolean  true if empty.
code »
goog.array.isSorted(arropt_compareFnopt_strict) boolean
Tells if the array is sorted.
Arguments:
arr : !Array.<T>
The array.
opt_compareFn : ?function(T,T):number=
Function to compare the array elements. Should take 2 arguments to compare, and return a negative number, zero, or a positive number depending on whether the first argument is less than, equal to, or greater than the second.
opt_strict : boolean=
If true no equal elements are allowed.
Returns: boolean  Whether the array is sorted.
code »
goog.array.join(var_args) !Array.<T>
Returns a new array that contains the contents of all the arrays passed.
Arguments:
var_args : ...!Array.<T>
No description.
Returns: !Array.<TNo description.
code »
goog.array.last(array) T
Returns the last element in an array without removing it. Same as goog.array.peek.
Arguments:
array : Array.<T> | goog.array.ArrayLike
The array.
Returns: T  Last item in array.
code »
goog.array.lastIndexOf(arrobjopt_fromIndex) number
Returns the index of the last element of an array with a specified value, or -1 if the element is not present in the array. See http://tinyurl.com/developer-mozilla-org-array-lastindexof
Arguments:
arr : !Array.<T> | !goog.array.ArrayLike
The array to be searched.
obj : T
The object for which we are searching.
opt_fromIndex : ?number=
The index at which to start the search. If omitted the search starts at the end of the array.
Returns: number  The index of the last matching array element.
code »
goog.array.map(arrfopt_obj) !Array.<RESULT>
Calls a function for each element in an array and inserts the result into a new array. See http://tinyurl.com/developer-mozilla-org-array-map
Arguments:
arr : Array.<VALUE> | goog.array.ArrayLike
Array or array like object over which to iterate.
f : function(this:THIS, VALUE, number, ?): RESULT
The function to call for every element. This function takes 3 arguments (the element, the index and the array) and should return something. The result will be inserted into a new array.
opt_obj : THIS=
The object to be used as the value of 'this' within f.
Returns: !Array.<RESULT>  a new array with the results from f.
code »
goog.array.moveItem(fromIndextoIndex)
Moves one item of an array to a new position keeping the order of the rest of the items. Example use case: keeping a list of JavaScript objects synchronized with the corresponding list of DOM elements after one of the elements has been dragged to a new position.
Arguments:
: !(Array | Arguments | {length:number
No description.
fromIndex : number
Index of the item to move between 0 and arr.length - 1.
toIndex : number
Target index between 0 and arr.length - 1.
code »
goog.array.peek(array) T
Returns the last element in an array without removing it. Same as goog.array.last.
Arguments:
array : Array.<T> | goog.array.ArrayLike
The array.
Returns: T  Last item in array.
code »
goog.array.range(startOrEndopt_endopt_step) !Array.<number>
Creates a range of numbers in an arithmetic progression. Range takes 1, 2, or 3 arguments:
range(5) is the same as range(0, 5, 1) and produces [0, 1, 2, 3, 4]
range(2, 5) is the same as range(2, 5, 1) and produces [2, 3, 4]
range(-2, -5, -1) produces [-2, -3, -4]
range(-2, -5, 1) produces [], since stepping by 1 wouldn't ever reach -5.
Arguments:
startOrEnd : number
The starting value of the range if an end argument is provided. Otherwise, the start value is 0, and this is the end value.
opt_end : number=
The optional end value of the range.
opt_step : number=
The step size between range values. Defaults to 1 if opt_step is undefined or 0.
Returns: !Array.<number>  An array of numbers for the requested range. May be an empty array if adding the step would not converge toward the end value.
code »
goog.array.reduce(arrfvalopt_obj) R
Passes every element of an array into a function and accumulates the result. See http://tinyurl.com/developer-mozilla-org-array-reduce For example: var a = [1, 2, 3, 4]; goog.array.reduce(a, function(r, v, i, arr) {return r + v;}, 0); returns 10
Arguments:
arr : Array.<T> | goog.array.ArrayLike
Array or array like object over which to iterate.
f : ?function(this:S, R, T, number, ?) : R
The function to call for every element. This function takes 4 arguments (the function's previous result or the initial value, the value of the current array element, the current array index, and the array itself) function(previousValue, currentValue, index, array).
val : ?
The initial value to pass into the function on the first call.
opt_obj : S=
The object to be used as the value of 'this' within f.
Returns: R  Result of evaluating f repeatedly across the values of the array.
code »
goog.array.reduceRight(arrfvalopt_obj) R
Passes every element of an array into a function and accumulates the result, starting from the last element and working towards the first. See http://tinyurl.com/developer-mozilla-org-array-reduceright For example: var a = ['a', 'b', 'c']; goog.array.reduceRight(a, function(r, v, i, arr) {return r + v;}, ''); returns 'cba'
Arguments:
arr : Array.<T> | goog.array.ArrayLike
Array or array like object over which to iterate.
f : ?function(this:S, R, T, number, ?) : R
The function to call for every element. This function takes 4 arguments (the function's previous result or the initial value, the value of the current array element, the current array index, and the array itself) function(previousValue, currentValue, index, array).
val : ?
The initial value to pass into the function on the first call.
opt_obj : S=
The object to be used as the value of 'this' within f.
Returns: R  Object returned as a result of evaluating f repeatedly across the values of the array.
code »
goog.array.remove(arrobj) boolean
Removes the first occurrence of a particular value from an array.
Arguments:
arr : Array.<T> | goog.array.ArrayLike
Array from which to remove value.
obj : T
Object to remove.
Returns: boolean  True if an element was removed.
code »
goog.array.removeAt(arri) boolean
Removes from an array the element at index i
Arguments:
arr : goog.array.ArrayLike
Array or array like object from which to remove value.
i : number
The index to remove.
Returns: boolean  True if an element was removed.
code »
goog.array.removeDuplicates(arropt_rvopt_hashFn)
Removes all duplicates from an array (retaining only the first occurrence of each array element). This function modifies the array in place and doesn't change the order of the non-duplicate items. For objects, duplicates are identified as having the same unique ID as defined by goog.getUid. Alternatively you can specify a custom hash function that returns a unique value for each item in the array it should consider unique. Runtime: N, Worstcase space: 2N (no dupes)
Arguments:
arr : Array.<T> | goog.array.ArrayLike
The array from which to remove duplicates.
opt_rv : Array=
An optional array in which to return the results, instead of performing the removal inplace. If specified, the original array will remain unchanged.
opt_hashFn : function(T):string=
An optional function to use to apply to every item in the array. This function should return a unique value for each item in the array it should consider unique.
code »
goog.array.removeIf(arrfopt_obj) boolean
Removes the first value that satisfies the given condition.
Arguments:
arr : Array.<T> | goog.array.ArrayLike
Array or array like object over which to iterate.
f : ?function(this:S, T, number, ?) : boolean
The function to call for every element. This function takes 3 arguments (the element, the index and the array) and should return a boolean.
opt_obj : S=
An optional "this" context for the function.
Returns: boolean  True if an element was removed.
code »
goog.array.repeat(valuen) !Array.<VALUE>
Returns an array consisting of the given value repeated N times.
Arguments:
value : VALUE
The value to repeat.
n : number
The repeat count.
Returns: !Array.<VALUE>  An array with the repeated value.
code »
goog.array.rotate(arrayn) !Array.<T>
Rotates an array in-place. After calling this method, the element at index i will be the element previously at index (i - n) % array.length, for all values of i between 0 and array.length - 1, inclusive. For example, suppose list comprises [t, a, n, k, s]. After invoking rotate(array, 1) (or rotate(array, -4)), array will comprise [s, t, a, n, k].
Arguments:
array : !Array.<T>
The array to rotate.
n : number
The amount to rotate.
Returns: !Array.<T>  The array.
code »
goog.array.shuffle(arropt_randFn)
Shuffles the values in the specified array using the Fisher-Yates in-place shuffle (also known as the Knuth Shuffle). By default, calls Math.random() and so resets the state of that random number generator. Similarly, may reset the state of the any other specified random number generator. Runtime: O(n)
Arguments:
arr : !Array
The array to be shuffled.
opt_randFn : function():number=
Optional random function to use for shuffling. Takes no arguments, and returns a random number on the interval [0, 1). Defaults to Math.random() using JavaScript's built-in Math library.
code »
goog.array.slice(arrstartopt_end) !Array.<T>
Returns a new array from a segment of an array. This is a generic version of Array slice. This means that it might work on other objects similar to arrays, such as the arguments object.
Arguments:
arr : Array.<T> | goog.array.ArrayLike
The array from which to copy a segment.
start : number
The index of the first element to copy.
opt_end : number=
The index after the last element to copy.
Returns: !Array.<T>  A new array containing the specified segment of the original array.
code »
goog.array.some(arrfopt_obj) boolean
Calls f for each element of an array. If any call returns true, some() returns true (without checking the remaining elements). If all calls return false, some() returns false. See http://tinyurl.com/developer-mozilla-org-array-some
Arguments:
arr : Array.<T> | goog.array.ArrayLike
Array or array like object over which to iterate.
f : ?function(this:S, T, number, ?) : boolean
The function to call for for every element. This function takes 3 arguments (the element, the index and the array) and should return a boolean.
opt_obj : S=
The object to be used as the value of 'this' within f.
Returns: boolean  true if any element passes the test.
code »
goog.array.sort(arropt_compareFn)
Sorts the specified array into ascending order. If no opt_compareFn is specified, elements are compared using goog.array.defaultCompare, which compares the elements using the built in < and > operators. This will produce the expected behavior for homogeneous arrays of String(s) and Number(s), unlike the native sort, but will give unpredictable results for heterogenous lists of strings and numbers with different numbers of digits. This sort is not guaranteed to be stable. Runtime: Same as Array.prototype.sort
Arguments:
arr : Array.<T>
The array to be sorted.
opt_compareFn : ?function(T,T):number=
Optional comparison function by which the array is to be ordered. Should take 2 arguments to compare, and return a negative number, zero, or a positive number depending on whether the first argument is less than, equal to, or greater than the second.
code »
goog.array.sortObjectsByKey(arrkeyopt_compareFn)
Sorts an array of objects by the specified object key and compare function. If no compare function is provided, the key values are compared in ascending order using goog.array.defaultCompare. This won't work for keys that get renamed by the compiler. So use {'foo': 1, 'bar': 2} rather than {foo: 1, bar: 2}.
Arguments:
arr : Array.<Object>
An array of objects to sort.
key : string
The object key to sort by.
opt_compareFn : Function=
The function to use to compare key values.
code »
goog.array.splice(arrindexhowManyvar_args) !Array.<T>
Adds or removes elements from an array. This is a generic version of Array splice. This means that it might work on other objects similar to arrays, such as the arguments object.
Arguments:
arr : Array.<T> | goog.array.ArrayLike
The array to modify.
index : number | undefined
The index at which to start changing the array. If not defined, treated as 0.
howMany : number
How many elements to remove (0 means no removal. A value below 0 is treated as zero and so is any other non number. Numbers are floored).
var_args : ...T
Optional, additional elements to insert into the array.
Returns: !Array.<T>  the removed elements.
code »
goog.array.stableSort(arropt_compareFn)
Sorts the specified array into ascending order in a stable way. If no opt_compareFn is specified, elements are compared using goog.array.defaultCompare, which compares the elements using the built in < and > operators. This will produce the expected behavior for homogeneous arrays of String(s) and Number(s). Runtime: Same as Array.prototype.sort, plus an additional O(n) overhead of copying the array twice.
Arguments:
arr : Array.<T>
The array to be sorted.
opt_compareFn : ?function(T, T): number=
Optional comparison function by which the array is to be ordered. Should take 2 arguments to compare, and return a negative number, zero, or a positive number depending on whether the first argument is less than, equal to, or greater than the second.
code »
goog.array.toArray(object) !Array.<T>
Converts an object to an array.
Arguments:
object : Array.<T> | goog.array.ArrayLike
The object to convert to an array.
Returns: !Array.<T>  The object converted into an array. If object has a length property, every property indexed with a non-negative number less than length will be included in the result. If object does not have a length property, an empty array will be returned.
code »
goog.array.toObject(arrkeyFuncopt_obj) !Object.<T>
Creates a new object built from the provided array and the key-generation function.
Arguments:
arr : Array.<T> | goog.array.ArrayLike
Array or array like object over which to iterate whose elements will be the values in the new object.
keyFunc : ?function(this:S, T, number, ?) : string
The function to call for every element. This function takes 3 arguments (the element, the index and the array) and should return a string that will be used as the key for the element in the new object. If the function returns the same key for more than one element, the value for that key is implementation-defined.
opt_obj : S=
The object to be used as the value of 'this' within keyFunc.
Returns: !Object.<T>  The new object.
code »
goog.array.zip(var_args) !Array.<!Array>
Creates a new array for which the element at position i is an array of the ith element of the provided arrays. The returned array will only be as long as the shortest array provided; additional values are ignored. For example, the result of zipping [1, 2] and [3, 4, 5] is [[1,3], [2, 4]]. This is similar to the zip() function in Python. See http://docs.python.org/library/functions.html#zip
Arguments:
var_args : ...!goog.array.ArrayLike
Arrays to be combined.
Returns: !Array.<!Array>  A new array of arrays created from provided arrays.
code »

Global Properties

goog.array.ARRAY_PROTOTYPE_ :
Reference to the original Array.prototype.
Code »
goog.array.ASSUME_NATIVE_FUNCTIONS :
No description.
Code »
goog.array.ArrayLike :
No description.
Code »

Package array

Package Reference