PHP的json_encode分析

最新推荐文章于 2023-12-28 13:07:23 发布
最新推荐文章于 2023-12-28 13:07:23 发布
阅读量9.4k 收藏
点赞数 1
分类专栏： PHP C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/siren0203/article/details/8852257
版权
PHP 同时被 2 个专栏收录
72 篇文章 0 订阅
订阅专栏
C
17 篇文章 0 订阅
订阅专栏

json的优点就不说了，

有个习惯，我在输出json的时候，喜欢用 sprintf 拼成json格式，

前两天被朋友说不标准，必须要用json_encode生成的才是标准的json格式，我当然很郁闷啦，

用了这么多年了，刚知道 这样做不标准，既然说我不标准，那上面才是标准的json格式？

1
2
3
4
{a : 'abc' }
{ 'a' : 'abc' }
{a : "abc" }
{ "a" : "abc" }

那都知道，只有第四种才是标准的json格式。

我这么做

1
2
$ret_json = '{"%s":"%s"}' ;
echo json_encode( $ret_json , "a" , "abc" );

必然也符合标准。

既然如此，那我就要刨根问底，json_encode生成的json格式究竟有什么不同？
上代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
static PHP_FUNCTION(json_encode)
{
         zval *parameter;
         smart_str buf = {0};
         long options = 0;
 
         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|l" , &parameter, &options) == FAILURE) {
                 return ;
         }  
 
         JSON_G(error_code) = PHP_JSON_ERROR_NONE;
 
         php_json_encode(&buf, parameter, options TSRMLS_CC);
 
         ZVAL_STRINGL(return_value, buf.c, buf.len, 1);
 
         smart_str_free(&buf);
}


JSON_G(error_code) = PHP_JSON_ERROR_NONE;
是定义的json错误，该错误可以通过json_last_error函数获取，你用过吗？反正我没用过。
php_json_encode是主要的操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
PHP_JSON_API void php_json_encode(smart_str *buf, zval *val, int options TSRMLS_DC) /* {{{ */
{
         switch (Z_TYPE_P(val))
         {
                 case IS_NULL:
                         smart_str_appendl(buf, "null" , 4); //输出NULL
                         break ;
 
                 case IS_BOOL:
                         if (Z_BVAL_P(val)) {
                                 smart_str_appendl(buf, "true" , 4); //输出true
                         } else {
                                 smart_str_appendl(buf, "false" , 5); //输出false
                         }
                         break ;
 
                 case IS_LONG:
                         smart_str_append_long(buf, Z_LVAL_P(val)); //输出长整形的值
                         break ;
 
                 case IS_DOUBLE:
                         {
                                 char *d = NULL;
                                 int len;
                                 double dbl = Z_DVAL_P(val);
 
                                 if (!zend_isinf(dbl) && !zend_isnan(dbl)) { //非无穷尽
                                         len = spprintf(&d, 0, "%.*k" , ( int ) EG(precision), dbl);
                                         smart_str_appendl(buf, d, len);
                                         efree(d);
                                 } else {
                                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "double %.9g does not conform to the JSON spec, encoded as 0" , dbl);
                                         smart_str_appendc(buf, '0' );
                                 }
                        }
                         break ;
 
                 case IS_STRING: //字符串
                         json_escape_string(buf, Z_STRVAL_P(val), Z_STRLEN_P(val), options TSRMLS_CC);
                         break ;
 
                 case IS_ARRAY: //数组和对象
                 case IS_OBJECT:
                         json_encode_array(buf, &val, options TSRMLS_CC);
                         break ;
 
                 default :
                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "type is unsupported, encoded as null" );
                         smart_str_appendl(buf, "null" , 4);
                         break ;
         }
 
         return ;
}

