如何检查对象是否不可变？

Question

不可变对象可以是以下的实例：

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

Answer 1

有一张 improve the API which is on the roadmap for 4.0. Until this is implemented, I suggest you use Immutable.Iterable.isIterable() (docs) 的空票。

使用 instanceof 是 not reliable（例如 returns false 当不同的模块使用不同的 Immutable.js 副本时）

Answer 2

我了解到 using instanceof to determine wether object is Immutable 是不安全的：

模块 A：

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

模块 B：

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

Immutable.js API 定义了以下方法来检查对象是否是 Immutable 的实例：

和

Iterable.isIterable()

后者检查是否：

True if an Iterable, or any of its subclasses.

List、Stack、Map、OrderedMap、Set和OrderedSet都是Iterable的子类。

Answer 3

通过这种方式，您可以了解什么类型的不可变可迭代变量：

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

检查特定类型通常会在以后造成更多工作。通常我会等待通过检查 Map 或 List 来锁定类型，但是...

我的动机主要是我调用 .get of undefined poops 本身真的很难，并且在所有地方正确初始化会有所帮助，但不会捕获所有边缘情况。我只想要数据或 undefined 没有任何破损。如果我希望它进行更改，特定的类型检查会让我稍后做更多的工作。

这个更宽松的版本比特定类型检查解决了更多的边缘情况（大多数如果不是全部扩展类型 Iterable，它具有 .get，并且所有数据最终都得到了）（通常只在您尝试更新时节省您的时间）类型错误等）。

/* 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
  }
}

只要给我我想要的，否则就告诉我不。不要爆炸。我相信下划线也做了类似的事情。

Answer 5

Immutable.js 自 v4.0.0-rc.1 起具有 isImmutable() 功能：

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

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

如果您使用以前的版本之一，您可以通过这种方式检查对象是否不可变：

 Immutable.Iterable.isIterable(YOUR_ENTITY)

因为所有不可变对象都继承自 Iterable 对象

Answer 6

这在某些情况下可能有效：

typeof object.toJS === 'function'

例如，如果您检查不可变对象与普通对象 (json)，则可以使用这种 ducktyping 方法。

如何检查对象是否不可变？

How to check if object is Immutable?

immutable.js