Question

（JS的一些魔力）

大家好，

JS应该有足够的表现力来执行“情境化”多态？

我的意思是让一个对象根据其内部状态公开不同的接口，使用模块模式，方法链接和闭包来实现此机制。

例如：假设有限状态机：

// definition time
let m = machines_module.factory('machine-01', options);

m.onsuccess(function() { console.log(''done !''); });
m.onfailure(function() { console.log(''error !''); });

m.def('state-1')
  .inital()
  .when('event-a', 'state-2')
  .when('event-b', 'state-3');

m.def('state-2')
  .when('event-a', 'state-3');

m.def('state-3')
  .terminal()
  .when('event-b', 'state-2');
// etc... dozens of defs

// switch to run time
m.go('state-1');

// accept is only visible at run-time
m.accept('event-a');
m.accept('event-b');
// hundreds of transitions

// --> success  or failure

// switch back to def-time
m.halt();

顺便说一下，对象签名是依赖于上下文的。在定义时，您无法接受事件，在运行时无法添加新状态。

这可能吗？我想是的，是的。

自从我测试过：

 let X = {
   abc : 123,
   del : function() {
     for(let prop in this) {
       delete this[prop];
     }
   },
   xyz : 'will be destroyed by del() method'
 };

这对我来说很有效...我现在可以实现下面的代码......

想法是将项目移植到ES6中：

https://github.com/hefeust/dexm

这是我在具有时间嵌入能力（TEFSM）的有限状态机上的第一个实现。

我再说一遍;基本思想是提供对象的几种方法的访问，取决于其内部状态（停止或运行），从而强制执行数据保护和使用安全。

以下是代码：

'use strict';

// Inside a module pattern
class Utils {
  static eraseProps(obj) {
    console.log('   erase props');
    for(let prop in obj) {
      delete obj[prop];
    }
  };

  static cloneProps(fromObj, toObj) {
    console.log('   clone props');
    for(let prop in fromObj) {
      toObj[prop] = fromObj[prop];
    }
  }
}

class ContextualPolymorphic {
  constructor() {
    this.defs = new Map();
    this.state = false;
  };

  def(name, value) {
    this.defs.set(name, value);
  };

  list() {
    return this.defs.keys();
  };

  go() {
    this.state = true;
  };

  halt() {
    this.state = false;
  };

  defWrapper() {
    let self = this;

    return {
       go() {
         self.go();
         Utils.eraseProps(this);
         Utils.cloneProps(self.wrapper, this);
       },
       def(name) {
         self.def(name);
       }
    };
  };

  runWrapper() {
    let self = this;

    return {
       halt() {
         self.halt();
         Utils.eraseProps(this);
         Utils.cloneProps(self.wrapper, this);
       },
       list() {
         return self.list();
       }
    };
  };

  get wrapper() {
    if(this.state) {
      return this.runWrapper();
    } else {
      return this.defWrapper();
    }
  };
}

// module's factory method
let cp = new ContextualPolymorphic();

// we can solely access to "w",
// it s published outside the module
// w id public, cp is privatized
let w = cp.wrapper;

// tests
console.log('def phase');
console.log(w);
w.def('abc');
w.go();

console.log('run phase');
console.log(w);
w.list();
w.halt();

console.log('ready for new def-phase');
console.log(w);

那么，你的感受是什么？

是否可以简化上下文多态的机制？没有删除和克隆道具进入包装器的吸气剂？

JS：上下文多态性有点神奇

0 个答案: