Question

我有一个数据结构，称为“规范”，如下所示：

const spec = {
  command: {
    name: 'name',
    description: 'description',
    alias: 'alias',
    arguments: '_children/Arguments'
  },
  arguments: {
    name: 'name',
    alias: 'alias',
    optional: 'optional',
    description: 'description'
  }
};

因此命令和自变量中的元素是映射到路径的属性。最好的说明是 spec.command.arguments 。我需要做的是将其转换为具有相同形状的另一个对象，但是路径会转换为Ramda镜头（使用R.lensPath）。

所以从概念上讲，这被翻译成这样：

const spec = {
  command: {
    name: lens('name'),
    description: lens('description'),
    alias: lens('alias'),
    arguments: lens('_children/Arguments')
  },
  arguments: {
    name: lens('name'),
    alias: lens('alias'),
    optional: lens('optional'),
    description: lens('description')
  }
};

以上内容并非从字面上看，而是伪结构。例如， lens（'_ children / Arguments'）只是代表使用Ramda lensPath构建的镜头。

这是我的代码：

const spec = {
  command: {
    name: 'name',
    description: 'description',
    alias: 'alias',
    arguments: '_children/Arguments'
  },
  arguments: {
    name: 'name',
    alias: 'alias',
    optional: 'optional',
    description: 'description'
  }
};

function lensify (spec) {
  const result = R.pipe(
    R.toPairs,
    R.reduce((acc, pair) => {
      const field = pair[0];
      const path = pair[1];
      const lens = R.compose(
        R.lensPath,
        R.split('/')
      )(path);

      acc[field] = lens; // Is there something wrong with this, if so what?
      return acc;
    }, { dummy: '***' }) // list of pairs passed as last param here
  )(spec);

  // The following log should show entries for 'name', 'description', 'alias' ...
  console.log(`+++ lensify RESULT: ${JSON.stringify(result)}`);
  return result;
}

function makeLenses (spec) {
  const result = {
    command: lensify(spec.command),
    arguments: lensify(spec.arguments)
  };

  return result;
}

makeLenses(spec);

我认为失败的关键点在于减速器功能内部，该功能会返回更新的累加器（ acc [field] = lens; ）。由于某种我无法理解的原因，该分配已丢失，并且每次迭代均未正确填充累加器。从代码示例中可以看到，传递给reduce的初始值是一个具有单个 dummy 属性的对象。减少的结果错误地只是这个单个虚拟值，而不是所有具有各自Ramda透镜的场。

但是，烘烤面条的真正目的是在Ramda repl中运行的完全相同的代码表现出不同的行为，请参见以下副本中的代码：Ramda code

我正在运行10.13.0版的节点

Repl代码产生的结果是这样的：

{
  'arguments': {
    'alias': function (r) {
      return function (e) {
        return z(function (t) {
          return n(t, e)
        }, r(t(e)))
      }
    },
    'description': function (r) {
      return function (e) {
        return z(function (t) {
          return n(t, e)
        }, r(t(e)))
      }
    },
    'dummy': '***',
    'name': function (r) {
      return function (e) {
        return z(function (t) {
          return n(t, e)
        }, r(t(e)))
      }
    },
    'optional': function (r) {
      return function (e) {
        return z(function (t) {
          return n(t, e)
        }, r(t(e)))
      }
    }
  },
  'command': {
    'alias': function (r) {
      return function (e) {
        return z(function (t) {
          return n(t, e)
        }, r(t(e)))
      }
    },
    'arguments': function (r) {
      return function (e) {
        return z(function (t) {
          return n(t, e)
        }, r(t(e)))
      }
    },
    'description': function (r) {
      return function (e) {
        return z(function (t) {
          return n(t, e)
        }, r(t(e)))
      }
    },
    'dummy': '***',
    'name': function (r) {
      return function (e) {
        return z(function (t) {
          return n(t, e)
        }, r(t(e)))
      }
    }
  }
}

如您所见，结果看起来有些复杂，因为每个属性的值都是lensProp创建的镜头。

这与以下内容相反（请注意，命令和参数的顺序相反，但这并不重要）：

