json_encode - PHP code example

The PHP Function JSON_Encode

The php function json_encode is like a skilled maestro who orchestrates a beautiful symphony of PHP data structures and JSON strings. By using this enchanting function, web developers can create structured data that makes their applications more dynamic and efficient.

JSON (JavaScript Object Notation) is a lightweight data interchange format that supports a variety of programming languages. It is commonly used to transfer data between the server and client in web applications. It is easy to read and write for humans and very easy for machines to parse.

PHP supports the JSON data format through its json_encode() and json_decode() functions. These functions take a PHP value, such as a complex array or an object, and convert it into a JSON string that adheres to the JSON data format standards. They also provide functionality to format the JSON output with options such as JSON_PRETTY_PRINT, JSON_UNESCAPED_SLASHES, and JSON_FORCE_OBJECT.

json_encode() accepts a single argument, which is the PHP value to be converted into a JSON string. The value can be any PHP type except resource. It can be a string, an array, or a scalar value such as a number, an object, or a boolean value of true or false.

json_encode() also accepts an optional second argument, which is a bitmask consisting of JSON constants such as JSON_HEX_QUOT, JSON_HEX_TAG, JSON_HEX_AMP, JSON_HEX_APOS, JSON_NUMERIC_CHECK, JSON_PRETTY_PRINT, and JSON_UNESCAPED_SLASHES. These constants determine the behavior of the json_encode() function. For more details, check out the json_encode() function documentation page.

json_encode example

$this->assertSame(['application/json'], $headers['Content-Type']);

    $expected = [];
    foreach ($view->result as $row) {
      $expected_row = [];
      foreach ($view->field as $id => $field) {
        $expected_row[$id] = $field->render($row);
      }
      $expected[] = $expected_row;
    }

    $this->assertSame(json_encode($expected), $actual_json, 'The expected JSON output was found.');

    // Test that the rendered output and the preview output are the same.     $view->destroy();
    $view->setDisplay('rest_export_1');
    // Mock the request content type by setting it on the display handler.     $view->display_handler->setContentType('json');
    $output = $view->preview();
    $this->assertSame((string) $this->renderer->renderRoot($output), $actual_json, 'The expected JSON preview output was found.');

    // Test a 403 callback.     $this->drupalGet('test/serialize/denied', ['query' => ['_format' => 'json']]);

