Comparing JSON arrays in Typescript: A comprehensive guide

Question

Comparing JSON arrays in Typescript: A comprehensive guide

I'm currently facing an issue when trying to compare the array from a JSON file within a TypeScript function. The following code is in index.ts: Remember not to hard-code references to context variables like 'Profession'. Conditions can be nested at various levels. Try converting the condition into postfix-notation for easier evaluation.

import conditionInput from "./condition.json";

/**
 * Evaluate a condition against the context.
 * @param condition A DSL JSON object.
 * @param context An object of key-value pairs
 * @return boolean
 */
function evaluate(
  condition: typeof conditionInput,
  context: { [key: string]: string | undefined }
): boolean {
  // Your task is to implement this function to evaluate the imported condition.json with the given context. Variables prefixed with '$' should fetch their values from the context.
  // Hint 1: Do not hard-code references to context variables like 'Profession'
  // Hint 2: Conditions can be nested, n-levels deep
  // Convert the condition into postfix-notation
  
  // Ideally, one value must remain in the result stack with the last operation's result
  return false;
}

/**
 * Click "run" to execute the test cases, which should pass after your implementation.
 */
(function () {
  const cases = [
    {
      context: {
        State: "Alabama",
        Profession: "Software development",
      },
      expected: true,
    },
    {
      context: {
        State: "Texas",
      },
      expected: true,
    },
    {
      context: {
        State: "Alabama",
        Profession: "Gaming",
      },
      expected: false,
    },
    {
      context: {
        State: "Utah",
      },
      expected: false,
    },
    {
      context: {
        Profession: "Town crier",
      },
      expected: false,
    },
    {
      context: {
        Profession: "Tradesperson",
      },
      expected: true,
    },
  ];

  for (const c of cases) {
    const actual = evaluate(conditionInput, c.context);
    console.log(actual === c.expected ? "yay :-)" : "nay :-(");
  }
})();

The content of condition.json:

[
  "OR",
  [
    "AND",
    ["==", "$State", "Alabama"],
    ["==", "$Profession", "Software development"]
  ],
  ["AND", ["==", "$State", "Texas"]],
  ["OR", ["==", "$Profession", "Tradesperson"]]
]

javascript json typescript

Answer 1

Answer №1

function isConditionalOperator(toVerify) {
    switch (toVerify) {
        case 'AND':
        case 'OR':
            return true;
        default:
            return false;
    }
}

function isLogicalOperator(toCheck) {
    switch (toCheck) {
        case '==':
        case '<':
        case '>':
        case '<=':
        case '>=':
        case '!=':
            return true;
        default:
            return false;
    }
}

function calculate(a, operator, b) {
    return operator(a, b);
}

function symbolToOperator(symbol) {
    switch (symbol) {
        case '==': return doubleEqualsFunction;
        case '<': return lessThanFunction;
        case '>': return greaterThanFunction;
        case '>=': return lessThanOrEqualFunction;
        case '<=': return greaterThanOrEqualFunction;
        case '!=': return notEqualFunction;
        case 'OR': return orFunction;
        case 'AND': return andFunction;
    }
}

function andFunction(a, b) {return a && b; }
function orFunction(a, b) { return a || b; }
function notEqualFunction(a, b) { return a != b; }
function doubleEqualsFunction(a, b) { return a == b; }
function lessThanFunction(a, b) { return a < b; }
function greaterThanFunction(a, b) { return a > b; }
function lessThanOrEqualFunction(a, b) { return a <= b; }
function greaterThanOrEqualFunction(a, b) { return a >= b; }

function createPostfixNotationStack(arr: Array<any>, postfixConditionStack: Array<any>): Array<any> {
    arr.push(arr.shift());
    arr.forEach((element: any) => {
        if (element instanceof Array) {
            makePostfixNotationStack(element, postfixConditionStack);
        } else if ((element == 'OR' || element == 'AND') && arr.length > 2) {
            postfixConditionStack.push(element);
        } else if (arr.length == 3) {
            postfixConditionStack.push(element);
        }
    });
    return postfixConditionStack;
}


/**
 * Evaluate a condition against the context.
 * @param condition A domain-specific language (DSL) JSON object.
 * @param context An object of keys and values
 * @return boolean
 */
