WordPress at a glance
function is not described

Services_JSON::_encode() public WP 1.0

Deprecated in from version 5.3.0. It is no longer supported and can be removed in future releases. Use PHP native JSON extension instead.

PRIVATE CODE that does the work of encodes an arbitrary variable into JSON format

{} It's a method of the class: Services_JSON{}

No Hooks.

Return

Mixed. JSON string representation of input var or an error if a problem occurs

Usage

$Services_JSON = new Services_JSON();
$Services_JSON->_encode( $var );
$var(mixed) (required)
any number, boolean, string, array, or object to be encoded. see argument 1 to Services_JSON() above for array-parsing behavior. if var is a string, note that encode() always expects it to be in ASCII or UTF-8 format!

Changelog

Deprecated Since 5.3.0 Use the PHP native JSON extension instead.

Code of Services_JSON::_encode() WP 5.5.1

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

    switch (gettype($var)) {
        case 'boolean':
            return $var ? 'true' : 'false';

        case 'NULL':
            return 'null';

        case 'integer':
            return (int) $var;

        case 'double':
        case 'float':
            return  (float) $var;

        case 'string':
            // STRINGS ARE EXPECTED TO BE IN ASCII OR UTF-8 FORMAT
            $ascii = '';
            $strlen_var = $this->strlen8($var);

           /*
            * Iterate over every character in the string,
            * escaping with a slash or encoding to UTF-8 where necessary
            */
            for ($c = 0; $c < $strlen_var; ++$c) {

                $ord_var_c = ord($var[$c]);

                switch (true) {
                    case $ord_var_c == 0x08:
                        $ascii .= '\b';
                        break;
                    case $ord_var_c == 0x09:
                        $ascii .= '\t';
                        break;
                    case $ord_var_c == 0x0A:
                        $ascii .= '\n';
                        break;
                    case $ord_var_c == 0x0C:
                        $ascii .= '\f';
                        break;
                    case $ord_var_c == 0x0D:
                        $ascii .= '\r';
                        break;

                    case $ord_var_c == 0x22:
                    case $ord_var_c == 0x2F:
                    case $ord_var_c == 0x5C:
                        // double quote, slash, slosh
                        $ascii .= '\\'.$var[$c];
                        break;

                    case (($ord_var_c >= 0x20) && ($ord_var_c <= 0x7F)):
                        // characters U-00000000 - U-0000007F (same as ASCII)
                        $ascii .= $var[$c];
                        break;

                    case (($ord_var_c & 0xE0) == 0xC0):
                        // characters U-00000080 - U-000007FF, mask 110XXXXX
                        // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                        if ($c+1 >= $strlen_var) {
                            $c += 1;
                            $ascii .= '?';
                            break;
                        }
                        
                        $char = pack('C*', $ord_var_c, ord($var[$c + 1]));
                        $c += 1;
                        $utf16 = $this->utf82utf16($char);
                        $ascii .= sprintf('\u%04s', bin2hex($utf16));
                        break;

                    case (($ord_var_c & 0xF0) == 0xE0):
                        if ($c+2 >= $strlen_var) {
                            $c += 2;
                            $ascii .= '?';
                            break;
                        }
                        // characters U-00000800 - U-0000FFFF, mask 1110XXXX
                        // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                        $char = pack('C*', $ord_var_c,
                                     @ord($var[$c + 1]),
                                     @ord($var[$c + 2]));
                        $c += 2;
                        $utf16 = $this->utf82utf16($char);
                        $ascii .= sprintf('\u%04s', bin2hex($utf16));
                        break;

                    case (($ord_var_c & 0xF8) == 0xF0):
                        if ($c+3 >= $strlen_var) {
                            $c += 3;
                            $ascii .= '?';
                            break;
                        }
                        // characters U-00010000 - U-001FFFFF, mask 11110XXX
                        // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                        $char = pack('C*', $ord_var_c,
                                     ord($var[$c + 1]),
                                     ord($var[$c + 2]),
                                     ord($var[$c + 3]));
                        $c += 3;
                        $utf16 = $this->utf82utf16($char);
                        $ascii .= sprintf('\u%04s', bin2hex($utf16));
                        break;

                    case (($ord_var_c & 0xFC) == 0xF8):
                        // characters U-00200000 - U-03FFFFFF, mask 111110XX
                        // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                        if ($c+4 >= $strlen_var) {
                            $c += 4;
                            $ascii .= '?';
                            break;
                        }
                        $char = pack('C*', $ord_var_c,
                                     ord($var[$c + 1]),
                                     ord($var[$c + 2]),
                                     ord($var[$c + 3]),
                                     ord($var[$c + 4]));
                        $c += 4;
                        $utf16 = $this->utf82utf16($char);
                        $ascii .= sprintf('\u%04s', bin2hex($utf16));
                        break;

                    case (($ord_var_c & 0xFE) == 0xFC):
                    if ($c+5 >= $strlen_var) {
                            $c += 5;
                            $ascii .= '?';
                            break;
                        }
                        // characters U-04000000 - U-7FFFFFFF, mask 1111110X
                        // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                        $char = pack('C*', $ord_var_c,
                                     ord($var[$c + 1]),
                                     ord($var[$c + 2]),
                                     ord($var[$c + 3]),
                                     ord($var[$c + 4]),
                                     ord($var[$c + 5]));
                        $c += 5;
                        $utf16 = $this->utf82utf16($char);
                        $ascii .= sprintf('\u%04s', bin2hex($utf16));
                        break;
                }
            }
            return  '"'.$ascii.'"';

        case 'array':
           /*
            * As per JSON spec if any array key is not an integer
            * we must treat the whole array as an object. We
            * also try to catch a sparsely populated associative
            * array with numeric keys here because some JS engines
            * will create an array with empty indexes up to
            * max_index which can cause memory issues and because
            * the keys, which may be relevant, will be remapped
            * otherwise.
            *
            * As per the ECMA and JSON specification an object may
            * have any string as a property. Unfortunately due to
            * a hole in the ECMA specification if the key is a
            * ECMA reserved word or starts with a digit the
            * parameter is only accessible using ECMAScript's
            * bracket notation.
            */

            // treat as a JSON object
            if (is_array($var) && count($var) && (array_keys($var) !== range(0, sizeof($var) - 1))) {
                $properties = array_map(array($this, 'name_value'),
                                        array_keys($var),
                                        array_values($var));

                foreach($properties as $property) {
                    if(Services_JSON::isError($property)) {
                        return $property;
                    }
                }

                return '{' . join(',', $properties) . '}';
            }

            // treat it like a regular array
            $elements = array_map(array($this, '_encode'), $var);

            foreach($elements as $element) {
                if(Services_JSON::isError($element)) {
                    return $element;
                }
            }

            return '[' . join(',', $elements) . ']';

        case 'object':
        
            // support toJSON methods.
            if (($this->use & SERVICES_JSON_USE_TO_JSON) && method_exists($var, 'toJSON')) {
                // this may end up allowing unlimited recursion
                // so we check the return value to make sure it's not got the same method.
                $recode = $var->toJSON();
                
                if (method_exists($recode, 'toJSON')) {
                    
                    return ($this->use & SERVICES_JSON_SUPPRESS_ERRORS)
                    ? 'null'
                    : new Services_JSON_Error(get_class($var).
                        " toJSON returned an object with a toJSON method.");
                        
                }
                
                return $this->_encode( $recode );
            } 
            
            $vars = get_object_vars($var);
            
            $properties = array_map(array($this, 'name_value'),
                                    array_keys($vars),
                                    array_values($vars));

            foreach($properties as $property) {
                if(Services_JSON::isError($property)) {
                    return $property;
                }
            }

            return '{' . join(',', $properties) . '}';

        default:
            return ($this->use & SERVICES_JSON_SUPPRESS_ERRORS)
                ? 'null'
                : new Services_JSON_Error(gettype($var)." can not be encoded as JSON string");
    }
}