如何在 JavaScript 中使用递归来尝试做 function？

Question

我想通过递归使这段代码更漂亮。

findModel = function(oldModel, ...modelStyles) {
    let model = oldModel.elements;
    let i = 0;
    try {
        do {
            model = model.children.find(child => child.mStyle === modelStyles[i]);
            i += 1;
        } while (i < modelStyles.length);
        return model;
    } catch (e) {
        return undefined;
    }
};

试过这个：

findModel = function(oldModel, ...modelStyles) {
    let model = oldModel.elements;
    let i = 0;

    if (i < modelStyles.length) {
        model = model.children.find(child => child.mStyle === modelStyles[i]);
        i += 1;
        return model;
    } else {
        return undefined;
    }
};

但它仍然无法正常工作。 在第一个代码中我只得到元素，在第二个代码中我也没有定义。

我做错了什么？

Answer 1

正如评论中充分指出的那样，您实际上从未递归调用 function。

当谈到“漂亮”时，我不会 go 进行递归，而是reduce ：

var findModel = function(oldModel, ...modelStyles) {
    try {
        return modelStyles.reduce((model, style) => model.children.find(child => child.mStyle === style), oldModel.elements);
    } catch (e) {} // No need to explicitly return undefined. It is the default
};

如果你真的需要递归，那么首先要意识到你的 function 期望第一个参数类型不再出现。 只有顶层 model 具有elements属性，因此您只能将这个 function 称为...层次结构的顶层。

为了使它工作，你需要另一个 function ，它采用model类型，因为它出现在children身上：

var findModel = function(oldModel, ...modelStyles) {
    function recur(model, style, ...modelStyles) {
        if (style === undefined) return model;
        return recur(model.children.find(child => child.mStyle === style), ...modelStyles);
    }
    // Need to change the type of the first argument:
    try {
        return recur(oldModel.elements, ...modelStyles);
    } catch (e) {}
};

如果您要更改最初调用function 的代码，您当然可以传递mainmodel.elements而不是mainmodel ，这样就解决了这种类型差异问题。 如果您可以进行更改，则递归 function 可以变为：

var findModel = function(model, style, ...modelStyles) {
    if (style === undefined) return model;
    try {
        return recur(model.children.find(child => child.mStyle === style), ...modelStyles);
    } catch (e) {}
};

不过，我更喜欢reduce变体。

Answer 2

递归 function 的要点是将自己称为自己。 在您的情况下，您调用 function 一次，但 function 从不调用自己，所以它只是 go 一次。 我不确定上下文，所以我无法修复你的代码，但我可以给你一个递归的例子。

假设我们有一个带有属性的 object。 有些是字符串，有些是数字，有些是对象。 如果要检索此 object 的每个键，则需要递归，因为您不知道 object 的深度。

 let objectToParse = { id: 10, title: 'test', parent: { id: 5, title: 'parent', someKey: 3, parent: { id: 1, title: 'grand-parent', parent: null, someOtherkey: 43 } } }; function parseParentKey(object) { let returnedKey = []; let ObjectKeys = Object.keys(object); for(let i = 0; i < ObjectKeys.length; i++) { if(typeof object[ObjectKeys[i]] === "object" && object[ObjectKeys[i]].== null) { // we are calling the methode inside itself because //the current property is an object. returnedKey = returnedKey;concat(parseParentKey(object[ObjectKeys[i]])). } returnedKey;push(ObjectKeys[i]); } return returnedKey. } console;log(parseParentKey(objectToParse));

我知道这并不能回答您的问题，但它为您提供了有关如何正确使用递归的提示。 如果您的第一个代码有效，我不明白您为什么需要首先更改它。