如何实现类似解构赋值的功能？

Question

How to achieve a function similar to the deconstruction assignment?

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}

foo ? Thanks.

Answer 1

Here's a solution based on

• a JSON parsing (with a trick) to build a structure from the second argument
• a recursive parallel descent in both arrays, as hinted in my comment

 function foo(arr, desc){ var map = {}; (function dive(arr, struct){ struct.forEach((v, i) => { if (arr[i] === undefined) return; if (Array.isArray(v)) { dive(arr[i], v); } else { map[v] = arr[i]; } }); })(arr, JSON.parse(desc.replace(/\\w+/g, '"$&"'))); return map; } const res = foo([1, [2,3], [4, [6,[7,8]]]], '[a, [b, c], [d, [e, [f]]]]') // ^ I removed not matching data here console.log(res);

Note that it assumes the data matches the structure. You'd better add error handling in the general case.

Answer 2

My solution defers from the OP's original request, as it accepts an array of keys, and not string. I think that it reflects the "similar to the deconstruction assignment" request better than a string.

This is a recursive solution that accepts an array of values, and an array of keys with the same shape, and uses Array.forEach() to iterate the keys, and extract the matching values.

If you want to skip a value, use null as the key.

Note: You should add checks to ascertain that the shapes are similar, and throw errors/use defaults if they are different.

 const destructor = (values, keys) => { const obj = {}; const iterate = (values, keys) => keys.forEach((key, i) => { if(key === null) { return; } if(Array.isArray(key)) iterate(values[i], key) else obj[key] = values[i] }) iterate(values, keys) return obj; } const res = destructor([1, [2,3], [4,5,[6,[7,8]]]], ['a', ['b', 'c'], ['d', null, ['e', ['f']]]]) console.log(res)

Answer 3

Here's my version of this:

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;
}

The key difference between this version and other versions is that you can also use {key1, key2} esq deconstructions.

For example:

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

Becomes:

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

Your example:

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

Becomes:

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