json_decode - PHP code example

Using the PHP Function JSON_Decode()

PHP has a number of built-in functions for working with JSON (JavaScript Object Notation) data. Among them is the json_decode() function, which transforms JSON-formatted strings into native PHP arrays and objects. This makes it easy for developers to work with this type of data in their web applications. In this article, we’ll look at the json_decode() function in more detail and see how it can be used.

json_decode() accepts the following arguments:

$json: The JSON string to be decoded. This string must be in UTF-8 format. $assoc: A boolean value that states whether the returned objects will be converted into associative arrays. If this is not true, the function will return a default PHP object. $depth: The recursion depth specified by the user. $flags: A bitmask that includes JSON_OBJECT_AS_ARRAY, JSON_BIGINT_AS_STRING, and JSON_THROW_ON_ERROR.

The json_decode() function returns a PHP value in the appropriate data type representing the $json string. If the recursion limit is exceeded, it will return NULL. If an error is encountered while trying to decode the string, json_last_error() will be called to determine the nature of the error.

JSON is a popular file format and data interchange protocol used in modern web applications. Its ease of use and flexibility makes it an ideal choice for storing and transmitting data between a server and a client, or even a single web page. To use it with PHP, you need to know how to encode and decode it. To do this, you need to be familiar with php function json_encode() and php function json_decode().

json_decode example

<?php
use Symfony\Component\RemoteEvent\Event\Sms\SmsEvent;

$wh = new SmsEvent(SmsEvent::DELIVERED, 'aaaaaaaa-bbbb-cccc-dddd-0123456789ab', json_decode(file_get_contents(str_replace('.php', '.json', __FILE__)), true, flags: \JSON_THROW_ON_ERROR));
$wh->setRecipientPhone('447700900000');

return $wh;

try {
            $contentTypes = $this->connection->query('SELECT internalName, config FROM s_content_types');
        } catch (Exception $e) {
            return [];
        }

        $result = [];

        try {
            foreach ($contentTypes->fetchAll(PDO::FETCH_KEY_PAIR) as $key => $type) {
                $result[$key] = json_decode($type, true);
            }
        } catch (Exception $e) {
        }

        return $result;
    }
}

/** * Returns decoded JSON from post content string, * or a 404 if not found. * * @since 6.3.0 * * @param string $raw_json Encoded JSON from global styles custom post content. * @return Array|WP_Error */
    protected function get_decoded_global_styles_json( $raw_json ) {
        $decoded_json = json_decode( $raw_json, true );

        if ( is_array( $decoded_json ) && isset( $decoded_json['isGlobalStylesUserThemeJSON'] ) && true === $decoded_json['isGlobalStylesUserThemeJSON'] ) {
            return $decoded_json;
        }

        return new WP_Error(
            'rest_global_styles_not_found',
            __( 'Cannot find user global styles revisions.' ),
            array( 'status' => 404 )
        );
    }

static::assertInstanceOf(RequestInterface::class, $lastRequest);
        static::assertEquals('/swplatform/tracking/events', $lastRequest->getUri()->getPath());
        static::assertEquals(
            [
                'instanceId' => 'test-instance-id',
                'additionalData' => [
                    'shopwareVersion' => '6.5.0.0-test',
                    'someAdditionalData' => 'xy',
                ],
                'event' => 'Tracking event fired and returned',
            ],
            \json_decode($lastRequest->getBody()->getContents(), true, 512, \JSON_THROW_ON_ERROR)
        );
    }

    public function testEventDoesNotThrowExceptionOnRequestException(): void
    {
        $mockHandler = new MockHandler();
        $mockHandler->append(new \Exception());
        $httpClient = new Client(['handler' => HandlerStack::create($mockHandler)]);

        $instanceService = $this->createMock(InstanceService::class);
        $instanceService->method('getShopwareVersion')->willReturn('6.5.0.0-test');

        $this->View()->assign(['success' => true]);
    }

    /** * Changes Position of option in group */
    public function changeGroupPositionAction()
    {
        $data = $this->Request()->getParam('data');
        $data = json_decode($data, true);

        $db = $this->get('db');
        foreach ($data as $row) {
            $db->update(
                's_filter_relations',
                ['position' => $row['position']],
                ['groupID = ?' => $row['groupId'], 'optionID = ?' => $row['optionId']]
            );
        }

        $this->View()->assign(['success' => true, 'data' => $data]);
    }

