immutable.js - sort - seamless-immutable

¿Cómo verificar si el objeto es inmutable?

Question

El objeto inmutable puede ser una instancia de:

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

Answer 1

Esto puede funcionar en algunos casos:

typeof object.toJS === ''function''

Puede utilizar este método de identificación de patos si marca objetos inmutables vs simples (json), por ejemplo.

Answer 2

Hay un ticket abierto para mejorar la API que está en la hoja de ruta para 4.0. Hasta que esto se implemente, sugiero que use Immutable.Iterable.isIterable() ( docs ).

El uso de instanceof no es confiable (por ejemplo, devuelve falso cuando diferentes módulos usan diferentes copias de Immutable.js)

Answer 3

He aprendido que usar instanceof para determinar si su objeto es inmutable no es seguro:

Módulo A:

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

Módulo B:

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

La API Immutable.js define los siguientes métodos para verificar si el objeto es una instancia de Immutable:

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

y

• Iterable.isIterable()

Este último verifica si:

Verdadero si es Iterable o cualquiera de sus subclases.

List , Stack , Map , OrderedMap , Set y OrderedSet son todas las subclases de Iterable .

Answer 4

La comprobación de tipos específicos generalmente causará más trabajo más adelante. Por lo general, esperaba para bloquear los tipos al buscar Mapa o Lista, pero ...

Mi motivación aquí es sobre todo que mi llamada. Get de indecisos caca realmente difícil, y la inicialización correctamente en todo el lugar ayuda, pero no atrapa todos los casos extremos. Solo quiero los datos o indefinidos sin ninguna rotura. La verificación de tipos específicos hace que haga más trabajo más adelante si quiero que haga cambios.

Esta versión más flexible resuelve muchos casos más (la mayoría, si no todos, amplían el tipo Iterable que tiene .get y finalmente se obtienen todos los datos) que una comprobación de tipo específica (que generalmente solo lo guarda cuando intenta actualizar en el tipo incorrecto, 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
  }
}

Solo dame lo que estoy pidiendo o dime que no. No explotes Creo que el guión bajo también hace algo similar.

Answer 5

Y de esta manera usted puede conocer qué tipo de variable Iterable es Inmutable:

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 6

isImmutable() tiene la función isImmutable() desde 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 usa una de las versiones anteriores, puede verificar si el objeto es inmutable de esta manera:

 Immutable.Iterable.isIterable(YOUR_ENTITY)

porque todos los inmutables heredan del objeto Iterable