KnowledgeNet

k1,k2,k3,k4,k5,k6 六个知识点

k1,k2,k3 是 k4 的 前置知识点

k5,k6 是 k4 的后续知识点

KnowledgeSpaceNet

ks1...ks12 代表 12 个状态，每个状态代表人当前掌握的知识情况

比如 ks1 表示人什么知识点都没有掌握
ks2 表示人掌握了 k1 这个知识点
ks5 表示人掌握了 k1 k2 这两个知识点

箭头表示状态转换
比如 ks2到 ks5 表示如果人在ks2状态时，人的下一个状态可以是 ks5(表示人在掌握k1时,可以去学习k2)

KnowledgeSpaceNet 类上需要一个实例方法用于查询状态节点

knowledge_space_node = knowledge_space_net.get_space_node(knowledge_nodes)
# 传入一个知识节点数组，如果当前知识空间网络的空间节点里有对应这些知识节点的空间节点，则返回对应空间节点，否则返回nil

为了便于开发和演示知识定位问答工具
我们需要准备一些数据
知识点我已经准备了一部分，是关于 javascript 语言核心的知识点
知识点导图下载地址
mmap 格式 http://pan.baidu.com/share/link?uk=34055634&shareid=2515061730
bmp 格式 http://pan.baidu.com/share/link?uk=34055634&shareid=2605066501

给这个导图上的每个知识点（叶子节点），准备一个问题，根据知识点的实际情况准备合适类型的问题（多选，单选，判断，编程题）

编程题指的是类似 javascript_step 形式的问题，有具体的编程要求，不过不用准备 rule ，先准备编程要求就可以

需要做的是

给每个知识点准备一个合适的问题，汇总到一起，格式不限，方便查看和进一步整理就可以

KnowledgeSapceNet 表示一个很多 KnowledgeSapceNode 节点组成的网状结构

其中每个 KnowledgeSapceNode 节点，包含多个 KnowledgeNode 节点
一个 KnowledgeNode 可以被多个 KnowledgeSapceNode 分别包含

包括两个模型

KnowledgeSapceNet
表示一个网状结构

KnowledgeSapceNode
表示一个节点
KnowledgeSapceNode 有三个属性
  knowledge_nodes: 当前节点包含的KnowledgeNode对象数组 # KnowledgeNode 由 issue1 实现
  parents: 所有前置 KnowledgeSapceNode对象数组
  children: 所有后续 KnowledgeSapceNode对象数组

一个 KnowledgeSapceNet 被持久化为一个 xml 文件

xml 文件结构如下

<KnowledgeSapceNet>
  <nodes>
    <node id="ks1">
      <knowledge_node_ids>
        <id>k1</id>
      </knowledge_node_ids>
    </node>
    <node id="ks2">
      <knowledge_node_ids>
        <id>k1</id>
        <id>k2</id>
      </knowledge_node_ids>
    </node>
  </nodes>

  <relations>
    <relation>
      <parent node_id="ks1"/>
      <child node_id="ks2"/>
    </relation>
  </relations>
</KnowledgeSapceNet>

xml 说明
knowledge_node_ids 表示 一个KnowledgeSapceNode 包含的 KnowledgeNode id 数组

需要做的事情

1 实现
KnowledgeSapceNet
KnowledgeSapceNode
KnowledgeSpaceParser
三个类的逻辑
具体API如下

  # 这个是获取 knowledge_net,由 issue1 实现了
  knowledge_net = KnowledgeNet.load_xml_file('knowledge_net.xml')

  # 解析 xml 为 KnowledgeSapceNet 实例
  #1.xml 文件的位置是 rails_root/config/knowledge_sapce_nets/1.xml
  # knowledge_net 对象中包含 KnowledgeNode 信息
  sapce_net = KnowledgeSpaceParser.load(knowledge_net, "1.xml")

  # 返回 parents 是空数组的 KnowledgeSapceNet 实例
  sapce_nodes = sapce_net.root_nodes


  sapce_nodes.each do |sapce_node|
    sapce_node.knowledge_nodes
    sapce_node.parents
    sapce_node.children
  end

说明

KnowledgeNet 表示一个很多知识节点组成的网状结构
我们抽取了两个模型

1 KnowledgeNet
一个KnowledgeNet实例就表示一个知识网

2 KnowledgeNode
一个知识网中有很多知识节点,一个KnowledgeNode实例表示 一个知识节点

每个KnowledgeNode都有多个前置知识节点（如果要学C知识节点，必须先学会A,B这两个知识节点，我们就把A,B叫做C的前置知识节点）
反之
每个KnowledgeNode都有多个后续知识节点（如果要学E,F知识节点，必须先学会D知识节点，我们就把E,F叫做D的后续知识节点）