很明显，根据不同的类型，会有相应的case。
最复杂的是 字符串 、数组 、对象这三种类型，数组和对象是同一种操作。
先看看字符串吧，很长，注释直接写在代码里。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
//options应该是5.3版本之后才支持的，由以下常量组成的二进制掩码： JSON_HEX_QUOT, JSON_HEX_TAG, JSON_HEX_AMP, JSON_HEX_APOS, JSON_NUMERIC_CHECK, JSON_PRETTY_PRINT, JSON_UNESCAPED_SLASHES, JSON_FORCE_OBJECT, JSON_UNESCAPED_UNICODE.虽然我没用过。。。
static void json_escape_string(smart_str *buf, char *s, int len, int options TSRMLS_DC) /* {{{ */
{
         int pos = 0;
         unsigned short us;
         unsigned short *utf16;
 
         if (len == 0) { //如果长度为0，则直接返回 双引号 ""
                 smart_str_appendl(buf, "\"\"" , 2);
                 return ;
         }
 
         if (options & PHP_JSON_NUMERIC_CHECK) { //检测是否为0-9的数字，如果是数字，那么就会直接把数据作为long或double类型返回。
                 double d;
                 int type;
                 long p;
 
                 if ((type = is_numeric_string(s, len, &p, &d, 0)) != 0) {
                         if (type == IS_LONG) {
                                 smart_str_append_long(buf, p);
                         } else if (type == IS_DOUBLE) {
                                 if (!zend_isinf(d) && !zend_isnan(d)) {
                                         char *tmp;
                                         int l = spprintf(&tmp, 0, "%.*k" , ( int ) EG(precision), d);
                                         smart_str_appendl(buf, tmp, l);
                                         efree(tmp);
                                 } else {
                                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "double %.9g does not conform to the JSON spec, encoded as 0" , d);
                                         smart_str_appendc(buf, '0' );
                                 }
                         }
                         return ;
                 }
 
         }
 
         utf16 = (unsigned short *) safe_emalloc(len, sizeof (unsigned short ), 0);
         len = utf8_to_utf16(utf16, s, len); //这里会对你输入的值一次处理转成对应的Dec码，比如1是49，a是97这样的，保存到utf16中。
         if (len <= 0) { //如果len小于0 说明出错。如果用json_encode处理GBK的编码，就会在这里挂掉。
                 if (utf16) {
                         efree(utf16);
                 }
                 if (len < 0) {
                         JSON_G(error_code) = PHP_JSON_ERROR_UTF8;
                         if (!PG(display_errors)) {
                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid UTF-8 sequence in argument" );
                         }
                         smart_str_appendl(buf, "null" , 4);
                 } else {
                         smart_str_appendl(buf, "\"\"" , 2);
                 }
                 return ;
         }
 
         smart_str_appendc(buf, '"' ); //输入 \"
 
//下面这一段代码就是将一些特殊字符转义如 双引号，反斜线等等
         while (pos < len)
         {
                 us = utf16[pos++];
 
                 switch (us)
                 {
                         case '"' :
                                 if (options & PHP_JSON_HEX_QUOT) {
                                         smart_str_appendl(buf, "\\u0022" , 6);
                                 } else {
                                         smart_str_appendl(buf, "\\\"" , 2);
                                 }
                                 break ;
 
                         case '\\' :
                                 smart_str_appendl(buf, "\\\\" , 2);
                                 break ;
case '/' :
                                 smart_str_appendl(buf, "\\/" , 2);
                                 break ;
 
                         case '\b' :
                                 smart_str_appendl(buf, "\\b" , 2);
                                 break ;
 
                         case '\f' :
                                 smart_str_appendl(buf, "\\f" , 2);
                                 break ;
 
                         case '\n' :
                                 smart_str_appendl(buf, "\\n" , 2);
                                 break ;
 
                         case '\r' :
                                 smart_str_appendl(buf, "\\r" , 2);
                                 break ;
 
                         case '\t' :
                                 smart_str_appendl(buf, "\\t" , 2);
                                 break ;
 
                         case '<' :
                                 if (options & PHP_JSON_HEX_TAG) {
                                         smart_str_appendl(buf, "\\u003C" , 6);
                                 } else {
                                         smart_str_appendc(buf, '<' );
                                 }
                                 break ;
 
                         case '>' :
                                 if (options & PHP_JSON_HEX_TAG) {
                                         smart_str_appendl(buf, "\\u003E" , 6);
                                 } else {
                                         smart_str_appendc(buf, '>' );
}
                                 break ;
 
                         case '&' :
                                 if (options & PHP_JSON_HEX_AMP) {
                                         smart_str_appendl(buf, "\\u0026" , 6);
                                 } else {
                                         smart_str_appendc(buf, '&' );
                                 }
                                 break ;
 
                         case '\'' :
                                 if (options & PHP_JSON_HEX_APOS) {
                                         smart_str_appendl(buf, "\\u0027" , 6);
                                 } else {
                                         smart_str_appendc(buf, '\'' );
                                 }
                                 break ;
 
                         default : //一直到这里，没有特殊字符就会把值append到buf中
                                 if (us >= ' ' && (us & 127) == us) {
                                         smart_str_appendc(buf, (unsigned char ) us);
                                 } else {
                                         smart_str_appendl(buf, "\\u" , 2);
                                         us = REVERSE16(us);
 
                                         smart_str_appendc(buf, digits[us & ((1 << 4) - 1)]);
                                         us >>= 4;
                                         smart_str_appendc(buf, digits[us & ((1 << 4) - 1)]);
                                         us >>= 4;
                                         smart_str_appendc(buf, digits[us & ((1 << 4) - 1)]);
                                         us >>= 4;
                                         smart_str_appendc(buf, digits[us & ((1 << 4) - 1)]);
                                 }
                                 break ;
                 }
         }
         smart_str_appendc(buf, '"' ); //结束 双引号。
         efree(utf16);
}

