node.js - 异步查找子字符串匹配。递归？扁平化？

Question

我很想用redis喜欢node.js，但是征服不了异步。我再次拥有传统数据库和语言中的简单任务。我的问题更多是关于在异步数据库获取中完成控制流和逻辑，而不是我的问题解决方法是否最优。

这是我正在尝试做的事情:我有由单词组成的 Redis 键，我们只说 car 和 card。现在，给定一个输入字符串，我想知道与 redis 中的键匹配的最长子字符串是什么。我只需要检查给定字符串从位置 0 开始的子字符串，因此复杂度很低。

示例:cardinal 中有 key card，还有car，但card 更长。 Cape 与任何一个键都不匹配。

我的方法是:从整个字符串开始，检查它是否与某个键匹配。如果是，请返回该 key 。否则，对字符串减去最后一个字符重复相同的过程。

我怎样才能完成这个任务？欢迎不同的方法。

我对 async 库了解一些，看起来 waterfall 最适合我正在做的事情。但是，看来我需要键入从 string.length、string.length-1 等到最后一个字符的所有函数。我正在寻找的是一个很好的替代 for 循环的中断。

下面我用我假设总是 3 个字符或更多的输入进行测试(因为它已经很难看，而且更多的嵌套对于测试来说似乎毫无意义)。它有效，carde 导致 card，并且 care -> car。废话给出不匹配。

var http = require("http");
var redis = require("redis");

http.createServer(function(request, response) {
    client = redis.createClient();
    word = "carde";
    client.keys(word, function(err, reply) {
        if(err) { response.end(err); client.end(); }
        else {
          if(reply.length > 0) {
            response.end(word);
            client.end();
          }
          else {
            client.keys(word.slice(0,-1), function(err, reply) {
                if(err) { response.end(err); client.end(); }
                else {
                  if(reply.length > 0) {
                    response.end(word.slice(0, -1));
                    client.end();
                  }
                  else {
                    client.keys(word.slice(0, -2), function(err,reply) {
                        if(err) { response.end(err); client.end(); }
                        else {
                          if(reply.length > 0) {
                            response.end(word.slice(0, -2));
                            client.end();
                          }
                          else {
                            response.end("no match");
                          }
                        }
                      });
                  }
                }
              });
          }
        }
    });
  }).listen(8000);

我也试过递归，这可能是最好的方法。 (感谢 Timonthy Strimple 纠正错误)。

http.createServer(function(request, response) {
    client = redis.createClient();
    recursiveKeys("cardinalsin", client, response);
  }).listen(8000);

function recursiveKeys(word, client, response) {
  if (word.length == 0) {
    response.write("0");
    response.end();
    client.end();
  }
  else {
    client.keys(word, function(err, reply) {
        if(err) {
          response.write("0");
          response.end();
          client.end();
        }
        else {
          if(reply.length > 0) {
            response.write(word);
            response.end();
            client.end();
          }
          else {
            return recursiveKeys(word.slice(0,-1), client, response);
          }
        }
      });
  }
}

Answer 1

我同意递归解决方案可能是最好的。我在研究你的代码之前就解决了这个问题(以免影响实验)并得出了一个非常相似的解决方案。使用 http://localhost:3000/?word=cardinal

搜索单词

var http  = require('http');
var redis = require('redis');
var url   = require('url');

var findWord = function(needle, client, callback) {
  if (needle.length <= 0) { return callback("Word not found") }

  client.keys(needle, function(err, reply) {
    if (err) { callback("Word not found"); }
    else {
      if (reply.length > 0) {
        callback(needle);
      } else {
        findWord(needle.slice(0, -1), client, callback);
      }
    }
  });
};

var server = http.createServer(function(request, response) {
  var query  = url.parse(request.url, true).query;
  var word   = query.word || "";
  var client = redis.createClient();

  findWord(word, client, function(found) {
    client.end();
    response.writeHead(200, {"Content-Type": "text/plain"});
    response.end(found);
  });
});
server.listen(3000);