When expecting a positive integer...
domenic at domenicdenicola.com
Mon Apr 8 23:05:33 PDT 2013
I notice that operations accepting positive integers do various somewhat-inconsistent things as of the latest ES6 spec:
Various typed array things do `ToPositiveInteger`, a new operation as of ES6:
- `ArrayBuffer(length)` and `TypedArray(length)`
- Constructing a typed array, and `TypedArray.prototype.set`, coerce both the passed object's `length` property and the numeric byte-offset argument
- Most interestingly, `TypedArray.prototype.@@elementGet(index)` and `@@elementSet(index, value)` do a `ToPositiveInteger` on `index`. So `typedArray[-123] === typedArray`, and `typedArray[-321] = 5` gives `typedArray === 5`.
Whereas arrays use `ToUint32`, but sometimes throw `RangeError`s:
- Indices generally "work" if `ToString(ToUint32(index)) !== index`; otherwise they're treated as ordinary properties.
- When getting a length from any array-like, you just do `ToUint32` on it.
- But when setting a length, you validate so that if `ToUint32(length) !== length`, a `RangeError` is thrown.
Finally, one lone place throws `RangeError`s after conversion:
- `String.prototype.repeat(count)` throws if `ToInteger(count)` is negative or infinite.
I was curious if there were any interesting rationales driving these decisions. (And I fully appreciate there might not be; it could just be compatibility constraints.) Or, to put it another way, I was curious what would be considered "idiomatic" JS, e.g. in the same way that the spec sets a precedent of `ToString`-ing all string inputs to its functions.
More information about the es-discuss