Javascript 如何实现类似于解构任务的功能？

如何实现类似于解构任务的功能

const res = foo([1, [2,3], [4,5,[6,[7,8]]]], '[a, [b, c], [d, [e, [f]]]]')
// res = {a: 1, b: 2, c: 3, d: 4, e: 6, f: 7}

---

福？谢谢。

我的解决方案与OP的原始请求不同，因为它接受一组键，而不是字符串。我认为它比字符串更好地反映了“类似于解构赋值”的要求

这是一个递归解决方案，它接受一个值数组和一个具有相同形状的键数组，并使用该数组迭代键，并提取匹配值

如果要跳过某个值，请使用

null

作为键

注意：您应该添加检查以确定形状相似，如果形状不同，则抛出错误/使用默认值

const析构函数=（值、键）=>{
常量obj={}；
常量迭代=（值、键）=>
keys.forEach（（key，i）=>{
如果（键===null）{
返回；
}
if（Array.isArray（key））迭代（值[i]，key）
else obj[key]=值[i]
})
迭代（值、键）
返回obj；
}
const res=析构函数（[1，[2,3]，[4,5，[6，[7,8]]]，[a'，[b'，[c']，[d'，null，[e'，[f']]）
log（res）

这里有一个基于

• JSON解析（使用技巧）从第二个参数构建结构
• 正如我在评论中所暗示的，两个数组中的递归并行下降

函数foo（arr，desc）{
var-map={}；
（功能潜水（arr、结构）{
结构forEach（（v，i）=>{
if（arr[i]==未定义）返回；
if（数组isArray（v））{
潜水（arr[i]，v）；
}否则{
map[v]=arr[i]；
}
});
})（arr，JSON.parse（desc.replace（/\w+/g，“$&”）；
返回图；
}
常数res=foo（[1[2,3]，[4[6[7,8]]]]，“[a[b，c]，[d[e[f]]]”）
//^我在此处删除了不匹配的数据
控制台日志（res）这是我的版本：

function destructor(values, keys) {
    const output = {};
    const kReg = /(?:"([^"]+)"|'([^']+)'|(\w+))/g;
    keys = keys.replace(/\{[^{}]+\}/g, match => match.replace(kReg, '"$1$2$3":"$1$2$3"'));
    keys = keys.replace(kReg, '"$1$2$3"');

    keys = JSON.parse(keys);

    function forAll(array, func, loc) {
        loc = loc || [];

        if (typeof array === 'object') {
            const nest = Object.assign({}, array);
            for (let a in nest) {
                if ({}.hasOwnProperty.call(nest, a)) {
                    nest[a] = forAll(nest[a], func, loc.concat(a));
                }
            }

            return nest;
        } else {
            return func(array, loc);
        }
    }
    function nestedGet(values, path) {
        const key = path.shift();

        return key === undefined ? values : (
            typeof values[key] === 'undefined' ? 
            undefined : nestedGet(values[key], path)
        );
    }

    forAll(keys, (elem, path) => {
        output[elem] = nestedGet(values, path)
    });

    return output;
}

此版本与其他版本之间的关键区别在于，您还可以使用
{key1，key2}
esq解构

例如：

destructor(
     [1, [2, 3], [4, {e:5, f:6}]],
    '[a, [b, c], [d, {e,   f  }]]'
);

destructor(
     [1, [2, 3], [4, 5, [6, [7, 8]]]],
    '[a, [b, c], [d, [e, [f]]]]'
);

变成：

{
    'a':1,
    'b':2,
    'c':3,
    'd':4,
    'e':5,
    'f':6
}

你的例子是：

destructor(
     [1, [2, 3], [4, {e:5, f:6}]],
    '[a, [b, c], [d, {e,   f  }]]'
);

destructor(
     [1, [2, 3], [4, 5, [6, [7, 8]]]],
    '[a, [b, c], [d, [e, [f]]]]'
);

变成：

{
    'a':1,
    'b':2,
    'c':3,
    'd':4,
    'e':undefined,
    'f':undefined
}

这是一个有趣的问题，但恐怕没有什么神奇的方法：您必须解析第二个参数（我个人使用递归解析，同时读取这两个结构）。我们可以做到，但我不确定为你做这项工作是否真的是为了你。我只是想了解为什么这个问题被否决，它是明确和有趣的one@HyyanAboFakher可能是因为“这个问题没有显示任何研究成果[…]”。嗨@Denys Séguret，你能给我一个案例代码吗？谢谢。您可以使用babeljs transpiler。这个函数的第二个参数是数组，而不是字符串。问题将字符串定义为第二个参数param@HyyanAboFakher-谢谢。我知道，我会在回答中指出它与请求不同。这只需使用JSON.parse来解决，将字符串转换为数组只是一个小观察：
['d'，'e'，
不在同一级别。@Rajesh-原始结构缺少一个字母。