1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
/* __ *\
** ________ ___ / / ___ __ ____ Scala.js API **
** / __/ __// _ | / / / _ | __ / // __/ (c) 2013, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ |/_// /_\ \ http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | |__/ /____/ **
** |/____/ **
\* */
/**
* All doc-comments marked as "MDN" are by Mozilla Contributors,
* distributed under the Creative Commons Attribution-ShareAlike license from
* https://developer.mozilla.org/en-US/docs/Web/Reference/API
*/
package scala.scalajs.js
import annotation._
/**
* Arrays are list-like objects whose prototype has methods to perform
* traversal and mutation operations. Neither the length of a JavaScript
* array nor the types of its elements are fixed. Since an array's size
* length grow or shrink at any time, JavaScript arrays are not guaranteed
* to be dense. In general, these are convenient characteristics; but if
* these features are not desirable for your particular use, you might
* consider using typed arrays.
*
* MDN
*
* To construct a new array with uninitialized elements, use the constructor
* of this class. To construct a new array with specified elements, as if
* you used the array literal syntax in JavaScript, use the
* [[Array$.apply Array.apply]] method instead.
*
* @tparam A Type of the elements of the array
*
* @constructor Creates a new array of length 0.
*/
class Array[A] extends Object {
/** Creates a new array with the given length.
* @param arrayLength Initial length of the array.
*/
def this(arrayLength: Int) = this()
// Do not expose this one - use js.Array(item1, item2, ...) instead
// def this(items: A*) = this()
/** Length of the array. */
def length: Int = native
/** Sets the length of the array.
* If the new length is bigger than the old length, created slots are
* filled with `undefined` (irrespective of the type argument `A`!).
* If the new length is smaller than the old length, the array is shrunk.
*/
def length_=(v: Int): Unit = native
/** Access the element at the given index. */
@JSBracketAccess
def apply(index: Int): A = native
/** Set the element at the given index. */
@JSBracketAccess
def update(index: Int, value: A): Unit = native
/**
* concat creates a new array consisting of the elements in the this object
* on which it is called, followed in order by, for each argument, the
* elements of that argument (if the argument is an array) or the argument
* itself (if the argument is not an array).
*
* MDN
*/
def concat[B >: A](items: Array[_ <: B]*): Array[B] = native
/**
* The join() method joins all elements of an array into a string.
*
* separator Specifies a string to separate each element of the array.
* The separator is converted to a string if necessary. If omitted, the
* array elements are separated with a comma.
*/
def join(seperator: String = ","): String = native
/**
* The pop() method removes the last element from an array and returns that
* element.
*
* MDN
*/
def pop(): A = native
/**
* The push() method mutates an array by appending the given elements and
* returning the new length of the array.
*
* MDN
*/
def push(items: A*): Int = native
/**
* The reverse() method reverses an array in place. The first array element
* becomes the last and the last becomes the first.
*
* MDN
*/
@JSName("reverse")
def reverseInPlace(): Array[A] = native
/**
* The shift() method removes the first element from an array and returns that
* element. This method changes the length of the array.
*
* MDN
*/
def shift(): A = native
/**
* The slice() method returns a shallow copy of a portion of an array.
*
* MDN
*/
@JSName("slice")
def jsSlice(start: Int = 0, end: Int = Int.MaxValue): Array[A] = native
/**
* The sort() method sorts the elements of an array in place and returns the
* array. The sort is not necessarily stable. The default sort order is
* lexicographic (not numeric).
*
* If compareFunction is not supplied, elements are sorted by converting them
* to strings and comparing strings in lexicographic ("dictionary" or "telephone
* book," not numerical) order. For example, "80" comes before "9" in
* lexicographic order, but in a numeric sort 9 comes before 80.
*
* MDN
*/
def sort(compareFn: Function2[A, A, Int] = ???): Array[A] = native
/** Removes and adds new elements at a given index in the array.
*
* This method first removes `deleteCount` elements starting from the index
* `index`, then inserts the new elements `items` at that index.
*
* If `index` is negative, it is treated as that number of elements starting
* from the end of the array.
*
* @param index Index where to start changes
* @param deleteCount Number of elements to delete from index
* @param items Elements to insert at index
* @return An array of the elements that were deleted
*/
def splice(index: Int, deleteCount: Int, items: A*): Array[A] = native
/**
* The unshift() method adds one or more elements to the beginning of an array
* and returns the new length of the array.
*
* MDN
*/
def unshift(items: A*): Int = native
}
/** Factory for [[js.Array]] objects. */
object Array extends Object {
// Do not expose this one - use new Array(len) instead
// def apply[A](arrayLength: Int): Array[A] = native
/** Creates a new array with the given items. */
def apply[A](items: A*): Array[A] = sys.error("stub")
/** Returns true if the given value is an array. */
def isArray(arg: Any): Boolean = native
}
|
