web-dev-qa-db-fra.com

Comment vérifier si l'objet est immuable?

Un objet immuable peut être une instance de:

  • Immutable.List
  • Immutable.Map
  • Immutable.OrderedMap
  • Immutable.Set
  • Immutable.OrderedSet
  • Immutable.Stack
immutable.js
41
Gajus

Il existe un ticket ouvert pour améliorer l'API qui est sur la feuille de route pour 4.0. Jusqu'à ce que ceci soit implémenté, je vous suggère d'utiliser Immutable.Iterable.isIterable() ( docs ).

Utiliser instanceof est pas fiable (par exemple, renvoie faux lorsque différents modules utilisent différentes copies de Immutable.js)

41
mbh

J'ai appris que en utilisant instanceof pour déterminer si l'objet est immuable est dangereux:

Module A:

var Immutable = require('immutable');
module.exports = Immutable.Map({foo: "bar});

Module B:

var Immutable = require('immutable');
var moduleA = require('moduleA');
moduleA instanceof Immutable.Map // will return false

L'API Immutable.js définit les méthodes suivantes pour vérifier si object est une instance de Immutable:

et

Ce dernier vérifie si:

Vrai si un Iterable ou l’une de ses sous-classes.

List, Stack, Map, OrderedMap, Set et OrderedSet sont toutes des sous-classes de Iterable.

21
Gajus

Immutable.js a isImmutable () function depuis la v4.0.0-rc.1:

 import { isImmutable, Map, List, Stack } from 'immutable';

 isImmutable([]); // false
 isImmutable({}); // false
 isImmutable(Map()); // true
 isImmutable(List()); // true
 isImmutable(Stack()); // true
 isImmutable(Map().asMutable()); // false

Si vous utilisez l'une des versions précédentes, vous pouvez vérifier si l'objet est immuable de cette façon:

 Immutable.Iterable.isIterable(YOUR_ENTITY)

parce que tous les immuables héritent de l'objet Iterable

16
Anton Novik

Et de cette façon, vous pouvez savoir quel type de variable immuable est modifiable:

const obj0 = 'xxx';
const obj1 = Immutable.fromJS({x: 'XXX', z: 'ZZZ'});
const obj2 = Immutable.fromJS([ {x: 'XXX'}, {z: 'ZZZ'}]);

const types = ['List', 'Stack', 'Map', 'OrderedMap', 'Set', 'OrderedSet'];
const type0 = types.find(currType => Immutable[currType][`is${currType}`](obj0));
const type1 = types.find(currType => Immutable[currType][`is${currType}`](obj1));
const type2 = types.find(currType => Immutable[currType][`is${currType}`](obj2));

console.log(`Obj0 is: ${type0}`); // Obj0 is: undefined
console.log(`Obj1 is: ${type1}`); // Obj1 is: Map
console.log(`Obj2 is: ${type2}`); // Obj2 is: List
<script src="https://cdnjs.cloudflare.com/ajax/libs/immutable/3.8.1/immutable.js"></script>

1
webmato

Cela peut fonctionner dans certains cas:

typeof object.toJS === 'function'

Vous pouvez utiliser cette méthode ducktyping si vous vérifiez les objets immuables par rapport aux objets simples (json), par exemple.

0
Dan K.K.

La vérification de types spécifiques entraînera généralement plus de travail ultérieurement. Habituellement, j'attendais de verrouiller les types en vérifiant la présence d'une carte ou d'une liste, mais ... 

Ma motivation ici réside principalement dans le fait que mon appel. Trouver des merde non définie lui-même est très difficile, et une initialisation correcte partout aide, mais ne détecte pas tous les cas Edge. Je veux juste les données ou indéfinies sans aucune rupture. La vérification de type spécifique me force à faire plus de travail plus tard si je veux qu’elle apporte des modifications. 

Cette version plus souple résout beaucoup plus de cas Edge (la plupart sinon tous les types étendus de type Iterable qui ont .get, et toutes les données sont finalement obtenues) qu'une vérification de type spécifique ne (généralement ce qui vous enregistre lorsque vous essayez de mettre à jour sur le type incorrect, etc. ).

/* getValid: Checks for valid ImmutableJS type Iterable

    returns valid Iterable, valid Iterable child data, or undefined

    Iterable.isIterable(maybeIterable) && maybeIterable.get(['data', key], Map()), becomes
    getValid(maybeIterable, ['data', key], Map())

    But wait! There's more! As a result:
    getValid(maybeIterable) returns the maybeIterable or undefined 
    and we can still say getValid(maybeIterable, null, Map()) returns the maybeIterable or Map()            */

export const getValid = (maybeIterable, path, getInstead) =>
  Iterable.isIterable(maybeIterable) && path
    ? ((typeof path === 'object' && maybeIterable.getIn(path, getInstead)) || maybeIterable.get(path, getInstead))
    : Iterable.isIterable(maybeIterable) && maybeIterable || getInstead;


//Here is an untested version that a friend requested. It is slightly easier to grok.

export const getValid = (maybeIterable, path, getInstead) => {
  if(valid(maybeIterable)) {                 // Check if it is valid
    if(path) {                                        // Check if it has a key
      if(typeof path === 'object') {     // Check if it is an 'array'
        return maybeIterable.getIn(path, getInstead) // Get your stuff
      } else {
        maybeIterable.get(path, getInstead)          // Get your stuff
      }
    } else {
      return maybeIterable || getInstead;                 // No key? just return the valid Iterable
    }
  } else {
    return undefined;                       // Not valid, return undefined, perhaps should return false here
  }
}

Donnez-moi simplement ce que je demande ou dites-moi non. N'explose pas. Je crois que le soulignement fait quelque chose de similaire aussi.

0
Urasquirrel