JavaScript Wie noch vereinfachen?

[Hendoul]

Hi

Folgenden Code möchte ich noch vereinfachen:
https://jsfiddle.net/GarfieldKlon/a30nhr7e/36/

const test = {
    valid: [],
    invalid: []
};

const methodsAndComparison = {
    isPresent: {
        valid: ['toBe(true)', 'toEqual(true)'],
        invalid: ['toBe(false)', 'toEqual(false)']
    },
    isOpen: {
        valid: ['toBe(true)', 'toEqual(true)'],
        invalid: ['toBe(false)', 'toEqual(false)']
    }
};


function fillValid(method, comparison) {
    const codeSnippets = [
        'some.expressions.' + method + '()).' + comparison + '; }',
        'another.epxression.' + method + '()).' + comparison + ';',
    ];

    for (let codeSnippet of codeSnippets) {
        test.valid.push({
            code: codeSnippet
        });
    }

}

function fillInvalid(method, comparison) {
    const codeSnippets = [
        'some.expressions.' + method + '()).' + comparison + '; }',
        'another.epxression.' + method + '()).' + comparison + ';',
    ];

    for (let codeSnippet of codeSnippets) {
        test.invalid.push({
            code: codeSnippet,
            someMorStuff: 'goesHere'
        });
    }

}

for (let [method, comparisons] of Object.entries(methodsAndComparison)) {
    for (let comparison of comparisons.valid) {
        fillValid(method, comparison);
    }

    for (let comparison of comparisons.invalid) {
        fillInvalid(method, comparison);
    }
}

console.log(test);

Mir gefällt nicht, dass ich zweimal den Aufruf von einer fast identischen Funktion machen muss (fillValid und fillInvalid)
Jemand eine Idee wie ich das möglichst ohne Code-Duplication sauber hinkriege?

 

[new Account()]

Übergib doch test.invalid und test.valid einfach der Methode als Referenz.

Dann fügst die einfach in den container hinzu, den du als Argument bekommst.

Das somemoreStuff kannst du auch als Argument übergeben - sofern da nichts kompliziertes dahintersteckt.
Z.b. via https://stackoverflow.com/questions...mically-named-properties-to-javascript-object
Oder du übergibst ein Ojekt mit dem somemorestuff der Funktion, welche dieses Objekt dann in der Schleife kopiert und ergänzt (https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)
Eventuell ist auch der spread Operator ausreichend: https://thecodebarbarian.com/object-assign-vs-object-spread.html

 

[I'm unknown]

Man könnte die beiden Methode in eine mit einem bool als Übergabeparameter erweitern.

function fillValidationResult(method, comparison, invalid){
    if(invalid == true){
        ...
    }
    else{
        ...
    }
}

 

[Hendoul]

Habs jetzt mal noch so abgeändert:
https://jsfiddle.net/GarfieldKlon/a30nhr7e/

const test = {
    valid: [],
    invalid: []
};

const methodsAndComparison = {
    isPresent: {
        valid: ['toBe(true)', 'toEqual(true)'],
        invalid: ['toBe(false)', 'toEqual(false)'],
        someMoreStuff: {blub: 'blabla'}
    },
    isOpen: {
        valid: ['toBe(true)', 'toEqual(true)'],
        invalid: ['toBe(false)', 'toEqual(false)'],
        someMoreStuff: {blub: 'blabla'}
    }
};


function fill(method, {valid, invalid, someMoreStuff}) {
    const validCodeSnippets = [];
    const invalidCodeSnippets = [];

    for (const comparison of valid) {
        validCodeSnippets.push(
            'some.expressions.' + method + '()).' + comparison + '; }',
            'another.epxression.' + method + '()).' + comparison + ';'
        )
    }
    
    for (const comparison of invalid) {
        invalidCodeSnippets.push(
            'some.expressions.' + method + '()).' + comparison + '; }',
            'another.epxression.' + method + '()).' + comparison + ';'
        )
    }

    for (const validCodeSnippet of validCodeSnippets) {
        test.valid.push({
            code: validCodeSnippet
        });
    }
    
    for (const invalidCodeSnippet of invalidCodeSnippets) {
        test.invalid.push({
            code: invalidCodeSnippet,
            someMoreStuff
        });
    }

}

for (let [method, comparisons] of Object.entries(methodsAndComparison)) {
    fill(method, comparisons);
}

console.log(test);

Ist halt alles immer noch so ein bisschen doppelt gemoppelt mit den 4 for schleifen...

 

[new Account()]

Ich habe eigentlich Vorschläge in die Richtung gemacht - hast du die nicht verstanden?

Ich war mal so frei:

const test2 = {
    valid: [],
    invalid: []
};

const methodsAndComparison = {
    isPresent: {
        valid: ['toBe(true)', 'toEqual(true)'],
        invalid: ['toBe(false)', 'toEqual(false)']
    },
    isOpen: {
        valid: ['toBe(true)', 'toEqual(true)'],
        invalid: ['toBe(false)', 'toEqual(false)']
    }
};

function fill(array, method, comparison, additionalEntries) {
    const codeSnippets = [
        'some.expressions.' + method + '()).' + comparison + '; }',
        'another.epxression.' + method + '()).' + comparison + ';',
    ];

    for (let codeSnippet of codeSnippets) {
        array.push({
            code: codeSnippet,
                ...additionalEntries,
        });
    }
}


for (let [method, comparisons] of Object.entries(methodsAndComparison)) {
    for (let comparison of comparisons.valid) {
        fill(test2.valid, method, comparison, {});
    }

    for (let comparison of comparisons.invalid) {
        fill(test2.invalid, method, comparison, {
            someMorStuff: 'goesHere'
        });
    }
}
console.log(test2)

https://jsfiddle.net/6wv5c2q4/2/

Ergänzung (21. Februar 2020)

Eine weitere Alternative:

const test2 = {
    valid: [],
    invalid: []
};

const methodsAndComparison = {
    isPresent: {
        valid: ['toBe(true)', 'toEqual(true)'],
        invalid: ['toBe(false)', 'toEqual(false)']
    },
    isOpen: {
        valid: ['toBe(true)', 'toEqual(true)'],
        invalid: ['toBe(false)', 'toEqual(false)']
    }
};

function fill(array, method, comparison, generateObject) {
    const codeSnippets = [
        'some.expressions.' + method + '()).' + comparison + '; }',
        'another.epxression.' + method + '()).' + comparison + ';',
    ];

    for (let codeSnippet of codeSnippets) {
        array.push(generateObject(codeSnippet));
    }
}


for (let [method, comparisons] of Object.entries(methodsAndComparison)) {
    for (let comparison of comparisons.valid) {
        fill(test2.valid, method, comparison, codeSnippet => ({
            code: codeSnippet,
        }));
    }

    for (let comparison of comparisons.invalid) {
        fill(test2.invalid, method, comparison, codeSnippet => ({
            code: codeSnippet,
            someMorStuff: 'goesHere',
        }));
    }
}
console.log(test2)

https://jsfiddle.net/depLqc1k/

 

[new Account()]

Oder: https://jsfiddle.net/t1acwnzo/

 

[Hendoul]

Nein, sonst hätte ich es gleich so gemacht wie du
Danke, ich schau es mir gleich mal an
So sieht es gleich etwas übersichtlicher aus