当前位置：首页 > PHP教程 > php高级应用 > 列表

源码分析系列之json_encode()如何转化一个对象

发布:smiling　来源: PHP粉丝网 　添加日期：2022-04-23 18:05:58　浏览: 评论：0　

json_encode()如何转化一个对象？ 使用 json_encode() 将数组 array 转化成 json 字符串我们都已经很熟悉了。

那么使用 json_encode() 转化一个对象是什么样的过程呢？

初步测试

我们需要新建一个具有多种属性的对象

新建 JsonTest

  1. class JsonTest 
  2. { 
  3.     public const TEST = 'c'; 
  4.     public $a = 'a'; 
  5.     public static $b = 'b'; 
  6.     protected $e = 'e'; 
  7.     private $d = 'd'; 
  8.    
  9.     protected function test1() 
  10.     { 
  11.         return __FUNCTION__; 
  12.     } 
  13.    
  14.     private function test2() 
  15.     { 
  16.         return __FUNCTION__; 
  17.     } 
  18.    
  19.     public function test3() 
  20.     { 
  21.         return __FUNCTION__; 
  22.     } 
  23.    
  24.     public static function test4() 
  25.     { 
  26.         return __FUNCTION__; 
  27.     } 
  28. } 

执行 打印结果

echo json_encode(new JsonTest());

输出

{ "a": "a" }

可以看得出，只有公开非静态的属性被打印出来了，其他东西（常量、私有变量、方法等等）都丢失了。

思考

在实际的应用中，多数情况下，我们的属性都是非公开的，但是我们又想在执行 json_encode() 的时候将它打印出来，该怎么办呢？

JsonSerializable

JsonSerializable 是一个 PHP 的 JSON 序列化接口

官方定义

JSON 序列化接口

(PHP 5 >= 5.4.0, PHP 7)

简介

实现 JsonSerializable 的类可以 在 json_encode() 时定制他们的 JSON 表示法。

接口摘要

  1. JsonSerializable { 
  2.     /* 方法 */ 
  3.     abstract public jsonSerialize ( void ) : mixed 
  4. }<br data-filtered="filtered"> 

可以看出 php 版本低于 5.4 是没有这个接口的

修改 JsonTest 继续测试

修改 JsonTest 让它实现 JsonSerializable，并为其写一个 jsonSerialize 方法

  1. class JsonTest implements JsonSerializable 
  2. { 
  3.     public const TEST = 'c'; 
  4.     public $a = 'a'; 
  5.     public static $b = 'b'; 
  6.     protected $e = 'e'; 
  7.     private $d = 'd'; 
  8.    
  9.     protected function test1() 
  10.     { 
  11.         return __FUNCTION__; 
  12.     } 
  13.    
  14.     private function test2() 
  15.     { 
  16.         return __FUNCTION__; 
  17.     } 
  18.    
  19.     public function test3() 
  20.     { 
  21.         return __FUNCTION__; 
  22.     } 
  23.    
  24.     public static function test4() 
  25.     { 
  26.         return __FUNCTION__; 
  27.     } 
  28.    
  29.     public function jsonSerialize() 
  30.     { 
  31.         $json = array(); 
  32.         foreach ($this as $key => $value) { 
  33.             $json[$key] = $value; 
  34.         } 
  35.         return $json; 
  36.     } 
  37. }<br data-filtered="filtered"> 

执行 打印结果

echo json_encode(new JsonTest());

输出

{ "a": "a", "e": "e", "d": "d" }

可以看得出，公开属性和私有属性都被打印出来了，方法，常量以及静态变量没有打印出来（这是因为类(class)中静态变量和常量的实现方式是所有对象共享的，并不具体属于某个类）

源码分析

这部分源码较多，我会按照源码中的 function 来一个一个进行分析，注意看代码块中的注释。

里边对应有一些 option 的位运算，我先贴出来每个 option 常量对应的值， << 是左移

  1. /* json_encode() options */ 
  2. #define PHP_JSON_HEX_TAG                    (1<<0) 
  3. #define PHP_JSON_HEX_AMP                    (1<<1) 
  4. #define PHP_JSON_HEX_APOS                   (1<<2) 
  5. #define PHP_JSON_HEX_QUOT                   (1<<3) 
  6. #define PHP_JSON_FORCE_OBJECT               (1<<4) 
  7. #define PHP_JSON_NUMERIC_CHECK              (1<<5) 
  8. #define PHP_JSON_UNESCAPED_SLASHES          (1<<6) 
  9. #define PHP_JSON_PRETTY_PRINT               (1<<7) 
  10. #define PHP_JSON_UNESCAPED_UNICODE          (1<<8) 
  11. #define PHP_JSON_PARTIAL_OUTPUT_ON_ERROR    (1<<9) 
  12. #define PHP_JSON_PRESERVE_ZERO_FRACTION     (1<<10) 
  13. #define PHP_JSON_UNESCAPED_LINE_TERMINATORS (1<<11)<br data-filtered="filtered"> 

