PHPdisk如何开发打印Json

JohnceCena2012

include '../includes/commons.inc.php';
define('P_W',   1);
include '../plugins/api/pw_api/class_json.php';

$arr = array ('a'=>1,'b'=>2,'c'=>3,'d'=>4,'e'=>5);

$json = new Services_JSON(true);

echo $json->json_encode($arr);

使用以上代码出错，请高人帮忙, 小弟不甚感激

along

你的代码应该正确呀

JohnceCena2012

谢谢站长的回复，弄了半天没搞定，从discuz源码中移植了关于json的代码，现在分享出来以免大家以后在这方面浪费时间：

json.class.php：

1. <?php
   
2. 
   
3. /**
   
4. * Init by Hubery
   
5. */
   
6. 
   
7. class CJSON {
   
8.         const JSON_SLICE = 1;
   
9.         const JSON_IN_STR = 2;
   
10.         const JSON_IN_ARR = 4;
    
11.         const JSON_IN_OBJ = 8;
    
12.         const JSON_IN_CMT = 16;
    
13. 
    
14.         static function encode($var) {
    
15.                 global $_G;
    
16.                 switch (gettype($var)) {
    
17.                         case 'boolean':
    
18.                                 return $var ? 'true' : 'false';
    
19.                         case 'NULL':
    
20.                                 return 'null';
    
21.                         case 'integer':
    
22.                                 return (int) $var;
    
23.                         case 'double':
    
24.                         case 'float':
    
25.                                 return rtrim(sprintf('%.16F',$var),'0');
    
26.                         case 'string':
    
27.                                 if(function_exists('diconv') && strtolower($_G['charset']) != 'utf-8') {
    
28.                                         $var = diconv($var, $_G['charset'], 'utf-8');
    
29.                                 }
    
30.                                 if(function_exists('json_encode')) {
    
31.                                         return json_encode($var);
    
32.                                 }
    
33.                                 $ascii = '';
    
34.                                 $strlen_var = strlen($var);
    
35.                                 for ($c = 0; $c < $strlen_var; ++$c) {
    
36.                                         $ord_var_c = ord($var{$c});
    
37.                                         switch (true) {
    
38.                                                 case $ord_var_c == 0x08:
    
39.                                                         $ascii .= '\b';
    
40.                                                         break;
    
41.                                                 case $ord_var_c == 0x09:
    
42.                                                         $ascii .= '\t';
    
43.                                                         break;
    
44.                                                 case $ord_var_c == 0x0A:
    
45.                                                         $ascii .= '\n';
    
46.                                                         break;
    
47.                                                 case $ord_var_c == 0x0C:
    
48.                                                         $ascii .= '\f';
    
49.                                                         break;
    
50.                                                 case $ord_var_c == 0x0D:
    
51.                                                         $ascii .= '\r';
    
52.                                                         break;
    
53. 
    
54.                                                 case $ord_var_c == 0x22:
    
55.                                                 case $ord_var_c == 0x2F:
    
56.                                                 case $ord_var_c == 0x5C:
    
57.                                                         $ascii .= '\\'.$var{$c};
    
58.                                                         break;
    
59. 
    
60.                                                 case (($ord_var_c >= 0x20) && ($ord_var_c <= 0x7F)):
    
61.                                                         $ascii .= $var{$c};
    
62.                                                         break;
    
63. 
    
64.                                                 case (($ord_var_c & 0xE0) == 0xC0):
    
65.                                                         $char = pack('C*', $ord_var_c, ord($var{$c+1}));
    
66.                                                         $c+=1;
    
67.                                                         $utf16 =  self::utf8ToUTF16BE($char);
    
68.                                                         $ascii .= sprintf('\u%04s', bin2hex($utf16));
    
69.                                                         break;
    
70. 
    
71.                                                 case (($ord_var_c & 0xF0) == 0xE0):
    
72.                                                         $char = pack('C*', $ord_var_c,
    
73.                                                                                  ord($var{$c+1}),
    
74.                                                                                  ord($var{$c+2}));
    
75.                                                         $c+=2;
    
76.                                                         $utf16 = self::utf8ToUTF16BE($char);
    
77.                                                         $ascii .= sprintf('\u%04s', bin2hex($utf16));
    
78.                                                         break;
    
79. 
    
80.                                                 case (($ord_var_c & 0xF8) == 0xF0):
    
81.                                                         $char = pack('C*', $ord_var_c,
    
82.                                                                                  ord($var{$c+1}),
    
83.                                                                                  ord($var{$c+2}),
    
84.                                                                                  ord($var{$c+3}));
    
85.                                                         $c+=3;
    
86.                                                         $utf16 = self::utf8ToUTF16BE($char);
    
87.                                                         $ascii .= sprintf('\u%04s', bin2hex($utf16));
    
88.                                                         break;
    
89. 
    
90.                                                 case (($ord_var_c & 0xFC) == 0xF8):
    
91.                                                         $char = pack('C*', $ord_var_c,
    
92.                                                                                  ord($var{$c+1}),
    
93.                                                                                  ord($var{$c+2}),
    
94.                                                                                  ord($var{$c+3}),
    
95.                                                                                  ord($var{$c+4}));
    
96.                                                         $c+=4;
    
97.                                                         $utf16 = self::utf8ToUTF16BE($char);
    
98.                                                         $ascii .= sprintf('\u%04s', bin2hex($utf16));
    
99.                                                         break;
    
100. 
     
101.                                                 case (($ord_var_c & 0xFE) == 0xFC):
     
102.                                                         $char = pack('C*', $ord_var_c,
     
103.                                                                                  ord($var{$c+1}),
     
104.                                                                                  ord($var{$c+2}),
     
105.                                                                                  ord($var{$c+3}),
     
106.                                                                                  ord($var{$c+4}),
     
107.                                                                                  ord($var{$c+5}));
     
108.                                                         $c+=5;
     
109.                                                         $utf16 = self::utf8ToUTF16BE($char);
     
110.                                                         $ascii .= sprintf('\u%04s', bin2hex($utf16));
     
111.                                                         break;
     
112.                                         }
     
113.                                 }
     
114. 
     
115.                                 return '"'.$ascii.'"';
     
116. 
     
117.                         case 'array':
     
118.                                 if (is_array($var) && count($var) && (array_keys($var) !== range(0, sizeof($var) - 1))) {
     
119.                                         return '{' .
     
120.                                                    join(',', array_map(array('CJSON', 'nameValue'),
     
121.                                                                                            array_keys($var),
     
122.                                                                                            array_values($var)))
     
123.                                                    . '}';
     
124.                                 }
     
125. 
     
126.                                 return '[' . join(',', array_map(array('CJSON', 'encode'), $var)) . ']';
     
127.                         case 'object':
     
128.                                 if ($var instanceof Traversable)
     
129.                                 {
     
130.                                         $vars = array();
     
131.                                         foreach ($var as $k=>$v)
     
132.                                                 $vars[$k] = $v;
     
133.                                 }
     
134.                                 else
     
135.                                         $vars = get_object_vars($var);
     
136.                                 return '{' .
     
137.                                            join(',', array_map(array('CJSON', 'nameValue'),
     
138.                                                                                    array_keys($vars),
     
139.                                                                                    array_values($vars)))
     
140.                                            . '}';
     
141. 
     
142.                         default:
     
143.                                 return '';
     
144.                 }
     
145.         }
     
146. 
     
147.         static function nameValue($name, $value) {
     
148.                 return self::encode(strval($name)) . ':' . self::encode($value);
     
149.         }
     
150. 
     
151.         static function reduceString($str) {
     
152.                 $str = preg_replace(array(
     
153. 
     
154.                                 '#^\s*//(.+)$#m',
     
155. 
     
156.                                 '#^\s*/\*(.+)\*/#Us',
     
157. 
     
158.                                 '#/\*(.+)\*/\s*$#Us'
     
159. 
     
160.                         ), '', $str);
     
161. 
     
162.                 return trim($str);
     
163.         }
     
164. 
     
165.         static function decode($str, $useArray=true) {
     
166.                 if(function_exists('json_decode')) {
     
167.                         return json_decode($str, $useArray);
     
168.             }
     
169. 
     
170.                 $str = self::reduceString($str);
     
171. 
     
172.                 switch (strtolower($str)) {
     
173.                         case 'true':
     
174.                                 return true;
     
175. 
     
176.                         case 'false':
     
177.                                 return false;
     
178. 
     
179.                         case 'null':
     
180.                                 return null;
     
181. 
     
182.                         default:
     
183.                                 if (is_numeric($str)) {
     
184.                                         return ((float)$str == (integer)$str)
     
185.                                                 ? (integer)$str
     
186.                                                 : (float)$str;
     
187. 
     
188.                                 } elseif (preg_match('/^("|\').+(\1)$/s', $str, $m) && $m[1] == $m[2]) {
     
189. 
     
190.                                         $delim = substr($str, 0, 1);
     
191.                                         $chrs = substr($str, 1, -1);
     
192.                                         $utf8 = '';
     
193.                                         $strlen_chrs = strlen($chrs);
     
194. 
     
195.                                         for ($c = 0; $c < $strlen_chrs; ++$c) {
     
196. 
     
197.                                                 $substr_chrs_c_2 = substr($chrs, $c, 2);
     
198.                                                 $ord_chrs_c = ord($chrs{$c});
     
199. 
     
200.                                                 switch (true) {
     
201.                                                         case $substr_chrs_c_2 == '\b':
     
202.                                                                 $utf8 .= chr(0x08);
     
203.                                                                 ++$c;
     
204.                                                                 break;
     
205.                                                         case $substr_chrs_c_2 == '\t':
     
206.                                                                 $utf8 .= chr(0x09);
     
207.                                                                 ++$c;
     
208.                                                                 break;
     
209.                                                         case $substr_chrs_c_2 == '\n':
     
210.                                                                 $utf8 .= chr(0x0A);
     
211.                                                                 ++$c;
     
212.                                                                 break;
     
213.                                                         case $substr_chrs_c_2 == '\f':
     
214.                                                                 $utf8 .= chr(0x0C);
     
215.                                                                 ++$c;
     
216.                                                                 break;
     
217.                                                         case $substr_chrs_c_2 == '\r':
     
218.                                                                 $utf8 .= chr(0x0D);
     
219.                                                                 ++$c;
     
220.                                                                 break;
     
221. 
     
222. 
     

复制代码

JohnceCena2012

1.                                         case $substr_chrs_c_2 == '\"':
   
2.                                                         case $substr_chrs_c_2 == '\\\'':
   
3.                                                         case $substr_chrs_c_2 == '\\\\':
   
4.                                                         case $substr_chrs_c_2 == '\\/':
   
5.                                                                 if (($delim == '"' && $substr_chrs_c_2 != '\\\'') ||
   
6.                                                                    ($delim == "'" && $substr_chrs_c_2 != '\"')) {
   
7.                                                                         $utf8 .= $chrs{++$c};
   
8.                                                                 }
   
9.                                                                 break;
   
10. 
    
11.                                                         case preg_match('/\\\u[0-9A-F]{4}/i', substr($chrs, $c, 6)):
    
12.                                                                 $utf16 = chr(hexdec(substr($chrs, ($c+2), 2)))
    
13.                                                                            . chr(hexdec(substr($chrs, ($c+4), 2)));
    
14.                                                                 $utf8 .= self::utf16beToUTF8($utf16);
    
15.                                                                 $c+=5;
    
16.                                                                 break;
    
17. 
    
18.                                                         case ($ord_chrs_c >= 0x20) && ($ord_chrs_c <= 0x7F):
    
19.                                                                 $utf8 .= $chrs{$c};
    
20.                                                                 break;
    
21. 
    
22.                                                         case ($ord_chrs_c & 0xE0) == 0xC0:
    
23.                                                                 $utf8 .= substr($chrs, $c, 2);
    
24.                                                                 ++$c;
    
25.                                                                 break;
    
26. 
    
27.                                                         case ($ord_chrs_c & 0xF0) == 0xE0:
    
28.                                                                 $utf8 .= substr($chrs, $c, 3);
    
29.                                                                 $c += 2;
    
30.                                                                 break;
    
31. 
    
32.                                                         case ($ord_chrs_c & 0xF8) == 0xF0:
    
33.                                                                 $utf8 .= substr($chrs, $c, 4);
    
34.                                                                 $c += 3;
    
35.                                                                 break;
    
36. 
    
37.                                                         case ($ord_chrs_c & 0xFC) == 0xF8:
    
38.                                                                 $utf8 .= substr($chrs, $c, 5);
    
39.                                                                 $c += 4;
    
40.                                                                 break;
    
41. 
    
42.                                                         case ($ord_chrs_c & 0xFE) == 0xFC:
    
43.                                                                 $utf8 .= substr($chrs, $c, 6);
    
44.                                                                 $c += 5;
    
45.                                                                 break;
    
46. 
    
47.                                                 }
    
48. 
    
49.                                         }
    
50. 
    
51.                                         return $utf8;
    
52. 
    
53.                                 } elseif (preg_match('/^\[.*\]$/s', $str) || preg_match('/^\{.*\}$/s', $str)) {
    
54. 
    
55.                                         if ($str{0} == '[') {
    
56.                                                 $stk = array(self::JSON_IN_ARR);
    
57.                                                 $arr = array();
    
58.                                         } else {
    
59.                                                 if ($useArray) {
    
60.                                                         $stk = array(self::JSON_IN_OBJ);
    
61.                                                         $obj = array();
    
62.                                                 } else {
    
63.                                                         $stk = array(self::JSON_IN_OBJ);
    
64.                                                         $obj = new stdClass();
    
65.                                                 }
    
66.                                         }
    
67. 
    
68.                                         array_push($stk, array('what'  => self::JSON_SLICE,
    
69.                                                                                    'where' => 0,
    
70.                                                                                    'delim' => false));
    
71. 
    
72.                                         $chrs = substr($str, 1, -1);
    
73.                                         $chrs = self::reduceString($chrs);
    
74. 
    
75.                                         if ($chrs == '') {
    
76.                                                 if (reset($stk) == self::JSON_IN_ARR) {
    
77.                                                         return $arr;
    
78. 
    
79.                                                 } else {
    
80.                                                         return $obj;
    
81. 
    
82.                                                 }
    
83.                                         }
    
84. 
    
85.                                         $strlen_chrs = strlen($chrs);
    
86. 
    
87.                                         for ($c = 0; $c <= $strlen_chrs; ++$c) {
    
88. 
    
89.                                                 $top = end($stk);
    
90.                                                 $substr_chrs_c_2 = substr($chrs, $c, 2);
    
91. 
    
92.                                                 if (($c == $strlen_chrs) || (($chrs{$c} == ',') && ($top['what'] == self::JSON_SLICE))) {
    
93. 
    
94.                                                         $slice = substr($chrs, $top['where'], ($c - $top['where']));
    
95.                                                         array_push($stk, array('what' => self::JSON_SLICE, 'where' => ($c + 1), 'delim' => false));
    
96.                                                         if (reset($stk) == self::JSON_IN_ARR) {
    
97.                                                                 array_push($arr, self::decode($slice,$useArray));
    
98. 
    
99.                                                         } elseif (reset($stk) == self::JSON_IN_OBJ) {
    
100.                                                                 if (preg_match('/^\s*(["\'].*[^\\\]["\'])\s*:\s*(\S.*),?$/Uis', $slice, $parts)) {
     
101.                                                                         $key = self::decode($parts[1],$useArray);
     
102.                                                                         $val = self::decode($parts[2],$useArray);
     
103. 
     
104.                                                                         if ($useArray) {
     
105.                                                                                 $obj[$key] = $val;
     
106.                                                                         } else {
     
107.                                                                                 $obj->$key = $val;
     
108.                                                                         }
     
109.                                                                 } elseif (preg_match('/^\s*(\w+)\s*:\s*(\S.*),?$/Uis', $slice, $parts)) {
     
110.                                                                         $key = $parts[1];
     
111.                                                                         $val = self::decode($parts[2],$useArray);
     
112. 
     
113.                                                                         if ($useArray) {
     
114.                                                                                 $obj[$key] = $val;
     
115.                                                                         } else {
     
116.                                                                                 $obj->$key = $val;
     
117.                                                                         }
     
118.                                                                 }
     
119. 
     
120.                                                         }
     
121. 
     
122.                                                 } elseif ((($chrs{$c} == '"') || ($chrs{$c} == "'")) && ($top['what'] != self::JSON_IN_STR)) {
     
123.                                                         array_push($stk, array('what' => self::JSON_IN_STR, 'where' => $c, 'delim' => $chrs{$c}));
     
124.                                                 } elseif (($chrs{$c} == $top['delim']) &&
     
125.                                                                  ($top['what'] == self::JSON_IN_STR) &&
     
126.                                                                  (($chrs{$c - 1} != "\") ||
     
127.                                                                  ($chrs{$c - 1} == "\" && $chrs{$c - 2} == "\"))) {
     
128.                                                         array_pop($stk);
     
129.                                                 } elseif (($chrs{$c} == '[') &&
     
130.                                                                  in_array($top['what'], array(self::JSON_SLICE, self::JSON_IN_ARR, self::JSON_IN_OBJ))) {
     
131.                                                         array_push($stk, array('what' => self::JSON_IN_ARR, 'where' => $c, 'delim' => false));
     
132.                                                 } elseif (($chrs{$c} == ']') && ($top['what'] == self::JSON_IN_ARR)) {
     
133.                                                         array_pop($stk);
     
134.                                                 } elseif (($chrs{$c} == '{') &&
     
135.                                                                  in_array($top['what'], array(self::JSON_SLICE, self::JSON_IN_ARR, self::JSON_IN_OBJ))) {
     
136.                                                         array_push($stk, array('what' => self::JSON_IN_OBJ, 'where' => $c, 'delim' => false));
     
137.                                                 } elseif (($chrs{$c} == '}') && ($top['what'] == self::JSON_IN_OBJ)) {
     
138.                                                         array_pop($stk);
     
139.                                                 } elseif (($substr_chrs_c_2 == '/**') &&
     
140.                                                                  in_array($top['what'], array(self::JSON_SLICE, self::JSON_IN_ARR, self::JSON_IN_OBJ))) {
     
141.                                                         array_push($stk, array('what' => self::JSON_IN_CMT, 'where' => $c, 'delim' => false));
     
142.                                                         $c++;
     
143.                                                 } elseif (($substr_chrs_c_2 == '*/') && ($top['what'] == self::JSON_IN_CMT)) {
     
144.                                                         array_pop($stk);
     
145.                                                         $c++;
     
146.                                                         for ($i = $top['where']; $i <= $c; ++$i) {
     
147.                                                                 $chrs = substr_replace($chrs, ' ', $i, 1);
     
148.                                           }
     
149.                                                 }
     
150. 
     
151.                                         }
     
152. 
     
153.                                         if (reset($stk) == self::JSON_IN_ARR) {
     
154.                                                 return $arr;
     
155. 
     
156.                                         } elseif (reset($stk) == self::JSON_IN_OBJ) {
     
157.                                                 return $obj;
     
158. 
     
159.                                         }
     
160. 
     
161.                                 }
     
162.                 }
     
163.         }
     
164. 
     
165. 
     
166.         static function utf8ToUnicode( &$str ) {
     
167.                 $unicode = array();
     
168.                 $values = array();
     
169.                 $lookingFor = 1;
     
170. 
     
171.                 for ($i = 0; $i < strlen( $str ); $i++ ) {
     
172.                         $thisValue = ord( $str[ $i ] );
     
173.                         if ( $thisValue < 128 ) {
     
174.                                 $unicode[] = $thisValue;
     
175.                   } else {
     
176.                                 if ( count( $values ) == 0 ) {
     
177.                                         $lookingFor = ( $thisValue < 224 ) ? 2 : 3;
     
178.                         }
     
179.                                 $values[] = $thisValue;
     
180.                                 if ( count( $values ) == $lookingFor ) {
     
181.                                         $number = ( $lookingFor == 3 ) ?
     
182.                                                 ( ( $values[0] % 16 ) * 4096 ) + ( ( $values[1] % 64 ) * 64 ) + ( $values[2] % 64 ):
     
183.                                                 ( ( $values[0] % 32 ) * 64 ) + ( $values[1] % 64 );
     
184.                                         $unicode[] = $number;
     
185.                                         $values = array();
     
186.                                         $lookingFor = 1;
     
187.                                 }
     
188.                         }
     
189.                 }
     
190.                 return $unicode;
     
191.         }
     
192. 
     
193.         static function unicodeToUTF8( &$str )
     
194.         {
     
195.                 $utf8 = '';
     
196.                 foreach( $str as $unicode )
     
197.                 {
     
198.                         if ( $unicode < 128 )
     
199.                         {
     
200.                                 $utf8.= chr( $unicode );
     
201.                         }
     
202.                         elseif ( $unicode < 2048 )
     
203.                         {
     
204.                                 $utf8.= chr( 192 +  ( ( $unicode - ( $unicode % 64 ) ) / 64 ) );
     
205.                                 $utf8.= chr( 128 + ( $unicode % 64 ) );
     
206.                         }
     
207.                         else
     
208.                         {
     
209.                                 $utf8.= chr( 224 + ( ( $unicode - ( $unicode % 4096 ) ) / 4096 ) );
     
210.                                 $utf8.= chr( 128 + ( ( ( $unicode % 4096 ) - ( $unicode % 64 ) ) / 64 ) );
     
211.                                 $utf8.= chr( 128 + ( $unicode % 64 ) );
     
212.                         }
     
213.                 }
     
214.                 return $utf8;
     
215.         }
     
216. 
     
217.         static function utf8ToUTF16BE(&$str, $bom = false) {
     
218.                 $out = $bom ? "\xFE\xFF" : '';
     
219.                 if(function_exists('mb_convert_encoding'))
     
220.                         return $out.mb_convert_encoding($str,'UTF-16BE','UTF-8');
     
221. 
     
222.                 $uni = self::utf8ToUnicode($str);
     
223.                 foreach($uni as $cp)
     
224.                         $out .= pack('n',$cp);
     
225.                 return $out;
     
226.         }
     
227. 
     
228.         static function utf16beToUTF8(&$str) {
     
229.                 $uni = unpack('n*',$str);
     
230.                 return self::unicodeToUTF8($uni);
     
231.         }
     
232. }

复制代码

mobile.class.php

1. <?php
   
2. 
   
3. /**
   
4. * Init by Hubery
   
5. */
   
6. 
   
7. class mobile_core {   
   
8.         function result($result) {
   
9.                 global $_G;
   
10.                 echo mobile_core::json($result);
    
11.                 exit;
    
12.         }
    
13. 
    
14.         function json($encode) {
    
15.                 require_once './json.class.php';
    
16.                 return CJSON::encode($encode);
    
17.         }
    
18. 
    
19.         function getvalues($variables, $keys, $subkeys = array()) {
    
20.                 $return = array();
    
21.                 foreach($variables as $key => $value) {
    
22.                         foreach($keys as $k) {
    
23.                                 if($k{0} == '/' && preg_match($k, $key) || $key == $k) {
    
24.                                         if($subkeys) {
    
25.                                                 $return[$key] = mobile_core::getvalues($value, $subkeys);
    
26.                                         } else {
    
27.                                                 if(!empty($value) || !empty($_GET['debug']) || (is_numeric($value) && intval($value) === 0 )) {
    
28.                                                         $return[$key] = is_array($value) ? mobile_core::arraystring($value) : (string)$value;
    
29.                                                 }
    
30.                                         }
    
31.                                 }
    
32.                         }
    
33.                 }
    
34.                 return $return;
    
35.         }
    
36. 
    
37.         function arraystring($array) {
    
38.                 foreach($array as $k => $v) {
    
39.                         $array[$k] = is_array($v) ? mobile_core::arraystring($v) : (string)$v;
    
40.                 }
    
41.                 return $array;
    
42.         }
    
43.        
    
44.         function errorExit($error){
    
45.                 $outPut = array(
    
46.           'ErrorMessage' => $error);
    
47. 
    
48.                 mobile_core::result($outPut);
    
49.                
    
50.                 exit();
    
51.         }
    
52. 
    
53. }
    
54. 
    
55. ?>

复制代码

使用方法：

1. 
   
2. 
   
3. include './mobile.class.php';
   
4. 
   
5. $outPut = array(
   
6.           'ErrorMessage' => $ErrorMessage,
   
7.           'Test001' => 'Very Good');
   
8. 
   
9. mobile_core::result($outPut);

复制代码