Type Feedback System in JavaScript

This challenge asks you to build a simple type feedback system in JavaScript. Such a system is useful for catching potential type-related errors early in development, especially in dynamically typed languages like JavaScript where type checking isn't enforced at runtime by default. The goal is to create a function that analyzes a given expression and provides feedback on the expected and actual types, highlighting potential mismatches.

Problem Description

You need to implement a function called typeFeedback that takes an expression and a type as input. The expression can be a simple JavaScript expression (e.g., a variable, a literal, a simple arithmetic operation). The type is a string representing the expected type (e.g., "number", "string", "boolean", "array", "object"). The function should evaluate the expression and return a feedback string indicating whether the expression's actual type matches the expected type.

Key Requirements:

• Expression Evaluation: The function must be able to evaluate the expression. For simplicity, assume the expression is safe to evaluate (no malicious code).
• Type Detection: The function must accurately determine the actual type of the evaluated expression.
• Feedback Generation: The function must generate a clear and informative feedback string.
• Error Handling: Handle cases where the expression is invalid or cannot be evaluated.

Expected Behavior:

• If the actual type matches the expected type, return a success message.
• If the actual type does not match the expected type, return an error message indicating the mismatch.
• If the expression is invalid or cannot be evaluated, return an error message indicating the issue.

Edge Cases to Consider:

• undefined and null values.
• Empty arrays and objects.
• Expressions involving functions (for this challenge, treat function calls as "object" type).
• Complex objects with nested properties (only check the top-level type).
• Expressions that result in errors during evaluation.

Examples

Example 1:

Input: { expression: "5 + 3", type: "number" }
Output: "Success: Expression '5 + 3' evaluated to a number."
Explanation: The expression "5 + 3" evaluates to 8, which is a number, matching the expected type.

Example 2:

Input: { expression: "hello", type: "number" }
Output: "Error: Expression 'hello' evaluated to a string, but a number was expected."
Explanation: The expression "hello" evaluates to the string "hello", which does not match the expected type of "number".

Example 3:

Input: { expression: "true", type: "boolean" }
Output: "Success: Expression 'true' evaluated to a boolean."
Explanation: The expression "true" evaluates to the boolean value true, matching the expected type.

Example 4:

Input: { expression: "myVariable", type: "string" }
Output: "Error: Expression 'myVariable' evaluated to undefined, but a string was expected."
Explanation: Assuming 'myVariable' is not defined, the expression evaluates to undefined, which doesn't match the expected string type.

Example 5:

Input: { expression: "[1, 2, 3]", type: "array" }
Output: "Success: Expression '[1, 2, 3]' evaluated to an array."
Explanation: The expression "[1, 2, 3]" evaluates to an array, matching the expected type.

Constraints

• The expression string will be a valid JavaScript expression that can be safely evaluated.
• The type string will be one of: "number", "string", "boolean", "array", or "object".
• The function should return a string within 0.1 seconds for any valid input.
• The expression will not contain any user-provided input to prevent security vulnerabilities.

Notes

• You can use typeof to determine the type of a variable. However, be mindful of its limitations (e.g., typeof [] returns "object").
• Consider using Array.isArray() to specifically check if a value is an array.
• Use a try...catch block to handle potential errors during expression evaluation.
• Focus on providing clear and informative feedback messages.
• This is a simplified type feedback system. Real-world type checking systems are much more complex.