函数本身

  1. PHP_JSON_API int php_json_encode(smart_str *buf, zval *val, int options) /* {{{ */ 
  2. { 
  3.     return php_json_encode_ex(buf, val, options, JSON_G(encode_max_depth)); 
  4. } 
  5. PHP_JSON_API int php_json_encode_ex(smart_str *buf, zval *val, int options, zend_long depth) /* {{{ */ 
  6. { 
  7.     php_json_encoder encoder; 
  8.     int return_code; 
  9.     // 初始化，开辟内存空间 
  10.     php_json_encode_init(&encoder); 
  11.     encoder.max_depth = depth; 
  12.     // 真正用于编码的函数体 
  13.     return_code = php_json_encode_zval(buf, val, options, &encoder); 
  14.     JSON_G(error_code) = encoder.error_code; 
  15.     return return_code; 
  16. } 
  17. /* }}} */<br data-filtered="filtered"> 

可以看出真正的编码函数是 php_json_encode_zval()

php_json_encode_zval()

smart_str_appendl() 是一个拼接字符串的函数，第三个参数是字符串的长度

buf 就是最终要返回的 json 字符串

  1. int php_json_encode_zval(smart_str *buf, zval *val, int options, php_json_encoder *encoder) /* {{{ */ 
  2. { 
  3. again: 
  4.     switch (Z_TYPE_P(val)) 
  5.     { 
  6.         case IS_NULL: 
  7.             smart_str_appendl(buf, "null", 4); 
  8.             break; 
  9.         case IS_TRUE: 
  10.             smart_str_appendl(buf, "true", 4); 
  11.             break; 
  12.         case IS_FALSE: 
  13.             smart_str_appendl(buf, "false", 5); 
  14.             break; 
  15.         case IS_LONG: 
  16.             smart_str_append_long(buf, Z_LVAL_P(val)); 
  17.             break; 
  18.         case IS_DOUBLE: 
  19.             if (php_json_is_valid_double(Z_DVAL_P(val))) { 
  20.                 php_json_encode_double(buf, Z_DVAL_P(val), options); 
  21.             } else { 
  22.                 encoder->error_code = PHP_JSON_ERROR_INF_OR_NAN; 
  23.                 smart_str_appendc(buf, '0'); 
  24.             } 
  25.             break; 
  26.         case IS_STRING: 
  27.             return php_json_escape_string(buf, Z_STRVAL_P(val), Z_STRLEN_P(val), options, encoder); 
  28.         case IS_OBJECT: 
  29.             // 如果对象实现了JsonSerializable，就将对象中的jsonSerialize()返回的结果进行编码 
  30.             if (instanceof_function(Z_OBJCE_P(val), php_json_serializable_ce)) { 
  31.                 return php_json_encode_serializable_object(buf, val, options, encoder); 
  32.             } 
  33.             // 如果对象没有实现了JsonSerializable，就执行下边的这个php_json_encode_array() 
  34.             /* fallthrough -- Non-serializable object */ 
  35.         case IS_ARRAY: 
  36.             // 解析数组 
  37.             return php_json_encode_array(buf, val, options, encoder); 
  38.         case IS_REFERENCE: 
  39.             //忽略引用 
  40.             val = Z_REFVAL_P(val); 
  41.             goto again; 
  42.         default: 
  43.             encoder->error_code = PHP_JSON_ERROR_UNSUPPORTED_TYPE; 
  44.             if (options & PHP_JSON_PARTIAL_OUTPUT_ON_ERROR) { 
  45.                 smart_str_appendl(buf, "null", 4); 
  46.             } 
  47.             return FAILURE; 
  48.     } 
  49.     return SUCCESS; 
  50. } 
  51. /* }}} */ 

php_json_encode_array()