KnowledgeNode 有五个属性
id: 全局唯一
name: 知识节点名称
desc: 知识节点描述
parents: 所有前置知识节点数组（在掌握这个知识节点之前，需要先掌握的直接关联的知识节点）
children: 所有后续知识节点数组（在掌握这个知识节点之后，可以进一步掌握的直接关联的知识节点）

每个 KnowledgeNet 会用一个 xml 文件来持久化

xml 结构如下

<KnowledgeNet>
  <nodes>
    <node id="k1">
      <name>xxx<name>
      <desc>xxx</desc>
    </node>
    <node id="k2">
      <name>xxx<name>
      <desc>xxx</desc>
    </node>
    <node id="k3">
      <name>xxx<name>
      <desc>xxx</desc>
    </node>
  </nodes>

  <relations>
    <relation>
      <parent node_id="k1"/>
      <child node_id="k2"/>
    </relation>
    <relation>
      <parent node_id="k1"/>
      <child node_id="k3"/>
    </relation>
  </relations>
</KnowledgeNet>

xml 结构说明
每个 node 表示一个知识节点
每个 relation 表示两个知识节点的前置后续关系

需要做的事情

1 实现 KnowledgeNet KnowledgeNode 两个类的逻辑
具体API如下

  # 解析 xml 为 KnowledgeNet 实例
  #1.xml 的位置文件位置是 rails_root/config/knowledge_nets/1.xml
  knowledge_net = KnowledgeNet.load_xml_file("1.xml")

  # 返回没有 parents(前置知识节点) 的KnowledgeNode 实例
  knowledge_nodes = knowledge_net.root_nodes


  knowledge_nodes.each do |node|
    node.id
    node.name
    node.desc
    node.parents
    node.children
  end

  # 根据 node_id 直接找到 KnowledgeNode 实例
  knowledge_node = knowledge_net.find_node_by_id(node_id)

每个知识空间节点都有若干个外联知识节点。
外联知识节点的定义是：

从当前知识空间节点(ks)内包含的知识节点集合 K(k1, k2, k3 ...)，取得这些知识节点的所有子节点集合 U
集合U中所有节点，符合以下条件的，是外联节点：
1 该子节点本身，不包含在 K 中。
2 该子节点所有的父节点，都包含在 K 中。

如果知识网络中的任何根节点，不包含在K中，那么该根节点也作为ks的外联节点。

举例：

  k1 ==> k2 ==> k4
           \
             \
  k3 =========> k5

当知识网络按照上述分布时。

如果当前存在知识空间节点 KS1{k1}
则 KS1 的外联节点为 [k2, k3]。
其中k2是k1的子节点，而k3是知识网络的根节点。

如果当前存在知识空间节点 KS1{k1,k3}
则 KS1 的外联节点为 [k2, k3]。
其中k2是k1的子节点，且k2的所有父节点[k1]都在KS1中。
而k3是知识网络的根节点。
注意，k5不是KS1的外联节点，因为 k5 的父节点 k2 现在不在KS1中

如果当前存在知识空间节点 KS1{k1,k2,k3}
则 KS1 的外联节点为 [k4, k5]。

综上，根据以上规则，在 KnowledgeSpaceNode上实现实例方法

outer_nodes = konwledge_space_node.outer_nodes

此方法返回当前知识空间节点的外联知识节点。

知识点测试题建模

knowledge_questions

  create_table :knowledge_questions do |t|
    t.string :knowledge_node_id
    t.string :kind # BOOLEAN | SINGLE_CHOOSE | MUTI_CHOOSE | CODE

    t.string :title
    t.text   :desc
    t.text   :rule
    t.text   :init_code
    t.string :code_type # JAVASCRIPT
    t.text :choices # 选择题选项 json 格式
    t.string :answer # "ABC" | "A" | "true" | "false"
    t.timestamps
  end

各种类型问题的数据字段情况

单选类型的问题

  type SINGLE_CHOOSE
  title "题内容"
  choices # ["选项A","选项B"].to_json
  answer # "A"

多选类型的问题

  type MUTI_CHOOSE
  title "题内容"
  choices # ["选项A","选项B"].to_json
  answer # "AB"

判断类型的问题

  type BOOLEAN
  title "题内容"
  answer # "true" | "false"

编程类型的问题

  type CODE
  title "问题内容"
  desc "问题的详细补充说明"
  rule "验收检验规则代码"
  init_code "编程题的初始代码"
  code_type # JAVASCRIPT

需要做的内容

1 创建 knowledge_questions 数据表，并建模

2 重新实现模型的 choices choices= 方法
knowledge_questions.choices 返回 数组对象
knowledge_questions.choices=(string_arr) 接受的参数是字符串数组