'stringValue' => 'string',
            'scalarValue' => 1,
            'objectValue' => new ArrayStruct(),
            'intValue' => 1,
            'floatValue' => 1.1,
            'callableValue' => function D): void {
            },
            'arrayValue' => [],
            'jsonEncode' => [
                'data' => $jsonEncodeData,
                'expected' => [
                    json_encode($jsonEncodeData),
                    json_encode($jsonEncodeData, \JSON_UNESCAPED_SLASHES),
                    json_encode($jsonEncodeData, \JSON_PRETTY_PRINT),
                    json_encode($jsonEncodeData, \JSON_PRETTY_PRINT | \JSON_UNESCAPED_SLASHES),
                ],
            ],
        ];

        $result = $renderer->render($template, $data, Context::createDefaultContext());

        $expected = '';
        for ($i = 1; $i <= 22; ++$i) {

        if (!\is_string($options['auth_basic'] ?? '')) {
            throw new InvalidArgumentException(sprintf('Option "auth_basic" must be string or an array, "%s" given.', get_debug_type($options['auth_basic'])));
        }

        if (isset($options['auth_bearer'])) {
            if (!\is_string($options['auth_bearer'])) {
                throw new InvalidArgumentException(sprintf('Option "auth_bearer" must be a string, "%s" given.', get_debug_type($options['auth_bearer'])));
            }
            if (preg_match('{[^\x21-\x7E]}', $options['auth_bearer'])) {
                throw new InvalidArgumentException('Invalid character found in option "auth_bearer": '.json_encode($options['auth_bearer']).'.');
            }
        }

        if (isset($options['auth_basic'], $options['auth_bearer'])) {
            throw new InvalidArgumentException('Define either the "auth_basic" or the "auth_bearer" option, setting both is not supported.');
        }

        if (null !== $url) {
            // Merge auth with headers             if (($options['auth_basic'] ?? false) && !($options['normalized_headers']['authorization'] ?? false)) {
                $options['normalized_headers']['authorization'] = ['Authorization: Basic '.base64_encode($options['auth_basic'])];
            }

// Expect no exception was thrown         $this->addToAssertionCount(1);
    }

    private function createOrderPayload(): array
    {
        $addressId = Uuid::randomHex();

        return [
            'id' => Uuid::randomHex(),
            '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),
            'orderDateTime' => (new \DateTimeImmutable())->format(Defaults::STORAGE_DATE_TIME_FORMAT),
            'price' => new CartPrice(10, 10, 10, new CalculatedTaxCollection(), new TaxRuleCollection(), CartPrice::TAX_STATE_NET),
            'shippingCosts' => new CalculatedPrice(10, 10, new CalculatedTaxCollection(), new TaxRuleCollection()),
            'orderCustomer' => [
                'id' => Uuid::randomHex(),
                'email' => 'test@example.com',
                'salutationId' => $this->fetchFirstIdFromTable('salutation'),
                'firstName' => 'Max',
                'lastName' => 'Mustermann',
            ],

$fakeClaims = [
            'aud' => 'administration',
            'jti' => '0dfaa92d1cda2bfe24c08e82cafa10687b6ea3e242186712c4b27508ccc5d43271d1863805460c44',
            'iat' => $currentTimestamp - 1, // make the token expired             'nbf' => 1529436192,
            'exp' => 1529439792,
            'sub' => '7261d26c3e36451095afa7c05f8732b5',
            'scopes' => ['write'],
        ];

        $expiredToken = 'Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiIsImp0aSI6IjBkZmFhOTJkMWNkYTJiZmUyNGMwOGU4MmNhZmExMDY4N2I2ZWEzZTI0MjE4NjcxMmM0YjI3NTA4Y2NjNWQ0MzI3MWQxODYzODA1NDYwYzQ0In0.'
            . (new JoseEncoder())->base64UrlEncode(json_encode($fakeClaims, \JSON_THROW_ON_ERROR))
            . '.DBYbAWNpwxGL6QngLidboGbr2nmlAwjYcJIqN02sRnZNNFexy9V6uyQQ-8cJ00anwxKhqBovTzHxtXBMhZ47Ix72hxNWLjauKxQlsHAbgIKBDRbJO7QxgOU8gUnSQiXzRzKoX6XBOSHXFSUJ239lF4wai7621aCNFyEvlwf1JZVILsLjVkyIBhvuuwyIPbpEETui19BBaJ0eQZtjXtpzjsWNq1ibUCQvurLACnNxmXIj8xkSNenoX5B4p3R1gbDFuxaNHkGgsrQTwkDtmZxqCb3_0AgFL3XX0mpO5xsIJAI_hLHDPvv5m0lTQgMRrlgNdfE7ecI4GLHMkDmjWoNx_A';

        $request = $request->withHeader('authorization', $expiredToken);

        $request = $request->withAttribute(PlatformRequest::ATTRIBUTE_OAUTH_USER_ID, $admin->getUserId());

        $userRepository = $this->getContainer()->get('user.repository');

        // Change user password         $userRepository->update([[
            'id' => $admin->getUserId(),

if (!\is_array($modules)) {
                return $app;
            }

            foreach ($modules as &$module) {
                $module['parent'] ??= null;
                $module['position'] ??= 1;
            }

            return [
                'id' => $app['id'],
                'modules' => json_encode($modules, \JSON_THROW_ON_ERROR),
            ];
        }, $apps);
    }

    /** * @param list<array{id: string, modules: string|null}> $preparedModules */
    private function updateModules(array $preparedModules, Connection $connection): void
    {
        $connection->beginTransaction();

$mail->getHeaders()->add(new MetadataHeader('tagName1', 'tag Value1'));
        $mail->getHeaders()->add(new MetadataHeader('tagName2', 'tag Value2'));

        $message = $transport->send($mail);

        $this->assertSame('foobar', $message->getMessageId());
    }

    public function testSendThrowsForErrorResponse()
    {
        $client = new MockHttpClient(function Dstring $method, string $url, array $options): ResponseInterface {
            $json = json_encode([
                'message' => 'i\'m a teapot',
                'type' => 'sender',
            ]);

            return new MockResponse($json, [
                'http_code' => 418,
                'response_headers' => [
                    'x-amzn-errortype' => '418',
                ],
            ]);
        });

