Types primitifs Typescript: une différence entre les types «nombre» et «nombre» (TSC est-il insensible à la casse)?

Je voulais écrire un paramètre de type number, mais j'ai mal orthographié le type, en écrivant à la Numberplace.

Sur mon IDE (JetBrains WebStorm), le type Numberest écrit avec la même couleur que celle utilisée pour le type primitif number, tandis que si j'écris le nom d'une classe (connue ou inconnue), il utilise une couleur différente, donc je suppose qu'il reconnaît d'une manière ou d'une autre le type mal orthographié comme un type correct / presque correct / en quelque sorte correct.

Lorsque je compile le code, au lieu de me plaindre par exemple que le compilateur n'a pas trouvé de classe nommée Number, TSC écrit ce message d'erreur:

Illegal property access

Est - ce que cela signifie que numberet Numbertant coexiste que différents types?

Si cela est vrai, quelle est la différence entre ces classes?

Si ce n'est pas le cas, alors pourquoi il n'a tout simplement pas écrit le même message d'erreur qu'il affiche pour les classes inconnues ("Le nom 'Number' n'existe pas dans la portée actuelle")

Voici le code:

class Test
{
    private myArray:string[] = ["Jack", "Jill", "John", "Joe", "Jeff"];

    // THIS WORKS
    public getValue(index:number):string
    {
        return this.myArray[index];
    }

    // THIS DOESN'T WORK: ILLEGAL PROPERTY ACCESS
    public getAnotherValue(index:Number):string
    {
        return this.myArray[index]; 
    }
}

JavaScript a la notion de types primitifs (nombre, chaîne, etc.) et de types d' objet (nombre, chaîne, etc., qui se manifestent à l'exécution). TypeScript numberet y Numberfaire référence, respectivement. JavaScript contraindra généralement un type d'objet à son équivalent primitif, ou vice versa:

var x = new Number(34);
> undefined
x
> Number {}
x + 1
> 35

Les règles du système de type TypeScript traitent ceci (spec section 3.7) comme ceci:

Aux fins de la détermination des relations de compatibilité de sous-type, de supertype et d'affectation, les types primitifs Number, Boolean et String sont traités comme des types d'objet avec les mêmes propriétés que les interfaces «Number», «Boolean» et «String» respectivement.

Pour augmenter la réponse de Ryan avec les conseils des choses à faire et à ne pas faire de TypeScript :

Ne jamais utiliser les types Number, String, Boolean, Symbol, ou Objectces types font référence à des objets non primitifs en boîte qui sont presque jamais utilisés de façon appropriée dans le code JavaScript.

/* WRONG */
function reverse(s: String): String;

N'utiliser les types number, string, booleanet symbol.

/* OK */
function reverse(s: string): string;

Comme le dit le document TypeScript:

var Number: NumberConstructor
(value?: any) => number

Un objet qui représente un nombre de n'importe quel type. Tous les nombres JavaScript sont des nombres à virgule flottante 64 bits.

Comme il dit, prenez anycomme paramètre et retournez le numéro ounull

Cela donne un moyen facile de vérifier qu'une valeur est un nombre ou non

Number("1234");   // 1234
Number("1234.54") // 1234.54
Number("-1234.54") // -1234.54
Number("1234.54.33") // null
Number("any-non-numeric") // null

Nous pouvons donc simplement utiliser pour vérifier le numéro, comme:

if(Number(val)){
   console.log('val is a number');
} else {
   console.log('Not a number');
}