这个函数递归编码数组及没有实现JsonSerializable()的对象（只编码对象的公开属性）。

  1. static int php_json_encode_array(smart_str *buf, zval *val, int options, php_json_encoder *encoder) /* {{{ */ 
  2. { 
  3.     int i, r, need_comma = 0; 
  4.     HashTable *myht; 
  5.     // r用来表示输出 `json` 的结构类型是数组还是对象 
  6.     // 只有自然排序的数组（['a','b','c']）才有可能被输出为数组（考虑option可能为JSON_FORCE_OBJECT） 
  7.     if (Z_TYPE_P(val) == IS_ARRAY) { 
  8.         // 如果是数组 
  9.         myht = Z_ARRVAL_P(val); 
  10.         // options中有JSON_FORCE_OBJECT 就强制输出对象，否则就判断数组是不是自然数组 
  11.         r = (options & PHP_JSON_FORCE_OBJECT) ? PHP_JSON_OUTPUT_OBJECT : php_json_determine_array_type(val); 
  12.     } else { 
  13.         myht = Z_OBJPROP_P(val); 
  14.         //对象就是输出对象 
  15.         r = PHP_JSON_OUTPUT_OBJECT; 
  16.     } 
  17.     if (myht && ZEND_HASH_GET_APPLY_COUNT(myht) > 0) { 
  18.         encoder->error_code = PHP_JSON_ERROR_RECURSION; 
  19.         smart_str_appendl(buf, "null", 4); 
  20.         return FAILURE; 
  21.     } 
  22.     PHP_JSON_HASH_APPLY_PROTECTION_INC(myht); 
  23.     if (r == PHP_JSON_OUTPUT_ARRAY) { 
  24.         //输出为数组 就用 [ 做开头 
  25.         smart_str_appendc(buf, '['); 
  26.     } else { 
  27.         //输出为对象 就用 { 做开头 
  28.         smart_str_appendc(buf, '{'); 
  29.     } 
  30.     // 当前递归的深度 
  31.     ++encoder->depth; 
  32.     // zend_hash_num_elements 返回哈希表中元素的数量 
  33.     i = myht ? zend_hash_num_elements(myht) : 0; 
  34.     if (i > 0) { 
  35.         zend_string *key; 
  36.         zval *data; 
  37.         zend_ulong index; 
  38.         //遍历当前维度的数组 如果当前元素不是数组 
  39.         ZEND_HASH_FOREACH_KEY_VAL_IND(myht, index, key, data) { 
  40.             // ↓ begin 从这里开始都是判断key怎么处理以及元素末尾怎么处理  ↓↓↓↓ 
  41.             if (r == PHP_JSON_OUTPUT_ARRAY) { 
  42.                 //need_comma初始值是0 
  43.                 if (need_comma) { 
  44.                     smart_str_appendc(buf, ','); 
  45.                 } else { 
  46.                     need_comma = 1; 
  47.                 } 
  48.                 //这两个方法是option中有JSON_PRETTY_PRINT的时候才会执行的 
  49.                 php_json_pretty_print_char(buf, options, '\n'); 
  50.                 php_json_pretty_print_indent(buf, options, encoder); 
  51.             } else if (r == PHP_JSON_OUTPUT_OBJECT) { 
  52.                 if (key) { 
  53.                     if (ZSTR_VAL(key)[0] == '\0' && ZSTR_LEN(key) > 0 && Z_TYPE_P(val) == IS_OBJECT) { 
  54.                         //跳过受保护的属性和私有属性 
  55.                         /* Skip protected and private members. */ 
  56.                         continue; 
  57.                     } 
  58.                     //need_comma初始值是0 
  59.                     if (need_comma) { 
  60.                         smart_str_appendc(buf, ','); 
  61.                     } else { 
  62.                         need_comma = 1; 
  63.                     } 
  64.                     php_json_pretty_print_char(buf, options, '\n'); 
  65.                     php_json_pretty_print_indent(buf, options, encoder); 
  66.                     // 处理字符串属性的key（例如判断key中的中文或者特殊字符的处理） 
  67.                     if (php_json_escape_string(buf, ZSTR_VAL(key), ZSTR_LEN(key), 
  68.                                 options & ~PHP_JSON_NUMERIC_CHECK, encoder) == FAILURE && 
  69.                             (options & PHP_JSON_PARTIAL_OUTPUT_ON_ERROR) && 
  70.                             buf->s) { 
  71.                         ZSTR_LEN(buf->s) -= 4; 
  72.                         smart_str_appendl(buf, "\"\"", 2); 
  73.                     } 
  74.                 } else { 
  75.                     if (need_comma) { 
  76.                         smart_str_appendc(buf, ','); 
  77.                     } else { 
  78.                         need_comma = 1; 
  79.                     } 
  80.                     php_json_pretty_print_char(buf, options, '\n'); 
  81.                     php_json_pretty_print_indent(buf, options, encoder); 
  82.                     smart_str_appendc(buf, '"'); 
  83.                     smart_str_append_long(buf, (zend_long) index); 
  84.                     smart_str_appendc(buf, '"'); 
  85.                 } 
  86.                 smart_str_appendc(buf, ':'); 
  87.                 php_json_pretty_print_char(buf, options, ' '); 
  88.             } 
  89.             // ↑ end 从这里之前都是判断key怎么处理以及元素末尾怎么处理  ↑↑↑↑ 
  90.             //继续调用对普通元素编码的 php_json_encode_zval() （实现数组和对象的递归闭环） 
  91.             if (php_json_encode_zval(buf, data, options, encoder) == FAILURE && 
  92.                     !(options & PHP_JSON_PARTIAL_OUTPUT_ON_ERROR)) { 
  93.                 PHP_JSON_HASH_APPLY_PROTECTION_DEC(myht); 
  94.                 return FAILURE; 
  95.             } 
  96.         } ZEND_HASH_FOREACH_END(); 
  97.     } 
  98.     PHP_JSON_HASH_APPLY_PROTECTION_DEC(myht); 
  99.     // 当前深度是否到达了设定的最大深度（默认512） 
  100.     if (encoder->depth > encoder->max_depth) { 
  101.         encoder->error_code = PHP_JSON_ERROR_DEPTH; 
  102.         if (!(options & PHP_JSON_PARTIAL_OUTPUT_ON_ERROR)) { 
  103.             return FAILURE; 
  104.         } 
  105.     } 
  106.     --encoder->depth; 
  107.     /* Only keep closing bracket on same line for empty arrays/objects */ 
  108.     if (need_comma) { 
  109.         php_json_pretty_print_char(buf, options, '\n'); 
  110.         php_json_pretty_print_indent(buf, options, encoder); 
  111.     } 
  112.     if (r == PHP_JSON_OUTPUT_ARRAY) { 
  113.         smart_str_appendc(buf, ']'); 
  114.     } else { 
  115.         smart_str_appendc(buf, '}'); 
  116.     } 
  117.     return SUCCESS; 
  118. } 
  119. /* }}} */ 