function assess(
    postfixConditionStack: Array<string>,
    context: { [key: string]: string | undefined }
    // count=0
): boolean {
    let postfixExecutionStack: any[] = ['|'];

    postfixConditionStack.forEach(function (current) {
        if (isLogicalOperator(current)) {
            let a = postfixExecutionStack.pop();
            let b = postfixExecutionStack.pop();
            let operator = symbolToOperator(current);
            if (typeof b == "string") {
                b = context[b.substring(1)];
            }
            postfixExecutionStack.push(
                compute(a, operator, b)
            );
        } else if (isConditionalOperator(current)) {
            let operator = symbolToOperator(current);

            postfixExecutionStack[postfixExecutionStack.length - 2] == '|' ? postfixExecutionStack.pop() : null;
            while (postfixExecutionStack[postfixExecutionStack.length - 2] != '|') {
                let a = postfixExecutionStack.pop();
                let b = postfixExecutionStack.pop();
                if (typeof b == "string") {
                    b = context[b.substring(1)];
                }
                postfixExecutionStack.push(
                    compute(a, operator, b)
                );
            };
            postfixExecutionStack[postfixExecutionStack.length - 2] != '|' ? postfixExecutionStack.push('|') : null;
        } else {
            postfixExecutionStack.push(current);
        }
    });

    return postfixExecutionStack[1];
    
    // Ideally, one value must remain in the result stack with the last operation's result
    //   return false;
}

/**
 * Click "run" to execute the test cases, which should pass after your implementation.
 */
(function () {
    const cases = [
        {
            context: {
                State: "Alabama",
                Profession: "Software development",
            },
            expected: true,
        },
        {
            context: {
                State: "Texas",
            },
            expected: true,
        },
        {
            context: {
                State: "Alabama",
                Profession: "Gaming",
            },
            expected: false,
        },
        {
            context: {
                State: "Utah",
            },
            expected: false,
        },
        {
            context: {
                Profession: "Town crier",
            },
            expected: false,
        },
        {
            context: {
                Profession: "Tradesperson",
            },
            expected: true,
        },
    ];

    let conditionInput = [
        "OR", [
            "AND", ["==", "$State", "Alabama"],
            ["==", "$Profession", "Software development"]
        ],
        ["AND", ["==", "$State", "Texas"]],
        ["OR", ["==", "$Profession", "Tradesperson"]]
    ];

    let postfixConditionStack: string[] = makePostfixNotationStack(conditionInput, []);
    
    for (const c of cases) {
        const actual = evaluate(postfixConditionStack, c.context);
        console.log(actual === c.expected ? "yay :-)" : "nay :-(");
    }
})();

Answer 2

function isConditionalOperator(toVerify) {
    switch (toVerify) {
        case 'AND':
        case 'OR':
            return true;
        default:
            return false;
    }
}

function isLogicalOperator(toCheck) {
    switch (toCheck) {
        case '==':
        case '<':
        case '>':
        case '<=':
        case '>=':
        case '!=':
            return true;
        default:
            return false;
    }
}

function calculate(a, operator, b) {
    return operator(a, b);
}

function symbolToOperator(symbol) {
    switch (symbol) {
        case '==': return doubleEqualsFunction;
        case '<': return lessThanFunction;
        case '>': return greaterThanFunction;
        case '>=': return lessThanOrEqualFunction;
        case '<=': return greaterThanOrEqualFunction;
        case '!=': return notEqualFunction;
        case 'OR': return orFunction;
        case 'AND': return andFunction;
    }
}

function andFunction(a, b) {return a && b; }
function orFunction(a, b) { return a || b; }
function notEqualFunction(a, b) { return a != b; }
function doubleEqualsFunction(a, b) { return a == b; }
function lessThanFunction(a, b) { return a < b; }
function greaterThanFunction(a, b) { return a > b; }
function lessThanOrEqualFunction(a, b) { return a <= b; }
function greaterThanOrEqualFunction(a, b) { return a >= b; }

function createPostfixNotationStack(arr: Array<any>, postfixConditionStack: Array<any>): Array<any> {
    arr.push(arr.shift());
    arr.forEach((element: any) => {
        if (element instanceof Array) {
            makePostfixNotationStack(element, postfixConditionStack);
        } else if ((element == 'OR' || element == 'AND') && arr.length > 2) {
            postfixConditionStack.push(element);
        } else if (arr.length == 3) {
            postfixConditionStack.push(element);
        }
    });
    return postfixConditionStack;
}