再来看看数组和对象，也很简单，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
static void json_encode_array(smart_str *buf, zval **val, int options TSRMLS_DC) /* {{{ */
{
         int i, r;
         HashTable *myht;
 
         if (Z_TYPE_PP(val) == IS_ARRAY) {
                 myht = HASH_OF(*val);
                 r = (options & PHP_JSON_FORCE_OBJECT) ? PHP_JSON_OUTPUT_OBJECT : json_determine_array_type(val TSRMLS_CC);
         } else {
                 myht = Z_OBJPROP_PP(val);
                 r = PHP_JSON_OUTPUT_OBJECT;
         }  
 
         if (myht && myht->nApplyCount > 1) {
                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "recursion detected" );
                 smart_str_appendl(buf, "null" , 4);
                 return ;
         }
//开始标签
         if (r == PHP_JSON_OUTPUT_ARRAY) {
                 smart_str_appendc(buf, '[' );
         } else {
                 smart_str_appendc(buf, '{' );
         }  
 
         i = myht ? zend_hash_num_elements(myht) : 0;
 
         if (i > 0)
         {
                 char *key;
                 zval **data;
                 ulong index;
                 uint key_len;
                 HashPosition pos;
                 HashTable *tmp_ht;
                 int need_comma = 0;
 
                 zend_hash_internal_pointer_reset_ex(myht, &pos);
//便利哈希表
                 for (;; zend_hash_move_forward_ex(myht, &pos)) {
                         i = zend_hash_get_current_key_ex(myht, &key, &key_len, &index, 0, &pos);
                         if (i == HASH_KEY_NON_EXISTANT)
                                 break ;
 
                         if (zend_hash_get_current_data_ex(myht, ( void **) &data, &pos) == SUCCESS) {
                                 tmp_ht = HASH_OF(*data);
                                 if (tmp_ht) {
                                         tmp_ht->nApplyCount++;
                                 }
 
                                 if (r == PHP_JSON_OUTPUT_ARRAY) {
                                         if (need_comma) {
                                                 smart_str_appendc(buf, ',' );
                                         } else {
                                                 need_comma = 1;
                                         }
//将值append到 buf中
                                         php_json_encode(buf, *data, options TSRMLS_CC);
                                 } else if (r == PHP_JSON_OUTPUT_OBJECT) {
                                         if (i == HASH_KEY_IS_STRING) {
                                                 if (key[0] == '\0' && Z_TYPE_PP(val) == IS_OBJECT) {
                                                         /* Skip protected and private members. */
                                                         if (tmp_ht) {
                                                                 tmp_ht->nApplyCount--;
                                                         }
                                                         continue ;
                                                 }
 
                                                 if (need_comma) {
                                                         smart_str_appendc(buf, ',' );
                                                 } else {
                                                         need_comma = 1;
                                                 }
 
                                                 json_escape_string(buf, key, key_len - 1, options & ~PHP_JSON_NUMERIC_CHECK TSRMLS_CC);
                                                 smart_str_appendc(buf, ':' );
 
                                                 php_json_encode(buf, *data, options TSRMLS_CC);
                                         } else {
                                                 if (need_comma) {
                                                         smart_str_appendc(buf, ',' );
                                                 } else {
                                                         need_comma = 1;
                                                 }
 
                                                 smart_str_appendc(buf, '"' );
                                                 smart_str_append_long(buf, ( long ) index);
                                                 smart_str_appendc(buf, '"' );
                                                 smart_str_appendc(buf, ':' );
 
                                                 php_json_encode(buf, *data, options TSRMLS_CC);
                                         }
                                 }
 
                                 if (tmp_ht) {
                                         tmp_ht->nApplyCount--;
                                 }
                         }
                 }
         }
