WordPress как на ладони
Недорогой хостинг для сайтов на WordPress: wordpress.jino.ru Платформа для конвертации и монетизации трафика
функция не описана

Services_JSON::decode() public WP 1.0

Запрещена (устарела) с версии 5.3.0. Больше не поддерживается и может быть удалена. Используйте PHP native JSON extension.

decodes a JSON string into appropriate variable

{} Это метод класса: Services_JSON{}

Хуков нет.

Возвращает

Разное. number, boolean, string, array, or object corresponding to given JSON input string. See argument 1 to Services_JSON() above for object-output behavior. Note that decode() always returns strings in ASCII or UTF-8 format!

Использование

$Services_JSON = new Services_JSON();
$Services_JSON->decode( $str );
$str(строка) (обязательный)
JSON-formatted string

Список изменений

Устарела с 5.3.0 Use the PHP native JSON extension instead.

Код Services_JSON::decode() WP 5.5.3

<?php
function decode($str)
{
    _deprecated_function( __METHOD__, '5.3.0', 'The PHP native JSON extension' );

    $str = $this->reduce_string($str);

    switch (strtolower($str)) {
        case 'true':
            return true;

        case 'false':
            return false;

        case 'null':
            return null;

        default:
            $m = array();

            if (is_numeric($str)) {
                // Lookie-loo, it's a number

                // This would work on its own, but I'm trying to be
                // good about returning integers where appropriate:
                // return (float)$str;

                // Return float or int, as appropriate
                return ((float)$str == (integer)$str)
                    ? (integer)$str
                    : (float)$str;

            } elseif (preg_match('/^("|\').*(\1)$/s', $str, $m) && $m[1] == $m[2]) {
                // STRINGS RETURNED IN UTF-8 FORMAT
                $delim = $this->substr8($str, 0, 1);
                $chrs = $this->substr8($str, 1, -1);
                $utf8 = '';
                $strlen_chrs = $this->strlen8($chrs);

                for ($c = 0; $c < $strlen_chrs; ++$c) {

                    $substr_chrs_c_2 = $this->substr8($chrs, $c, 2);
                    $ord_chrs_c = ord($chrs[$c]);

                    switch (true) {
                        case $substr_chrs_c_2 == '\b':
                            $utf8 .= chr(0x08);
                            ++$c;
                            break;
                        case $substr_chrs_c_2 == '\t':
                            $utf8 .= chr(0x09);
                            ++$c;
                            break;
                        case $substr_chrs_c_2 == '\n':
                            $utf8 .= chr(0x0A);
                            ++$c;
                            break;
                        case $substr_chrs_c_2 == '\f':
                            $utf8 .= chr(0x0C);
                            ++$c;
                            break;
                        case $substr_chrs_c_2 == '\r':
                            $utf8 .= chr(0x0D);
                            ++$c;
                            break;

                        case $substr_chrs_c_2 == '\\"':
                        case $substr_chrs_c_2 == '\\\'':
                        case $substr_chrs_c_2 == '\\\\':
                        case $substr_chrs_c_2 == '\\/':
                            if (($delim == '"' && $substr_chrs_c_2 != '\\\'') ||
                               ($delim == "'" && $substr_chrs_c_2 != '\\"')) {
                                $utf8 .= $chrs[++$c];
                            }
                            break;

                        case preg_match('/\\\u[0-9A-F]{4}/i', $this->substr8($chrs, $c, 6)):
                            // single, escaped unicode character
                            $utf16 = chr(hexdec($this->substr8($chrs, ($c + 2), 2)))
                                   . chr(hexdec($this->substr8($chrs, ($c + 4), 2)));
                            $utf8 .= $this->utf162utf8($utf16);
                            $c += 5;
                            break;

                        case ($ord_chrs_c >= 0x20) && ($ord_chrs_c <= 0x7F):
                            $utf8 .= $chrs[$c];
                            break;

                        case ($ord_chrs_c & 0xE0) == 0xC0:
                            // characters U-00000080 - U-000007FF, mask 110XXXXX
                            //see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                            $utf8 .= $this->substr8($chrs, $c, 2);
                            ++$c;
                            break;

                        case ($ord_chrs_c & 0xF0) == 0xE0:
                            // characters U-00000800 - U-0000FFFF, mask 1110XXXX
                            // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                            $utf8 .= $this->substr8($chrs, $c, 3);
                            $c += 2;
                            break;

                        case ($ord_chrs_c & 0xF8) == 0xF0:
                            // characters U-00010000 - U-001FFFFF, mask 11110XXX
                            // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                            $utf8 .= $this->substr8($chrs, $c, 4);
                            $c += 3;
                            break;

                        case ($ord_chrs_c & 0xFC) == 0xF8:
                            // characters U-00200000 - U-03FFFFFF, mask 111110XX
                            // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                            $utf8 .= $this->substr8($chrs, $c, 5);
                            $c += 4;
                            break;

                        case ($ord_chrs_c & 0xFE) == 0xFC:
                            // characters U-04000000 - U-7FFFFFFF, mask 1111110X
                            // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                            $utf8 .= $this->substr8($chrs, $c, 6);
                            $c += 5;
                            break;

                    }

                }

                return $utf8;

            } elseif (preg_match('/^\[.*\]$/s', $str) || preg_match('/^\{.*\}$/s', $str)) {
                // array, or object notation

                if ($str[0] == '[') {
                    $stk = array(SERVICES_JSON_IN_ARR);
                    $arr = array();
                } else {
                    if ($this->use & SERVICES_JSON_LOOSE_TYPE) {
                        $stk = array(SERVICES_JSON_IN_OBJ);
                        $obj = array();
                    } else {
                        $stk = array(SERVICES_JSON_IN_OBJ);
                        $obj = new stdClass();
                    }
                }

                array_push($stk, array('what'  => SERVICES_JSON_SLICE,
                                       'where' => 0,
                                       'delim' => false));

                $chrs = $this->substr8($str, 1, -1);
                $chrs = $this->reduce_string($chrs);

                if ($chrs == '') {
                    if (reset($stk) == SERVICES_JSON_IN_ARR) {
                        return $arr;

                    } else {
                        return $obj;

                    }
                }

                //print("\nparsing {$chrs}\n");

                $strlen_chrs = $this->strlen8($chrs);

                for ($c = 0; $c <= $strlen_chrs; ++$c) {

                    $top = end($stk);
                    $substr_chrs_c_2 = $this->substr8($chrs, $c, 2);

                    if (($c == $strlen_chrs) || (($chrs[$c] == ',') && ($top['what'] == SERVICES_JSON_SLICE))) {
                        // found a comma that is not inside a string, array, etc.,
                        // OR we've reached the end of the character list
                        $slice = $this->substr8($chrs, $top['where'], ($c - $top['where']));
                        array_push($stk, array('what' => SERVICES_JSON_SLICE, 'where' => ($c + 1), 'delim' => false));
                        //print("Found split at {$c}: ".$this->substr8($chrs, $top['where'], (1 + $c - $top['where']))."\n");

                        if (reset($stk) == SERVICES_JSON_IN_ARR) {
                            // we are in an array, so just push an element onto the stack
                            array_push($arr, $this->decode($slice));

                        } elseif (reset($stk) == SERVICES_JSON_IN_OBJ) {
                            // we are in an object, so figure
                            // out the property name and set an
                            // element in an associative array,
                            // for now
                            $parts = array();
                            
                           if (preg_match('/^\s*(["\'].*[^\\\]["\'])\s*:/Uis', $slice, $parts)) {
                                // "name":value pair
                                $key = $this->decode($parts[1]);
                                $val = $this->decode(trim(substr($slice, strlen($parts[0])), ", \t\n\r\0\x0B"));
                                if ($this->use & SERVICES_JSON_LOOSE_TYPE) {
                                    $obj[$key] = $val;
                                } else {
                                    $obj->$key = $val;
                                }
                            } elseif (preg_match('/^\s*(\w+)\s*:/Uis', $slice, $parts)) {
                                // name:value pair, where name is unquoted
                                $key = $parts[1];
                                $val = $this->decode(trim(substr($slice, strlen($parts[0])), ", \t\n\r\0\x0B"));

                                if ($this->use & SERVICES_JSON_LOOSE_TYPE) {
                                    $obj[$key] = $val;
                                } else {
                                    $obj->$key = $val;
                                }
                            }

                        }

                    } elseif ((($chrs[$c] == '"') || ($chrs[$c] == "'")) && ($top['what'] != SERVICES_JSON_IN_STR)) {
                        // found a quote, and we are not inside a string
                        array_push($stk, array('what' => SERVICES_JSON_IN_STR, 'where' => $c, 'delim' => $chrs[$c]));
                        //print("Found start of string at {$c}\n");

                    } elseif (($chrs[$c] == $top['delim']) &&
                             ($top['what'] == SERVICES_JSON_IN_STR) &&
                             (($this->strlen8($this->substr8($chrs, 0, $c)) - $this->strlen8(rtrim($this->substr8($chrs, 0, $c), '\\'))) % 2 != 1)) {
                        // found a quote, we're in a string, and it's not escaped
                        // we know that it's not escaped because there is _not_ an
                        // odd number of backslashes at the end of the string so far
                        array_pop($stk);
                        //print("Found end of string at {$c}: ".$this->substr8($chrs, $top['where'], (1 + 1 + $c - $top['where']))."\n");

                    } elseif (($chrs[$c] == '[') &&
                             in_array($top['what'], array(SERVICES_JSON_SLICE, SERVICES_JSON_IN_ARR, SERVICES_JSON_IN_OBJ))) {
                        // found a left-bracket, and we are in an array, object, or slice
                        array_push($stk, array('what' => SERVICES_JSON_IN_ARR, 'where' => $c, 'delim' => false));
                        //print("Found start of array at {$c}\n");

                    } elseif (($chrs[$c] == ']') && ($top['what'] == SERVICES_JSON_IN_ARR)) {
                        // found a right-bracket, and we're in an array
                        array_pop($stk);
                        //print("Found end of array at {$c}: ".$this->substr8($chrs, $top['where'], (1 + $c - $top['where']))."\n");

                    } elseif (($chrs[$c] == '{') &&
                             in_array($top['what'], array(SERVICES_JSON_SLICE, SERVICES_JSON_IN_ARR, SERVICES_JSON_IN_OBJ))) {
                        // found a left-brace, and we are in an array, object, or slice
                        array_push($stk, array('what' => SERVICES_JSON_IN_OBJ, 'where' => $c, 'delim' => false));
                        //print("Found start of object at {$c}\n");

                    } elseif (($chrs[$c] == '}') && ($top['what'] == SERVICES_JSON_IN_OBJ)) {
                        // found a right-brace, and we're in an object
                        array_pop($stk);
                        //print("Found end of object at {$c}: ".$this->substr8($chrs, $top['where'], (1 + $c - $top['where']))."\n");

                    } elseif (($substr_chrs_c_2 == '/*') &&
                             in_array($top['what'], array(SERVICES_JSON_SLICE, SERVICES_JSON_IN_ARR, SERVICES_JSON_IN_OBJ))) {
                        // found a comment start, and we are in an array, object, or slice
                        array_push($stk, array('what' => SERVICES_JSON_IN_CMT, 'where' => $c, 'delim' => false));
                        $c++;
                        //print("Found start of comment at {$c}\n");

                    } elseif (($substr_chrs_c_2 == '*/') && ($top['what'] == SERVICES_JSON_IN_CMT)) {
                        // found a comment end, and we're in one now
                        array_pop($stk);
                        $c++;

                        for ($i = $top['where']; $i <= $c; ++$i)
                            $chrs = substr_replace($chrs, ' ', $i, 1);

                        //print("Found end of comment at {$c}: ".$this->substr8($chrs, $top['where'], (1 + $c - $top['where']))."\n");

                    }

                }

                if (reset($stk) == SERVICES_JSON_IN_ARR) {
                    return $arr;

                } elseif (reset($stk) == SERVICES_JSON_IN_OBJ) {
                    return $obj;

                }

            }
    }
}