/**
 * Evaluate a condition against the context.
 * @param condition A domain-specific language (DSL) JSON object.
 * @param context An object of keys and values
 * @return boolean
 */
function assess(
    postfixConditionStack: Array<string>,
    context: { [key: string]: string | undefined }
    // count=0
): boolean {
    let postfixExecutionStack: any[] = ['|'];

    postfixConditionStack.forEach(function (current) {
        if (isLogicalOperator(current)) {
            let a = postfixExecutionStack.pop();
            let b = postfixExecutionStack.pop();
            let operator = symbolToOperator(current);
            if (typeof b == "string") {
                b = context[b.substring(1)];
            }
            postfixExecutionStack.push(
                compute(a, operator, b)
            );
        } else if (isConditionalOperator(current)) {
            let operator = symbolToOperator(current);

            postfixExecutionStack[postfixExecutionStack.length - 2] == '|' ? postfixExecutionStack.pop() : null;
            while (postfixExecutionStack[postfixExecutionStack.length - 2] != '|') {
                let a = postfixExecutionStack.pop();
                let b = postfixExecutionStack.pop();
                if (typeof b == "string") {
                    b = context[b.substring(1)];
                }
                postfixExecutionStack.push(
                    compute(a, operator, b)
                );
            };
            postfixExecutionStack[postfixExecutionStack.length - 2] != '|' ? postfixExecutionStack.push('|') : null;
        } else {
            postfixExecutionStack.push(current);
        }
    });

    return postfixExecutionStack[1];
    
    // Ideally, one value must remain in the result stack with the last operation's result
    //   return false;
}

/**
 * Click "run" to execute the test cases, which should pass after your implementation.
 */
(function () {
    const cases = [
        {
            context: {
                State: "Alabama",
                Profession: "Software development",
            },
            expected: true,
        },
        {
            context: {
                State: "Texas",
            },
            expected: true,
        },
        {
            context: {
                State: "Alabama",
                Profession: "Gaming",
            },
            expected: false,
        },
        {
            context: {
                State: "Utah",
            },
            expected: false,
        },
        {
            context: {
                Profession: "Town crier",
            },
            expected: false,
        },
        {
            context: {
                Profession: "Tradesperson",
            },
            expected: true,
        },
    ];

    let conditionInput = [
        "OR", [
            "AND", ["==", "$State", "Alabama"],
            ["==", "$Profession", "Software development"]
        ],
        ["AND", ["==", "$State", "Texas"]],
        ["OR", ["==", "$Profession", "Tradesperson"]]
    ];

    let postfixConditionStack: string[] = makePostfixNotationStack(conditionInput, []);
    
    for (const c of cases) {
        const actual = evaluate(postfixConditionStack, c.context);
        console.log(actual === c.expected ? "yay :-)" : "nay :-(");
    }
})();

Comparing JSON arrays in Typescript: A comprehensive guide

Answer №1

Similar questions

A guide to implementing angularjs app.service and $q in typescript

The attempt to establish a WebSocket connection to 'wss://******/socket.io/?EIO=4&transport=websocket&sid=T2Sf_4oNIisxKLwsAAAK' was unsuccessful

Double quotes (") are included in the JSONEncoder output when the input is a Python list containing strings

Maintaining the functionality of an AJAX web page even after extended periods of inactivity

Creating a custom useStorage hook to easily save a Set data type in local storage

Update two distinct object properties using a singular reference in Vue's set method

utilizing a spacemouse in conjunction with autodesk forge

Clearly defining the data types for static dictionary values, while also deducing the precise structure or at least the keys

Modify the height using JavaScript and then revert back to the initial CSS height

The ngTable feature in AngularJS fails to initiate the getData function when making an HTTP request

Is TypeScript declaration merging not functioning properly?

What are the methods to alter validation for a Formfield based on the input from other Formfields?

Test condition for the existence of field

Utilizing Angular 2: Implementing a template-driven form to send data from a chosen element to the submitting object

What could be the reason for the malfunction of Bootstrap Js in my template?

Creating a cross-platform file writer with PHP and JavaScript

Add a library to a server with npm installation

Tips on using AJAX to upload serialized posts:1. Serialize the post

Regular expression ignores the initial "less than" character

Footer content is displayed at the center of the page before anchoring itself to