`deleteCount` param to `splice()` is not optional in es5 types

[tjenkinson]

TypeScript Version: 3.5.1

Search Terms: splice deleteCount

Code
Set the target to ES5 then

[1, 2, 3].splice(0); // should error. deleteCount missing
[1, 2, 3].splice(0, 3); // ok

Expected behavior:
[1, 2, 3].splice(0); not allowed

Actual behavior:
[1, 2, 3].splice(0); allowed

Playground Link: this

deleteCount only become optional in ES6

ES5: https://www.ecma-international.org/ecma-262/5.1/#sec-15.4.4.12
ES6: https://www.ecma-international.org/ecma-262/6.0/#sec-array.prototype.splice

[AnyhowStep]

ES5 Array.prototype.splice (start, deleteCount, ...

7. Let actualDeleteCount be min(max(ToInteger(deleteCount),0), len – actualStart).

ToInteger

1. Let number be the result of calling ToNumber on the input argument.

ToNumber

Argument Type	Result
Undefined	NaN

ToInteger

2. If number is NaN, return +0.

---

max(ToInteger(undefined),0) is just max(+0, 0) is just zero

[RyanCavanaugh]

Unless I'm confused about something, the function's behavior is well-predictable when given one argument.

The spec is not authoritative as to argument optionality since it's not a well-defined concept in JS and ToInteger(undefined) gives 0 which is a good default argument in many cases.

For example Number.prototype.toFixed lists its argument as required, but TypeScript doesn't enforce this because (0).toFixed() is a well-formed and predictable result. Same for String.prototype.slice - its arguments are both listed as "required" but has predictable and expected behavior with one.

[tjenkinson]

Hmm interesting. The reason I opened this is because we had a .splice(0), and then our app broke in an old version of opera because there the second argument defaulted to 0 (correctly for es5) instead of the array length (explicit in es6).

The issue is the default value essentially changed between es5 and es6.

Given the the default becomes something else in es6, and the param is not marked as optional in es5, do you think it makes sense for there to be an exception in this case?

It's not safe to omit deleteCount unless you know for sure what environment you are running in.

[fatcerberus]

The wording used in the spec is interesting:

When the splice method is called with two or more arguments [...]

Based on this, and the fact that the behavior changed between ES5 and ES6 (despite "don't break the web" being the unofficial ES motto), the default value of 0 therefore seems to just be an accident of the integer coercion rules and not directly intended in the design. It definitely seems like the older spec wants to treat the second parameter as required, at any rate.

That said, even with the reasoning above, the fact that in practice there is a "default" and it isn't consistent between ES5 and ES6 is quite frustrating.

[AnyhowStep]

Yeah, after reading more, it seems like making the 2nd arg required for ES5 and optional for ES6 would be better in this particular case.

I don't think I've ever called splice without a second arg, though, because it's not very useful.

---

The ES6 spec explicitly mentions behaviour for 1 Arg being passed,

9. Else if the number of actual arguments is 1, then
   Let insertCount be 0.
   Let actualDeleteCount be len – actualStart

---

But it seems like the ES5 spec is hinting that if called with zero or one Arg, then the behavior is more or less undefined, even if the algorithm outlined defines a behavior

[RyanCavanaugh]

OK, that sounds pretty annoying. Accepting PRs

[RyanCavanaugh]

Thanks for the feedback on this BTW. When/if someone submits a PR it'd be nice if this issue had a clear and concrete description of what happens in ES5 vs ES6 with the various argument counts.

[tjenkinson]

Awesome. I will put together a PR.

I know I have used splice(0) several times in the past. It would have been great to have typescript flag it then :)

[AnyhowStep]

I think this is what happens.

Maybe someone can correct me if I made a mistake.

ES	array.splice()	array.splice(start)
ES5	(0, 0)	(start, 0)
ES6	(0, array.length)	(start, array.length-actualStart) *

---

From this, the actualStart is computed,

5. Let relativeStart be ToInteger(start).
6. ReturnIfAbrupt(relativeStart).
7. If relativeStart < 0, let actualStart be max((len + relativeStart),0); else let actualStart be min(relativeStart, len).