所以我开始研究 Ramda/Folktale。我在尝试映射来自目录的一系列任务时遇到问题。我正在尝试解析文件内容。

var fs = require('fs');
var util = require('util');
var R = require('ramda');
var Task = require('data.task');

var compose = R.compose;
var map = R.map;
var chain = R.chain;


function parseFile(data) {
      console.log("Name: " + data.match(/\$name:(.*)/)[1]);
      console.log("Description: " + data.match(/\$description:(.*)/)[1]);
      console.log("Example path: " + data.match(/\$example:(.*)/)[1]);
}

// String => Task [String]
function readDirectories(path) {
    return new Task(function(reject, resolve) {
        fs.readdir(path, function(err, files) {
            err ? reject(err) : resolve(files);
        })
    })
}

// String => Task String
function readFile(file) {
    return new Task(function(reject, resolve) {
        fs.readFile('./src/less/' + file, 'utf8', function(err, data) {
            err ? reject(err) : resolve(data);
        })
    })
}

var app = compose(chain(readFile), readDirectories);

app('./src/less').fork(
    function(error) { throw error },
    function(data)  { util.log(data) }
);

我正在读取目录中的文件并返回任务。当这个问题解决时，它应该进入 readFile 函数(它返回一个新任务)。一旦它读取文件，我希望它只解析其中的一些位。

具有以下内容:

var app = compose(chain(readFile), readDirectories);

它进入了 readFile 函数，但"file"是一个文件数组，因此它出错了。

与:

var app = compose(chain(map(readFile)), readDirectories);

我们从未进入 fs.readfile()，但"file"是实际文件名。

我对此很困惑，文档也令人费解。欢迎提出任何建议。

谢谢

最佳答案

'use strict';

const fs = require('fs');

const Task = require('data.task');
const R = require('ramda');


//    parseFile :: String -> { name :: String
//                           , description :: String
//                           , example :: String }
const parseFile = data => ({
  name:         R.nth(1, R.match(/[$]name:(.*)/, data)),
  description:  R.nth(1, R.match(/[$]description:(.*)/, data)),
  example:      R.nth(1, R.match(/[$]example:(.*)/, data)),
});

//    readDirectories :: String -> Task (Array String)
const readDirectories = path =>
  new Task((reject, resolve) => {
    fs.readdir(path, (err, filenames) => {
      err == null ? resolve(filenames) : reject(err);
    })
  });

//    readFile :: String -> Task String
const readFile = filename =>
  new Task(function(reject, resolve) {
    fs.readFile('./src/less/' + filename, 'utf8', (err, data) => {
      err == null ? resolve(data) : reject(err);
    })
  });

//    dirs :: Task (Array String)
const dirs = readDirectories('./src/less');

//    files :: Task (Array (Task String))
const files = R.map(R.map(readFile), dirs);

//    sequenced :: Task (Task (Array String))
const sequenced = R.map(R.sequence(Task.of), files);

//    unnested :: Task (Array String)
const unnested = R.unnest(sequenced);

//    parsed :: Task (Array { name :: String
//                          , description :: String
//                          , example :: String })
const parsed = R.map(R.map(parseFile), unnested);

parsed.fork(err => {
              process.stderr.write(err.message);
              process.exit(1);
            },
            data => {
              process.stdout.write(R.toString(data));
              process.exit(0);
            });

我将每个转换写在单独的一行中，这样我就可以包含类型签名，使嵌套映射更容易理解。这些当然可以通过 R.pipe 组合成一个管道。 .

最有趣的步骤是使用 R.sequence将 Array (Task String) 转换为 Task (Array String)，并使用 R.unnest将 Task (Task (Array String)) 转换为 Task (Array String)。

我建议看看 plaid/async-problem如果您还没有这样做的话。

关于javascript - 在 Javascript 中映射一组任务，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/33518361/