What does json.stringify() do?

json.stringify() is used to convert JavaScript objects or values ​​to JSON strings. If a replacer function is specified, the value can be optionally replaced, or the specified replacer is an array, then the value can be optionally replaced. Contains only the attributes specified by the array.

Related recommendations: "javascript video tutorial"

JavaScript JSON.stringify()

The JSON.stringify() method is used to convert JavaScript values ​​into JSON strings.

Syntax

JSON.stringify(value[, replacer[, space]])

Parameter description:

value: required, the JavaScript value to be converted (usually an object or array).

replacer: optional. The function or array used to convert the result.

• If replacer is a function, JSON.stringify will call the function, passing in the key and value of each member. Use the return value instead of the original value. If this function returns undefined, the member is excluded. The key of the root object is an empty string: "".

• If replacer is an array, only members with key values ​​in the array are converted. Members are converted in the same order as the keys in the array.

space: Optional, the text adds indentation, spaces and newlines. If space is a number, the return value text is indented by the specified number of spaces at each level. If space If greater than 10, the text is indented 10 spaces. Space can also use non-digits, such as: \t.

Return value:

Returns a string containing JSON text.

Example description

Note: The following output results are all of string type. In order to make it easier to read, single quotes '' are not used to indicate that they are String type

1. Only one parameter

The parameter is an object:

var students = new Array();
students[0] = "pika";
students[1] = "hello";
students[2] = "hey";
var json = JSON.stringify(students);
alert(json);

Output result:

["pika","hello","hey"]

If JSON is not used .stringify() function, directly alert(students), then

Output result:

pika,hello,hey

From here to comparison, you can more intuitively see the role of the JSON.stringify() function

Look at other examples:

JSON.stringify({});                        // 输出结果：{}
JSON.stringify(true);                      // 输出结果：true
JSON.stringify("foo");                     // 输出结果："foo"
JSON.stringify([1, "false", false]);       // 输出结果：[1,"false",false]
JSON.stringify({ x: 5 });                  // 输出结果：{"x":5}

JSON.stringify({x: 5, y: 6});              
//输出结果：{"x":5,"y":6}

JSON.stringify([new Number(1), new String("false"), new Boolean(false)]); 
//输出结果：[1,"false",false]

It can be seen from these examples: Boolean values, numbers, and string packaging objects will be automatically converted into the corresponding original values ​​during the serialization process

Look at other examples:

JSON.stringify({x: undefined, y: Object, z: Symbol("")}); 
// 输出结果：{}

JSON.stringify([undefined, Object, Symbol("")]);          
// 输出结果：[null,null,null]'

JSON.stringify({[Symbol("foo")]: "foo"});                 
// 输出结果：{}

JSON.stringify({[Symbol.for("foo")]: "foo"}, [Symbol.for("foo")]);
// 输出结果：{}

JSON.stringify(
    {[Symbol.for("foo")]: "foo"}, 
    function (k, v) {
        if (typeof k === "symbol"){
            return "a symbol";
        }
    }
);
//输出结果：undefined

It can be seen from these examples: undefined, arbitrary functions and symbol values ​​will be ignored during the serialization process (appearing in attribute values ​​​​of non-array objects in) or converted to null (when appearing in an array)

Look at the last example again

JSON.stringify( 
    Object.create(
        null, 
        { 
            x: { value: 'x', enumerable: false }, 
            y: { value: 'y', enumerable: true } 
        }
    )
);

As can be seen from the example: non-enumerable properties will be ignored

2. There are two parameters. The second parameter is a function.

Function example:

 function replacer(key, value) {
  if (typeof value === "string") {
    return undefined;
  }
  return value;
}

It can be seen that there is a key value and a value value. Remember what I said at the beginning Is the second parameter used as the key value?

Example:

function replacer(key, value) {
  if (typeof value === "string") {
    return undefined;
  }
  return value;
}

var foo = {foundation: "Mozilla", model: "box", week: 45, transport: "car", month: 7};
var jsonString = JSON.stringify(foo, replacer);
//输出结果：{"week":45,"month":7}

is to pass the first value to the function for related processing

2. There are two parameters, the second parameter is an array

The first parameter is an array

var students = new Array();
students[0] = "pika";
students[1] = "hello";
students[2] = "hey";
var stu= new Array();
stu[0] = "how";
stu[1] = "are";
stu[2] = "u";
var json = JSON.stringify(students,stu);
alert(json);
//输出结果：["pika","hello","hey"]

The result is that only the first value is serialized, and the second one is ignored

The first parameter is The value of the object

var students = new Object();
students.name = "pika";
students.age = 19;
students.qq = "12345678";
var stu= new Array();
stu[0] = "name";
stu[1] = "qq";
var json = JSON.stringify(students,stu);
alert(json);
//输出结果：{"name":"pika","qq":"12345678"}

array represents the attribute name that will be serialized into a JSON string

The stu array does not have "age", so the "age" attribute of the students object is not displayed

There are three parameters

As mentioned earlier, the third parameter is used to indent or directly add a string in front of the serialized object, so just look at the example. Note that at most Can be 10 indents or characters

JSON.stringify({ a: 2 }, null, " ");   
// 输出结果：{\n "a": 2\n}

JSON.stringify({ uno: 1, dos : 2 }, null, '\t')
/* 输出结果：
{
    "uno": 1,
    "dos": 2
}
*/

var students = new Object();
students.name = "pika";
students.age = 19;
students.qq = "12345678";
var stu= new Array();
stu[0] = "name";
stu[1] = "qq";
var json = JSON.stringify(students,stu,"test")
alert(json);
/* 输出结果：
{
test"name": "pika",
test"qq": "12345678"
}
*/

Summary

Finally, to summarize, the JSON.stringify() function is used to serialize objects Yes, no matter what is input, the output is of string type. You can customize how to serialize and what the format of the output result is according to your own needs.

For more programming-related knowledge, please visit: Programming study! !

The above is the detailed content of What does json.stringify() do?. For more information, please follow other related articles on the PHP Chinese website!