In-depth Analysis and Solution for JSON.stringify Returning "[object Object]"

Problem Background and Phenomenon Analysis

In JavaScript development, JSON.stringify is a standard method widely used to convert objects into JSON strings. However, developers sometimes encounter a confusing issue: after calling JSON.stringify, the returned string is "[object Object]" instead of the expected object content. For example, in the following code:

var theObject = {name:{firstName:"Mark", lastName:"Bob"}};
alert(JSON.stringify(theObject.toString())); // outputs "[object Object]"

Here, alert displays "[object Object]", which is not a valid JSON representation but the default return value of the object's toString method. This phenomenon often stems from misunderstanding or misuse of the JSON.stringify method.

Root Cause and Solution

The core issue lies in incorrectly calling theObject.toString(). In JavaScript, an object's toString method defaults to returning the string "[object Object]", indicating the object's type identifier. When JSON.stringify receives this string as a parameter, it directly serializes it into a JSON string, resulting in "[object Object]". The correct approach is to pass the object itself to JSON.stringify, as shown below:

var theObject = {name:{firstName:"Mark", lastName:"Bob"}};
alert(JSON.stringify(theObject)); // correctly outputs JSON string

This way, JSON.stringify recursively traverses the object's properties, generating a JSON string like {"name":{"firstName":"Mark","lastName":"Bob"}}. This solution is based on the best answer, scored 10.0, ensuring proper application of the method.

Core Mechanism of JSON.stringify

To deeply understand this issue, it is essential to explore how JSON.stringify works. This method takes a JavaScript value (typically an object or array) as a parameter and returns its JSON string representation. It processes the input through the following steps:

1. If the value is a primitive type (e.g., string, number, boolean, null), it is directly converted to the corresponding JSON string.
2. If the value is an object or array, it recursively serializes all enumerable properties, ignoring functions and undefined values.
3. If the object defines a toJSON method, that method is called to obtain custom serialization results.

In the problem case, since the string returned by theObject.toString() was passed, JSON.stringify treated it as a primitive string, leading to unexpected output. This highlights the importance of understanding parameter types.

Advanced Applications and Common Pitfalls

Beyond basic usage, JSON.stringify supports optional parameters, such as the replacer function and space parameter, to control the serialization process. For example, using replacer can filter or transform property values:

var obj = {a: 1, b: 2, c: 3};
var jsonString = JSON.stringify(obj, function(key, value) {
    if (key === "b") return undefined; // ignore property b
    return value;
});
console.log(jsonString); // outputs {"a":1,"c":3}

Common pitfalls include handling circular references and special values. For instance, if an object contains circular references, JSON.stringify will throw an error. Developers can use libraries like Lodash's _.cloneDeep or custom logic to avoid this issue. Additionally, for strings containing HTML tags, care must be taken to escape them to prevent incorrect parsing in output. For example, in text nodes, <br> should be escaped as <br> to maintain semantic correctness.

Supplementary References and Other Answers

While the best answer directly solves the problem, other answers may provide additional insights. For example, some discussions might involve using JSON.parse to validate output or handling non-standard objects like Date and RegExp. In the case of Date objects, JSON.stringify defaults to converting them to ISO strings, but this can be customized via the toJSON method. These supplementary knowledge points help developers apply JSON technology more comprehensively.

Summary and Best Practices

In summary, the issue of JSON.stringify returning "[object Object]" typically arises from mistakenly passing the result of an object's toString method as a parameter. The correct method is to pass the object directly, allowing JSON.stringify to handle serialization. Developers should master the core mechanisms of the method, including parameter handling, optional features, and common pitfalls, to ensure reliable use in complex scenarios. By following these practices, common errors can be avoided, improving code quality and maintainability.