public function testLoadShouldReturnSuccess(): void
    {
        $productId = $this->createProduct($this->context);
        $customerWishlistId = $this->createCustomerWishlist($this->context, $this->customerId, $productId);

        $this->browser
            ->request(
                'POST',
                '/store-api/customer/wishlist'
            );
        $response = json_decode((string) $this->browser->getResponse()->getContent(), true, 512, \JSON_THROW_ON_ERROR);
        $wishlist = $response['wishlist'];
        $products = $response['products'];

        static::assertNotEmpty($response);
        static::assertEquals($customerWishlistId, $wishlist['id']);
        static::assertEquals(1, $products['total']);
        static::assertNotNull($products['elements']);
    }

    public function testDeleteProductShouldThrowCustomerWishlistNotActivatedException(): void
    {

// Check that we actually got JSON.         if ( ! $this->is_json_content_type() ) {
            return true;
        }

        $body = $this->get_body();
        if ( empty( $body ) ) {
            return true;
        }

        $params = json_decode( $body, true );

        /* * Check for a parsing error. */
        if ( null === $params && JSON_ERROR_NONE !== json_last_error() ) {
            // Ensure subsequent calls receive error instance.             $this->parsed_json = false;

            $error_data = array(
                'status'             => WP_Http::BAD_REQUEST,
                'json_error_code'    => json_last_error(),

    /** * Sets options used while encoding data to JSON. * * @return $this */
    public function setEncodingOptions(int $encodingOptions): static
    {
        $this->encodingOptions = $encodingOptions;

        return $this->setData(json_decode($this->data));
    }

    /** * Updates the content and headers according to the JSON data and callback. * * @return $this */
    protected function update(): static
    {
        if (null !== $this->callback) {
            // Not using application/javascript for compatibility reasons with older browsers.

$this->service->sync($operations, Context::createDefaultContext(), new SyncBehavior());
    }

    public function testSingleOperationWithDeletesAndWrites(): void
    {
        $ids = new TestDataCollection();

        $currency = [
            'name' => 'test',
            'factor' => 2,
            'symbol' => '€',
            'itemRounding' => json_decode(json_encode(new CashRoundingConfig(2, 0.01, true), \JSON_THROW_ON_ERROR), true, 512, \JSON_THROW_ON_ERROR),
            'totalRounding' => json_decode(json_encode(new CashRoundingConfig(2, 0.01, true), \JSON_THROW_ON_ERROR), true, 512, \JSON_THROW_ON_ERROR),
            'shortName' => 'TEST',
        ];

        $this->getContainer()->get('currency.repository')->create(
            [
                array_merge($currency, ['id' => $ids->get('currency-1'), 'isoCode' => 'xx']),
                array_merge($currency, ['id' => $ids->get('currency-2'), 'isoCode' => 'xy']),
            ],
            Context::createDefaultContext()
        );

__DIR__.'/../fixtures/importmaps/'
        );
        $this->assertEquals(['imports' => [
            '@hotwired/stimulus' => 'https://unpkg.com/@hotwired/stimulus@3.2.1/dist/stimulus.js',
            'lodash' => '/assets/vendor/lodash-ad7bd7bf42edd09654255a82b9027810.js',
            'app' => '/assets/app-ea9ebe6156adc038aba53164e2be0867.js',
            '/assets/pizza/index.js' => '/assets/pizza/index-b3fb5ee31adaf5e1b32d28edf1ab8e7a.js',
            '/assets/popcorn.js' => '/assets/popcorn-c0778b84ef9893592385aebc95a2896e.js',
            '/assets/imported_async.js' => '/assets/imported_async-8f0cd418bfeb0cf63826e09a4474a81c.js',
            'other_app' => '/assets/namespaced_assets2/app2-d5bf10c20bf9a0b77e67d78fcac301c5.js',
            '/assets/namespaced_assets2/imported.js' => '/assets/namespaced_assets2/imported-9ab37dabcfe317fba77123a4e573d53b.js',
        ]], json_decode($manager->getImportMapJson(), true));
    }

    public function testGetImportMapJsonUsesDumpedFile()
    {
        $manager = $this->createImportMapManager(
            ['assets' => ''],
            __DIR__.'/../fixtures/',
            '/final-assets',
            'test_public'
        );
        $this->assertEquals(['imports' => [

                if (isset($thisfile_riff_WAVE['guan'][0]['data'])) {
                    // shortcut                     $thisfile_riff_WAVE_guan_0 = &$thisfile_riff_WAVE['guan'][0];
                    if (!empty($thisfile_riff_WAVE_guan_0['data']) && (substr($thisfile_riff_WAVE_guan_0['data'], 0, 14) == 'GUANO|Version:')) {
                        $thisfile_riff['guano'] = array();
                        foreach (explode("\n", $thisfile_riff_WAVE_guan_0['data']) as $line) {
                            if ($line) {
                                @list($key, $value) = explode(':', $line, 2);
                                if (substr($value, 0, 3) == '[{"') {
                                    if ($decoded = @json_decode($value, true)) {
                                        if (!empty($decoded) && (count($decoded) == 1)) {
                                            $value = $decoded[0];
                                        } else {
                                            $value = $decoded;
                                        }
                                    }
                                }
                                $thisfile_riff['guano'] = array_merge_recursive($thisfile_riff['guano'], getid3_lib::CreateDeepArray($key, '|', $value));
                            }
                        }

public function testIndexing(?IdsCollection $ids = null): IdsCollection
    {
        try {
            $ids ??= new IdsCollection();
            $currency = [
                'id' => $ids->get('currency'),
                'factor' => 2,
                'symbol' => 'T',
                'isoCode' => 'TTT',
                'position' => 3,
                'itemRounding' => json_decode(json_encode(new CashRoundingConfig(2, 0.01, true), \JSON_THROW_ON_ERROR), true, 512, \JSON_THROW_ON_ERROR),
                'totalRounding' => json_decode(json_encode(new CashRoundingConfig(2, 0.01, true), \JSON_THROW_ON_ERROR), true, 512, \JSON_THROW_ON_ERROR),
                'shortName' => 'TE',
                'name' => 'Test',
            ];
            $this->getContainer()->get('currency.repository')
                ->create([$currency], Context::createDefaultContext());

            $products = [
                // no rule = 70€                 (new ProductBuilder($ids, 'p.1'))
                    ->price(70, null, 'default', 77)

$request = new Request();
        $request->request->set('term', 'elasticsearch');
        $request->request->set('entities', ['promotion']);
        $response = $this->controller->elastic($request, Context::createDefaultContext());

        static::assertEquals(200, $response->getStatusCode());

        $content = $response->getContent();
        static::assertNotFalse($content);

        $content = json_decode($content, true, 512, \JSON_THROW_ON_ERROR);

        static::assertNotEmpty($content['data']);
        static::assertNotEmpty($content['data']['promotion']);

        $data = $content['data']['promotion'];

        static::assertEquals(1, $data['total']);
        static::assertNotEmpty($data['data'][$id]);
        static::assertEquals($id, $data['data'][$id]['id']);
        static::assertEquals('elasticsearch', $data['data'][$id]['name']);
    }

    /** * @return array<string, mixed> */
    private function fetchSystemMailTemplateAvailableEntitiesFromType(Connection $connection, string $mailTemplateType): array
    {
        $availableEntities = $connection->executeQuery(' SELECT `available_entities` FROM `mail_template_type` WHERE `technical_name` = :mailTemplateType AND updated_at IS NULL; ', ['mailTemplateType' => $mailTemplateType])->fetchOne();

        if ($availableEntities === false || !\is_string($availableEntities) || json_decode($availableEntities, true, 512, \JSON_THROW_ON_ERROR) === null) {
            return [];
        }

        return json_decode($availableEntities, true, 512, \JSON_THROW_ON_ERROR);
    }

    private function updateMailTemplateTranslation(
        Connection $connection,
        string $mailTemplateId,
        ?string $langId,
        ?string $contentHtml,
        ?

if ($max <= 0) {
                throw new \RuntimeException('Failed to find plugin composer.json. Starting point ' . $callerFile);
            }

            $pathToComposerJson = $dir . '/composer.json';
        }

        if (!\is_file($pathToComposerJson)) {
            throw new \RuntimeException('Could not auto detect plugin name via composer.json. Path: ' . $pathToComposerJson);
        }

        $composer = json_decode((string) file_get_contents($pathToComposerJson), true, 512, \JSON_THROW_ON_ERROR);
        $baseClass = $composer['extra']['shopware-plugin-class'] ?? '';
        if ($baseClass === '') {
            throw new \RuntimeException('composer.json does not contain `extra.shopware-plugin-class`. Path: ' . $pathToComposerJson);
        }

        $parts = explode('\\', (string) $baseClass);
        $pluginName = end($parts);

        $this->addActivePlugins($pluginName);

        return $this;
    }