Comment vérifier si l'objet est immuable?

Question

objet immuable peut être une instance de:

• Immutable.List
• Immutable.Map
• Immutable.OrderedMap
• Immutable.Set
• Immutable.OrderedSet
• Immutable.Stack

Answer 1

Il y a un ticket ouvert à improve the API qui est sur la feuille de route pour 4.0. Jusqu'à ce que cela soit mis en œuvre, je vous suggère d'utiliser Immutable.Iterable.isIterable() (docs).

L'utilisation instanceof est not reliable (par exemple, retourne false lorsque différents modules utilisent des copies de Immutable.js)

Answer 2

J'ai appris que using instanceof to determine wether object is Immutable 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 

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

• Map.isMap()
• List.isList()
• Stack.isStack()
• OrderedMap.isOrderedMap()
• Set.isSet()
• OrderedSet.isOrderedSet()

et

• Iterable.isIterable()

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 les sous-classes de Iterable.

Answer 3

Et cette façon, vous pouvez apprendre à connaître ce type de variable Immuable est Iterable:

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>

Answer 4

Vérification des types spécifiques seront généralement causer plus de travail plus tard. Habituellement j'attendrais pour verrouiller les types dedans en vérifiant pour la Carte ou la Liste, mais ...

Ma motivation ici est surtout que mon appel .get de undefined se cogne vraiment dur, et l'initialisation correctement partout aide, mais n'attrape pas tous les cas de bordure. Je veux juste les données ou indéfinies sans aucune casse. La vérification de type spécifique me permet de faire plus de travail plus tard si je veux qu'il fasse des changements. Cette version plus souple résout beaucoup plus de cas de bords (la plupart du type Iterable avec la propriété .get, et toutes les données sont finalement obtenues) qu'une vérification de type spécifique (qui ne vous sauve habituellement que lorsque vous essayez de mettre à jour le mauvais type etc). Donne-moi ce que je te demande ou dis-moi non. Ne pas exploser. Je crois que le soulignement fait quelque chose de similaire aussi.

Answer 5

Immutable.js a déjà isImmutable() fonction:

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

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

Answer 6

Cela peut fonctionner dans certains cas:

typeof object.toJS === 'function' 

Vous pouvez utiliser cette méthode de duck typing si vous vérifiez immuable vs objets simples (JSON), par exemple.