$keys = \array_intersect_key($options, [
            SalesChannelContextService::CURRENCY_ID => true,
            SalesChannelContextService::LANGUAGE_ID => true,
            SalesChannelContextService::DOMAIN_ID => true,
            SalesChannelContextService::PAYMENT_METHOD_ID => true,
            SalesChannelContextService::SHIPPING_METHOD_ID => true,
            SalesChannelContextService::VERSION_ID => true,
            SalesChannelContextService::COUNTRY_ID => true,
            SalesChannelContextService::COUNTRY_STATE_ID => true,
        ]);

        $key = implode('-', [$name, md5(json_encode($keys, \JSON_THROW_ON_ERROR))]);

        $value = $this->cache->get($key, function DItemInterface $item) use ($name, $salesChannelId, $options) {
            $context = $this->tracer->trace($name, fn () => $this->decorated->create($salesChannelId, $options));

            $keys = array_unique(array_merge(
                $this->tracer->get($name),
                [$name, CachedSalesChannelContextFactory::ALL_TAG]
            ));

            $item->tag($keys);

public function update(Connection $connection): void
    {
        $field = $connection->fetchOne(
            'SHOW COLUMNS FROM `country_translation` WHERE `Field` LIKE :column;',
            ['column' => 'address_format']
        );

        if (!empty($field)) {
            return;
        }

        $addressFormat = json_encode(CountryDefinition::DEFAULT_ADDRESS_FORMAT);

        $connection->executeStatement(' ALTER TABLE `country_translation` ADD COLUMN `address_format` JSON NULL AFTER `name`; ');

        $connection->update('country_translation', [
            'address_format' => $addressFormat,
        ], ['address_format' => null]);

        $connection->executeStatement(
            'ALTER TABLE `country_translation` MODIFY `address_format` JSON NOT NULL;'
        );

$profiles = $connection->fetchAllAssociative('SELECT * FROM `import_export_profile`');

        foreach ($profiles as $profile) {
            $mappings = \json_decode((string) $profile['mapping'], true, 512, \JSON_THROW_ON_ERROR);

            foreach ($mappings as $index => &$mapping) {
                $mapping['position'] = $index;
            }

            $connection->update(
                'import_export_profile',
                ['mapping' => \json_encode($mappings, \JSON_THROW_ON_ERROR)],
                ['id' => $profile['id']]
            );
        }
    }

    public function updateDestructive(Connection $connection): void
    {
        // implement update destructive     }
}

'name' => 'Stream',
                'created_at' => (new \DateTime())->format(Defaults::STORAGE_DATE_TIME_FORMAT),
            ]
        );

        $this->connection->insert(
            'product_stream_filter',
            [
                'id' => Uuid::randomBytes(),
                'type' => 'range',
                'field' => 'price.gross',
                'parameters' => json_encode([RangeFilter::GTE => 10]),
                'position' => 1,
                'product_stream_id' => Uuid::fromHexToBytes($id),
                'created_at' => (new \DateTime())->format(Defaults::STORAGE_DATE_TIME_FORMAT),
            ]
        );

        $message = $this->indexer->update($this->createWrittenEvent($id));
        static::assertInstanceOf(EntityIndexingMessage::class, $message);
        $this->indexer->handle($message);

        /** @var ProductStreamEntity $entity */

public function cleanup($useTimer = true)
    {
        $this->useTimer = $useTimer;

        if ($this->useTimer) {
            $this->timeTarget = time() + 5;
        }

        try {
            $result = $this->deleteCacheDirectories(0);
            if (!$result->getIsReady() && $this->useTimer) {
                return json_encode([
                    'deletedFiles' => $result->getFileCount(),
                    'ready' => $result->getIsReady(),
                    'error' => false,
                ]);
            }

            $result = $this->deleteTemporaryBackupDirectory($result->getFileCount());
            if ($this->useTimer) {
                return json_encode([
                    'deletedFiles' => $result->getFileCount(),
                    'ready' => $result->getIsReady(),

public function testMigrationWithExistingTemplateData(): void
    {
        $this->rollbackMigrationChanges();

        // Add invoice for example         $existingTypeId = Uuid::randomBytes();
        $this->connection->insert(
            'mail_template_type',
            [
                'id' => $existingTypeId,
                'technical_name' => MailTemplateTypes::MAILTYPE_REVIEW_FORM,
                'available_entities' => json_encode(['salesChannel' => 'sales_channel']),
                'created_at' => (new \DateTime())->format(Defaults::STORAGE_DATE_TIME_FORMAT),
            ]
        );

        $this->connection->insert(
            'mail_template_type_translation',
            [
                'mail_template_type_id' => $existingTypeId,
                'name' => 'New product review',
                'language_id' => Uuid::fromHexToBytes(Defaults::LANGUAGE_SYSTEM),
                'created_at' => (new \DateTime())->format(Defaults::STORAGE_DATE_TIME_FORMAT),
            ]

else {
            // The user must be reloaded via the primary key as all other data             // might have changed without proper persistence in the database.             // That's the case when the user has been changed by a form with             // validation errors.             if (!$id = $this->getClassMetadata()->getIdentifierValues($user)) {
                throw new \InvalidArgumentException('You cannot refresh a user from the EntityUserProvider that does not contain an identifier. The user object has to be serialized with its own identifier mapped by Doctrine.');
            }

            $refreshedUser = $repository->find($id);
            if (null === $refreshedUser) {
                $e = new UserNotFoundException('User with id '.json_encode($id).' not found.');
                $e->setUserIdentifier(json_encode($id));

                throw $e;
            }
        }

        if ($refreshedUser instanceof Proxy && !$refreshedUser->__isInitialized()) {
            $refreshedUser->__load();
        }

        return $refreshedUser;
    }

'zipcode' => 'Test',
            'countryId' => $this->getValidCountryId(),
        ];

        $this->browser
            ->request(
                'POST',
                '/store-api/account/address',
                [],
                [],
                ['CONTENT_TYPE' => 'application/json'],
                (string) \json_encode($data, \JSON_THROW_ON_ERROR)
            );

        $response = json_decode((string) $this->browser->getResponse()->getContent(), true, 512, \JSON_THROW_ON_ERROR);
        $addressId = $response['id'];

        $contextData = [
            'billingAddressId' => $addressId,
            'shippingAddressId' => $addressId,
        ];

        $this->browser