When utilizing the [] operator, what should be the type? For example, a[10]?
In the realm of JavaScript (and consequently TypeScript), objects can possess properties with numeric values as their name, like so:
{
1: 'Apples',
2: 'Oranges'
}
This is essentially equivalent to:
{
'1': 'Apples',
'2': 'Oranges'
}
The term used for naming a property is also referred to as a key.
From my interpretation, an index type resembles an array (which is similar to an object in JavaScript).
It's crucial to note that just because an object contains numeric keys, it does not automatically categorize it as an array:
var arr = ['Apples', 'Oranges'];
console.log(arr.constructor); // logs 'function Array() { ... }'
console.log(arr[1]); // logs 'Apples'
var obj = { 1: 'Apples', 2: 'Oranges' };
console.log(obj.constructor); // logs 'function Object() { ... }'
console.log(obj[1]); // logs 'Apples'
console.log(obj['1']); // logs 'Apples'
That being said, the interface called NotOkay delineates objects that are capable of having both numerical and non-numerical keys. How these keys are accessed remains unrestricted by interfaces.
I find the definition of index type perplexing.
Indeed, the mention in the TypeScript handbook you made about indexing with a 'string' sometimes returning a Dog alludes to the ambiguity stemming from the flexible syntax for accessors expounded upon earlier. It would be quite confusing to have an object where numeric keys grant access to one type while non-numeric keys yield another type.
To ensure clarity: If the example were slightly altered, no errors would persist within the interface anymore:
class Animal {
name: string;
}
class Dog extends Animal {
//breed: string; <-- Dog and Animal now share the same interface
}
// No error due to Dog and Animal sharing the same interface:
interface Okay {
[a: number]: Animal;
[x: string]: Dog;
}
(TypeScript playground)
This instance holds up well, thanks to TypeScript employing a structural type system:
Type compatibility in TypeScript revolves around structural subtyping.
Structural typing establishes type relations solely based on their members, differing from nominal typing. more...
Hoping this elucidation proves beneficial to you.