分析

看了源码，我得出了一些结论。

只有 null，布尔值，浮点数，整数，字符串才会被直接编码

对象要么实现 JsonSerializable 并定义一个 jsonSerialize() ，要么就被当成一个数组，只会被处理公开非静态属性

json_encode() 并不会直接编码数组和对象，而是会递归遍历出所有可遍历的元素，并处理 key

源码中 php_json_encode_zval() 和 php_json_encode_array() 的相互调用，实现了数组和对象遍历的闭环

引用不会被编码

另外，关于 json_encode() 的 options ，我觉得这里处理的技巧非常有趣，巧妙利用位运算来区别多个常量，有兴趣的慢慢看看研究研究。（提示，将 options 每个常量转成二进制来看，json_encode() 接受多个 option 是按位或 | ）

Demo

  1. >>> $a = [1,2,3,4]; 
  2. => [ 
  3.      1, 
  4.      2, 
  5.      3, 
  6.      4, 
  7.    ] 
  8. >>> json_encode($a); 
  9. => "[1,2,3,4]" 
  10. >>> json_encode((object)$a); 
  11. => "{"0":1,"1":2,"2":3,"3":4}" 
  12. >>> json_encode($a,JSON_FORCE_OBJECT); 
  13. => "{"0":1,"1":2,"2":3,"3":4}" 
  14. >>> json_encode($a,JSON_FORCE_OBJECT|JSON_PRETTY_PRINT); 
  15. => """ 
  16.    {\n 
  17.        "0": 1,\n 
  18.        "1": 2,\n 
  19.        "2": 3,\n 
  20.        "3": 4\n 
  21.    } 
  22.    """ 
  23.  
  24. $arr = array( 
  25.     '0'=>'a','1'=>'b','2'=>'c','3'=>'d' 
  26. ); 
  27. echo json_encode($arr); 

但是结果是

["a","b","c","d"]

需求是要返回JSON对象，是这样似的

  1. {"0":"a","1":"b","2":"c","3":"d"} 
  2.  
  3. You can do it，you nee add 
  4.  
  5. $arr = array( 
  6.     '0'=>'a','1'=>'b','2'=>'c','3'=>'d' 
  7. ); 
  8. echo json_encode((object)$arr); 

输出结果

{"0":"a","1":"b","2":"c","3":"d"}

Tags: json_encode

分享到：

相关文章

推荐文章

热门文章

最新评论文章