Je regarde ce code:

/**
 * Bitmask of states
 */
export const enum ViewState {
    FirstCheck = 1 << 0,      // result is 1
    ChecksEnabled = 1 << 1,   // result is 2
    Errored = 1 << 2,         // result is 4
    Destroyed = 1 << 3        // result is 8
}

Je ne comprends pas pourquoi ne pas simplement spécifier les résultats entiers ou les nombres entiers 0,1,2,3. Est-ce que quelqu'un a une idée?

2
Max Koretskyi 1 avril 2017 à 13:22

2 réponses

Meilleure réponse

Parce que c'est plus facile à lire (c'est pour moi en tout cas et apparemment pour l'auteur aussi). Au fur et à mesure que cette liste grandit, il est beaucoup plus facile (pour un humain) d'ajouter un 16e élément et d'utiliser 1 << 15, puis de déterminer la valeur résultante. Donc juste une question de préférence

La raison de l'utilisation des décalages est que vous pouvez combiner plusieurs états en une seule valeur. Exemple: une valeur de 6 serait Errored et ChecksEnabled.

var combined = ViewState.ChecksEnabled | ViewState.Errored;

var isChecksEnabled = (combined & ViewState.ChecksEnabled) == ViewState.ChecksEnabled;
// or
var isChecksEnabled = !!(combined & ViewState.ChecksEnabled);
5
Igor 1 avril 2017 à 10:32

Cette énumération modélise l'idée de quatre indicateurs, chacun pouvant être soit on / true / one, soit off / false / zero. Vous pouvez définir l'énumération sur une valeur en combinant logiquement les valeurs souhaitées. Par exemple:

z = ViewState.FirstCheck | ViewState.ChecksEnabled

Plus tard dans le code, vous pouvez vérifier ces valeurs indépendamment les unes des autres par ET logique dans la valeur avec celle que vous souhaitez vérifier:

if (z & ViewState.FirstCheck) {
  do_something();
}

if (z & ViewState.ChecksEnabled) {
  do_something_else();
}

Le moyen le plus simple de vous assurer que vous pouvez décomposer la valeur d'énumération en un ensemble d'indicateurs distinct et sans ambiguïté consiste à utiliser les valeurs séparées en tant que puissances de deux.

3
Tim 1 avril 2017 à 10:36