//结束标签
         if (r == PHP_JSON_OUTPUT_ARRAY) {
                 smart_str_appendc(buf, ']' );
         } else {
                 smart_str_appendc(buf, '}' );
         }
}

通过简单分析，证明了一个问题，跟我上面用sprintf的方法其实是一样的，都是拼接字符串，

而且 为了性能，更应该鼓励用sprintf来拼接json格式，

因为 json_encode会进行很多 循环操作，而且所消耗的性能是线性的 O(n^2)。 ^.^

当然，此文只是在客观情况下分析了最简单的情况，如果数据是数组或者其他复杂的数据，当然还是建议用json_encode来做。

siren0203
关注
专栏目录
php中json_encode的[]与{}
gdali的专栏
06-26 2228
如果PHP数组的键都是数字或者空数组，那么json_encode()返回一个数组形式的Json，如果PHP数组的键全是字符串。那么json_encode()就会返回一个对象形式的Json。两者在js中的调用是不同的。 事实上，只要在PHP数组的键中有一个字符串形式的键，那么json_encode()就会返回对象形式的Json一个对象，而对象是不可能以数字作为属性名的。 $array = ar...
php中json_encode不兼容JSON_UNESCAPED_UNICODE的解决方案
10-22
在讨论解决PHP中json_encode函数不兼容JSON_UNESCAPED_UNICODE参数的问题之前，首先我们需要了解json_encode函数以及JSON_UNESCAPED_UNICODE参数的作用。json_encode是PHP内置函数，它用于将PHP值转换为JSON格式的...
php数组使用json_encode函数中文被编码成null的原因和解决办法
热门推荐
shrimpma的专栏
05-21 1万+
json格式在开发中用的十分广泛。在php中json_encode函数可以直接将数组转成 json格式，十分方便。但是有可能你在使用json_encode函数时，无奈的发现中文被编码成null了。原来json只支持转义utf-8编码格式的中文。php数组使用json_encode函数中文被编码成null的原因是转义gbk 或者别的编码时，中文被忽略了。一般出现在文档编码或者输出的内容编码是非UTF
json_encode()为null，引发的json相关总结
beyond__devil的博客
11-21 2812
上次使用 json_decode() 解析从前端复制过来的json数据，发现怎么都解析不出来，查看json格式，发现没问题啊！ /* 注意： 之前碰过同样的问题，有可能是实体引起的！但那应该是针对从其他地方接收到的变量，而非是复制过来的字符串！ 碰到这种问题，可以使用 html_entity_decode() */ 下面黏贴下，我复制过的大概的字符串：
转:PHP的json_encode分析--获取Json错误的方法json_last_error
weixin_33722405的博客
03-28 205
json的优点就不说了， 有个习惯，我在输出json的时候，喜欢用 sprintf 拼成json格式， 前两天被朋友说不标准，必须要用json_encode生成的才是标准的json格式，我当然很郁闷啦， 用了这么多年了，刚知道 这样做不标准，既然说我不标准，那上面才是标准的json格式？ {a : 'abc'} {'a' : 'abc'} {a : "abc"} {"a" : "ab...
php u003e,PHP的json_encode分析
weixin_32635501的博客
03-24 1559
json的优点就不说了， 有个习惯，我在输出json的时候，喜欢用 sprintf 拼成json格式， 前两天被朋友说不标准，必须要用json_encode生成的才是标准的json格式，我当然很郁闷啦， 用了这么多年了，刚知道 这样做不标准，既然说我不标准，那上面才是标准的jsonjson的优点就不说了，　　有个习惯，我在输出json的时候，喜欢用 sprintf 拼成json格式，前两天被朋友说...
浅析PHP中json_encode与json_decode的区别
12-17
一、json_encode() 对变量进行JSON编码 语法：json_encode($value[,$options=0]) 注意： 1、$value为要编码的值，且该函数只对UTF8编码的数据有效； 2、options:由以下常量组成的二进制掩码：JSON_HEX_QUOT, ...
java解析php函数json_encode unicode 编码问题
10-22
本文重点讲解了在使用PHP函数json_encode进行JSON编码时出现的unicode编码问题，以及Java客户端如何正确解析由PHP生成的JSON字符串。 首先，我们了解到json_encode函数的作用是将PHP变量转换为JSON格式的字符串。这...
PHP中让json_encode不自动转义斜杠“/”的方法
10-20
PHP中的json_encode函数是一个常用的函数，用于将数组或对象转换成JSON格式的字符串。然而，在默认情况下，json_encode函数会对某些特殊字符进行转义，比如斜杠“/”在JSON字符串中会被转义为“\/”。这种转义行为在...
【PHP】 json_encode 函数各个参数的解释
最新发布
q8688的博客
12-28 1869
json_encode 函数在 PHP 中用于将一个值转换为 JSON 格式字符串。这个函数可以接受几个可选参数来控制输出的格式和内容。这些参数可以帮助你根据特定的需求来定制 json_encode 函数的输出。希望这些信息能帮助你！
php中容易出错的小案例
tiancityycf的专栏
12-09 169
参考：https://www.phpmianshi.com/?id=193 sprintf 用到sprintf 的时候 如果有传递的变量 如果变量可能出现 % ，则容易出错 <?php $content="%')('%s'"; $kind=11; $content=sprintf($content,$kind); var_dump($content); //输出 PHPWarning:sprintf():Toofewargumentsin/home...
【代码】PHP的json_encode详解分析
11-15 3437
json的优点就不说了， 有个习惯，我在输出json的时候，喜欢用 sprintf 拼成json格式， 前两天被朋友说不标准，必须要用json_encode生成的才是标准的json格式，我当然很郁闷啦， 用了这么多年了，刚知道 这样做不标准，既然说我不标准，那上面才是标准的json格式？ {a : 'abc'} {'a' : 'abc'} {a : "abc
类json格式字符串打印
weixin_30349597的博客
12-13 728
package main import ( "fmt" ) func main() { msg := "{Amount:21111111 DrawalBankHolder:刘成友 DrawalBankNo:6212264100011335366 DrawalSn:5112118111111690 DrawalTime:2018-11-30T00:00:00+0...
php中json_encode和json_decode的错误处理
涛的博客
09-11 6778
在php中，json_encode和json_decode是很常用的函数，具体用法可以查看相关文档，这里主要说一下错误处理。 平时我们在使用这两个方法的时候可能没怎么注意错误处理，有时候如果传入的参数格式不正确就会导致报错了。下面是错误处理的方式： json_last_error — 返回最后发生的错误，如果有，返回 JSON 编码解码时最后发生的错误。 int json_last_err...
上传JSON格式文件字符串处理
普通读者_博客
05-18 445
根据要求编写字符串 如要求格式如下： "{"%s":{"%s%d":{"%04d-%02d-%02dT%02d:%02d:%02d.%03dZ":"%0.2f,%0.2f,%0.2f,%0.2f,%0.2f"}}}"， 但是直接sprintf这个直接上传不可行，因为"这个字符被认定为起始结束字符，所以需要对格式里含这个的字符进行转译，方式就是直接在字符前添加\反斜杠，如下所示： "{\"%s\":{\"%s%d\":{\"%04d-%02d-%02dT%02d:%02d:%02d.%03dZ\":\"%0.
cJSON文件
cumtchw
09-15 260
//cJSON.h /* Copyright (c) 2009 Dave Gamble Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值