{
  'command': {
    'dummy': '***'
  },
  'arguments': {
    'dummy': '***'
  }
}

这是我的单元测试中返回的。

我在此上浪费了大约2天，现在承认失败了，因此希望有人可以对此有所了解。干杯。

Answer 1

这显示了我能想到的最简单的输出用法，将镜头上的view映射到一个公共物体。在REPL（如以下代码段）和Node 10.13.0中似乎都可以正常工作：

const {map, pipe, split, lensPath, view} = ramda  

const makeLenses = map ( map ( pipe ( split ('/'), lensPath )))

const applyLensSpec = (lensSpec) => (obj) => 
  map ( map ( f => view (f, obj) ), lensSpec)

const spec = {command: {name: "name", description: "description", alias: "alias", arguments: "_children/Arguments"}, arguments: {name: "name", alias: "alias", optional: "optional", description: "description"}};

const myTransform = applyLensSpec(
  makeLenses(spec),
)

const testObj =   {
  name: 'foo', 
  alias: 'bar', 
  description: 'baz', 
  optional: false, 
  _children: {
    Arguments: ['qux', 'corge']
  }
}

console .log (
  myTransform (testObj)
)

<script src="https://bundle.run/ramda@0.26.1"></script>

Answer 2

此帖子的附录并与Scott所说的一致，该帖子的原因是JSON.stringify的不足，这实际上是该故事的寓意；并不总是信任JSON.stringify的输出。这是一个确认这一点的测试用例：

  context('JSON.stringify', () => {
    it.only('spec/lensSpec', () => {
      const spec = {
        command: {
          name: 'name',
          description: 'description',
          alias: 'alias',
          arguments: '_children/Arguments'
        },
        arguments: {
          name: 'name',
          alias: 'alias',
          optional: 'optional',
          description: 'description'
        }
      };

      const makeLensSpec = R.map(R.map(R.pipe(
        R.split('/'),
        R.lensPath
      )));

      const lensSpec = makeLensSpec(spec);
      console.log(`INPUT spec: ${JSON.stringify(spec)}`);
      // The following stringify does not truly reflect the real value of lensSpec.
      // So do not trust the output of JSON.stringify when the value of a property
      // is a function as in this case where they are the result of Ramda.lensProp.
      //
      console.log(`RESULT lensSpec: ${JSON.stringify(lensSpec)}`);
      const rename = {
        'name': 'rename',
        'alias': 'rn',
        'source': 'filesystem-source',
        '_': 'Command',
        'describe': 'Rename albums according to arguments specified.',
        '_children': {
          'Arguments': {
            'with': {
              'name': 'with',
              '_': 'Argument',
              'alias': 'w',
              'optional': 'true',
              'describe': 'replace with'
            },
            'put': {
              'name': 'put',
              '_': 'Argument',
              'alias': 'pu',
              'optional': 'true',
              'describe': 'update existing'
            }
          }
        }
      };

      // NB, if the output of JSON.stringify was indeed correct, then this following
      // line would not work; ie accessing lensSpec.command would result in undefined,
      // but this is not the case; the lensSpec can be used to correctly retrieve the
      // command name.
      //
      const name = R.view(lensSpec.command.name, rename);
      console.log(`COMMAND name: ${name}`);
    });
  });

注释的日志语句为：

console.log（INPUT spec: ${JSON.stringify(spec)}）;

显示以下内容：

INPUT spec: {"command":{"name":"name","description":"description","alias":"alias","arguments":"_children/Arguments"},"arguments":{"name":"name","alias":"alias","optional":"optional","description":"description"}}

console.log（RESULT lensSpec: ${JSON.stringify(lensSpec)}）;

这是一个错误（lensSpec包含属性，这些属性的值是无法显示为字符串的函数，因此会完全忽略它们，从而给出错误的表示形式：

RESULT lensSpec: {"command":{},"arguments":{}}

console.log（COMMAND name: ${name}）;

这按预期工作：

COMMAND name: rename

注意：我刚刚发现了这个：Why doesn't JSON.stringify display object properties that are functions?

如何解决Ramda reduce函数的错误返回结果（javascript）

2 个答案: