数据形变 / 数据补全相关

fill-rows 补全行

alias: fillRows

先按照 groupBy 和 orderBy 进行分组，如果以分组作为补全依据（fillBy: 'group'），那么就对比每个分组，以 orderBy 序列字段值最全的分组为标准补全数据行数不足的分组。如果以序列作为补全依据（fillBy: 'order'），那么就取所有 orderBy 序列字段的组合，为每个分组都补充全量的序列。

注意！如果原始数据有除 groupBy 和 orderBy 指定的字段以外的字段，那么补充的数据行里会缺失这些字段。这时可以结合 impute Transform 来做字段数据补全。

具体用法见示例：

fillBy: group

  1. const data = [
  2.   { a: 0, b: 0 },
  3.   { a: 0, b: 1 },
  4.   { a: 0, b: 2 },
  5.   { a: 1, b: 1 },
  6.   { a: 1, b: 2 },
  7.   { a: 1, b: 3 },
  8.   { a: 2, b: 0 },
  9. ];
  10. const dv = new DataSet.DataView().source(data).transform({
  11.   type: 'fill-rows',
  12.   groupBy: ['a'],
  13.   orderBy: ['b'],
  14.   fillBy: 'group', // 默认为 group，可选值：order
  15. });
  16. console.log(dv.rows);
  17. /*
  18.  * dv.rows 变为:
  19.  * [
  20.  *   { a: 0, b: 0 }, // 分组1 作为第一个序列字段最全（b）的组，被选为基准
  21.  *   { a: 0, b: 1 },
  22.  *   { a: 0, b: 2 },
  23.  *   { a: 1, b: 1 }, // 分组2 序列字段个数和基准组一致，所以不补充数据
  24.  *   { a: 1, b: 2 },
  25.  *   { a: 1, b: 3 },
  26.  *   { a: 2, b: 0 }, // 分组3 缺省数据，根据基准组进行数据补全
  27.  *   { a: 2, b: 1 }, // 这行数据被补充
  28.  *   { a: 2, b: 2 }, // 这行数据被补充
  29.  * ]
  30.  */

fillBy: order

  1. // 使用和上例同样的数据
  2. const dv = new DataSet.DataView().source(data).transform({
  3.   type: 'fill-rows',
  4.   groupBy: ['a'],
  5.   orderBy: ['b'],
  6.   fillBy: 'order', // 默认为 group，可选值：order
  7. });
  8. console.log(dv.rows);
  9. /*
  10.  * dv.rows 变为:
  11.  * [
  12.  *   { a: 0, b: 0 }, // 分组1
  13.  *   { a: 0, b: 1 },
  14.  *   { a: 0, b: 2 },
  15.  *   { a: 0, b: 3 }, // 分组1 补充了这行数据，因为全量的序列字段（b）有这个值
  16.  *   { a: 1, b: 0 }, // 分组2 补充了这行数据，因为全量的序列字段（b）有这个值
  17.  *   { a: 1, b: 1 },
  18.  *   { a: 1, b: 2 },
  19.  *   { a: 1, b: 3 },
  20.  *   { a: 2, b: 0 }, // 分组3 缺省数据，根据基准组进行数据补全
  21.  *   { a: 2, b: 1 }, // 这行数据被补充
  22.  *   { a: 2, b: 2 }, // 这行数据被补充
  23.  *   { a: 2, b: 3 }, // 这行数据被补充
  24.  * ]
  25.  */

impute 补全列 / 补全字段

根据配置规则为某个字段补全缺失值。

具体用法见示例：

  1. const data = [
  2.   { x: 0, y: 1 },
  3.   { x: 0, y: 2 },
  4.   { x: 0, y: 3 },
  5.   { x: 0 },
  6.   { x: 1, y: 5 },
  7.   { x: 1, y: 6 },
  8.   { x: 1, y: 7 },
  9.   { x: 1 },
  10.   { x: 1, y: 9 },
  11.   { x: 2 },
  12. ];
  13. const dv = new DataSet.DataView().source(data).transform({
  14.   type: 'impute',
  15.   field: 'y', // 待补全字段
  16.   groupBy: ['x'], // 分组字段集（传空则不分组）
  17.   method: 'max', // 补全字段值时执行的规则
  18. });
  19. /*
  20.  dv.rows 变为
  21. [
  22.   { x: 0, y: 1 },
  23.   { x: 0, y: 2 },
  24.   { x: 0, y: 3 },
  25.   { x: 0, y: 3 },
  26.   { x: 1, y: 5 },
  27.   { x: 1, y: 6 },
  28.   { x: 1, y: 7 },
  29.   { x: 1, y: 7 },
  30.   { x: 1, y: 9 },
  31.   { x: 2, y: 9 }
  32. ]
  33.  */

补全字段的规则（method）有常见的统计函数：max, min, median, mean

还有补充固定值的写法：method 指定为 value，然后 value 指定为填充的常量，譬如

  1. dv.transform({
  2.   type: 'impute',
  3.   field: 'y', // 待补全字段
  4.   groupBy: ['x'], // 分组字段集（传空则不分组）
  5.   method: 'value', // 补全常量
  6.   value: 10, // 补全的常量为10
  7. });

fold 字段展开

以指定字段集为 key，展开数据。

具体用法见示例：

  1. const data = [
  2.   { country: 'USA', gold: 10, silver: 20 },
  3.   { country: 'Canada', gold: 7, silver: 26 },
  4. ];
  5. const dv = ds
  6.   .createView()
  7.   .source(data)
  8.   .transform({
  9.     type: 'fold',
  10.     fields: ['gold', 'silver'], // 展开字段集
  11.     key: 'key', // key字段
  12.     value: 'value', // value字段
  13.     retains: ['country'], // 保留字段集，默认为除 fields 以外的所有字段
  14.   });
  15. /*
  16.  dv.rows 变为
  17. [
  18.   { key: gold, value: 10, country: "USA" },
  19.   { key: silver, value: 20, country: "USA" },
  20.   { key: gold, value: 7, country: "Canada" },
  21.   { key: silver, value: 26, country: "Canada" }
  22. ]
  23.  */