Pourquoi l'opérateur && produire le type du second opérande

Question

Pourquoi l'opérateur && produire le type du second opérande

voix

24

La spécification dactylographiée en §4.15.6 sur l' &&opérateur:

L'opérateur && permet opérandes d'être de tout type et produit un résultat du même type que le second opérande .

En Javascript, l' &&opérateur retourne le premier opérande si elle est falsy, sinon il retourne le deuxième opérande ( voir ECMA-262 §11.11 ).

Cela signifie que si l'opérande gauche est falsy, &&renvoie une valeur qui correspond au type de l'opérande gauche. Par exemple,

typeof ( false && {}      ) === boolean // true
typeof ( ''    && 1       ) === string  // true
typeof ( null  && hello ) === object  // true
typeof ( NaN   && true    ) === number  // true

Tapuscrit, selon la règle citée ci - dessus, ne serait pas correctement prédire les types des expressions ci - dessus sont Object, Number, Stringet Boolean, respectivement.

Est-ce que je manque quelque chose? Y at - il une bonne raison de faire le type d'une &&expression correspond au type du second opérande? Ne doit pas le type de résultat se comportent comme l' ||opérateur, et le retour le meilleur type commun des deux opérandes, et Anys'il n'y a pas de type le plus commun?

types typescript

Créé 02/10/2012 à 16:50
source utilisateur Peter Olson

Dans d'autres langues...

1 réponses

Ryan Cavanaugh · Accepted Answer · 2012-10-02 17:55

Longue histoire courte, il n'y a pas de solution ici qui plaît à tout le monde.

Considérez cet idiome commun:

var customer = GetCustomer(...); // of type 'Customer'
var address = customer && customer.address;
if(address) {
    printAddressLabel(address); // Signature: (Address) => void
} else {
    // Couldn't find the customer or the customer has no address on file
}

Ce serait assez boiteux d'abandonner et de décider que « adresse » est « tout » parce qu'il n'y a pas de meilleur type commun entre le client et adresse.

Dans la majorité des cas où l'opérateur && est utilisé, que ce soit les types déjà correspondent ou && est utilisé d'une manière de valeur comme ci - dessus coalescent. Dans les deux cas, le retour du type de l'opérande de droite donne à l'utilisateur le type attendu.

Bien que la sécurité de type est la rupture technique vers le bas à ce point, qu'il fait pas d'une manière qui est susceptible d'entraîner une erreur. Soit vous allez tester la valeur résultante pour truthiness (dans ce cas, le type est plus ou moins hors de propos), ou que vous allez utiliser l'opérande présomptif droit pour une opération (l'exemple ci-dessus à faire les deux).

Si nous regardons les exemples que vous avez énumérés et feignons l'opérande gauche est une période indéterminée truthy ou falsy et essayez d'écrire du code sain d' esprit qui fonctionnerait sur la valeur de retour, il devient beaucoup plus clair - il est tout simplement pas que vous pouvez faire avec « false && {} » qui va pas déjà dans une « toute position » argument ou test truthiness.

Addenda

Étant donné que certaines personnes ne sont pas convaincus par ce qui précède, voici une explication différente.

Imaginons un instant que le système de type dactylographiée a ajouté trois nouveaux types: Truthy<T>, Falsy<T>et Maybe<T>, ce qui représente des valeurs possibles truthy / falsy de type T. Les règles de ces types sont les suivants:

Truthy<T> se comporte exactement comme T
Vous ne pouvez pas accéder à toutes les propriétés de Falsy<T>
Une expression de type Maybe<T>, lorsqu'il est utilisé en tant que condition dans un ifbloc, elle devient un Truthy<T>dans le corps de ce même ifbloc et Falsy<T>dans le elsebloc

Cela vous permettra de faire des choses comme ceci:

function fn(x: Maybe<Customer>) {
   if(x) {
      console.log(x.address); // OK
   } else {
      console.log(x.phone); // Error: x is definitely falsy
   }
   console.log(x.name); // Warning: x might be falsy!
}

Très bon jusqu'à présent. Maintenant, nous pouvons comprendre ce que les règles de type sont pour l'opérateur &&.

Truthy<T> && x devrait être une erreur - si le côté gauche est connu pour être truthy, vous devriez venez d'écrire x
Falsy<T> && xdevrait être une erreur - si le côté gauche est connu pour être falsy, xest le code inaccessible
Maybe<T> && x devrait produire ... quoi?

Nous savons que le résultat de Maybe<T> && xsera soit une valeur falsy de type T, ou x. Il ne peut pas produire Truthy<T>( à moins T== le type de xdans ce cas , toute cette discussion est sans objet). Appelons ce nouveau type Falsy<T> XOR Maybe.

Quelles devraient être les règles d' Falsy<T> XOR Maybeêtre?

De toute évidence, vous ne pouvez pas utiliser les propriétés de Tdessus. Si la valeur est de type T, il est falsy, et non sécuritaire.
Vous devriez pouvoir l' utiliser comme Maybe, depuis Falsy<T>et Falsyont les mêmes comportements
Vous ne devriez pas être en mesure d'utiliser les propriétés de U, parce que la valeur pourrait encore être falsy.
Si vous l' utilisez dans un iftest, il devrait devenir Truthydans le bloc de cette ifdéclaration

En d' autres termes, Falsy<T> XOR Maybe est Maybe . Il suit toutes les mêmes règles. Vous n'avez pas besoin de compliquer le système de type tout ici en ajoutant ce bizarre XORtype car un type qui convient à toutes les spécifications dont vous avez besoin existe déjà.

Ceci est un peu comme donner à quelqu'un une boîte et en disant « Ceci est soit une boîte vide d'ordures, ou une boîte pleine de matières recyclables ». Vous pouvez en toute sécurité vider le contenu de la boîte dans le bac de recyclage.