El sáb., 30 de julio de 2022 11:58, Oleksii Bulba oleksii.bulba@gmail.com
escribió:

$memoryAfter = memory_get_usage(true) / 1024 / 1024;

I see that you used memory_get_usage that shows memory usage at the time
of the function call.
As far as I understand, your function does not return any value,
so I suspect that it is obvious that the memory usage after the function
call is the same as before.
But what is the actual memory usage during the function call?
Can you run the same benchmark but with memory_get_peak_usage function
to see how your function uses memory?

$memoryAfter = memory_get_peak_usage(true) / 1024 / 1024;

Also, I'm concerned if it would be better to name the function
is_json_valid?

On Sat, Jul 30, 2022 at 10:37 AM juan carlos morales <
dev.juan.morales@gmail.com> wrote:

Just want to clarify that when I mentioned the use of memory, I wrote down
the function "memory_get_usage()", which basically gives us the memory
handle by php that is related to the memory_limit INI setting.

Now I will provide a benchmark I have done really quick:

Code used (I have the implementation of is_json() done already)

<?php
// make sure you set your memory limit to -1 before running this code
// Here we create a very very very big json string, really big
$limit = 1000000;
$jsonString = '{ "test": { "foo": "bar" },';

for ($i=0; $i < $limit; $i++) {
$jsonString .= " "test$i": { "foo": { "test" : { "foo" : {
"test" : { "foo" : "bar" }}}}},";
}

$jsonString .= ' "testXXXX": { "foo": "replaceme" } }';
//{ "test" : { "foo" : "bar" }}}

$memoryBefore = memory_get_usage(true) / 1024 / 1024;
echo "Megas used before call: " . $memoryBefore . PHP_EOL;

$start = microtime(true);

json_decode($jsonString, null, $limit, 0);
//<------------------ un/comment to show/hide results for json_decode()
//is_json($jsonString);
//<------------------ un/comment to show/hide results for is_json()

$memoryAfter = memory_get_usage(true) / 1024 / 1024;
echo "Megas used after call: " . $memoryAfter . PHP_EOL;

echo "Difference: " . ($memoryAfter - $memoryBefore) . PHP_EOL;

echo "Time: " . (microtime(true) - $start) . " seconds" . PHP_EOL;
return;

Results

json_decode()

Megas used before call: 79.23828125
Megas used after call: 3269.23828125
Difference: 3190
Time: 12.091101884842 seconds

is_json()

Megas used before call: 79.23828125
Megas used after call: 79.23828125
Difference: 0
Time: 5.4537169933319 seconds

And yes, I am open to share the implementation, but after I write the RFC.

Thanks for taking your time to give me a feedback.

El sáb, 30 jul 2022 a las 3:50, Jordan LeDoux (jordan.ledoux@gmail.com)
escribió:

On Fri, Jul 29, 2022 at 7:27 AM juan carlos morales <
dev.juan.morales@gmail.com> wrote:

Why this function ?

At the moment the only way to determine if a JSON-string is valid we
have
to execute the json_decode() function.

The drawback about this, is that json_decode() generates an in memory
an
object/array (depending on parameters) while parsing the string; this
leads
to a memory usage that is not needed (because we use memory for
creating
the object/array) and also can cause an error for reaching the
memory-limit
of the php process.

Sometimes we just need to know is the string is a valid json or not,
and
nothing else.

You say that you have a first-pass at the implementation done. I'd be
curious to see it. My initial thought was that in order to validate the
string, you likely need to allocate extra memory as part of the
validation
that depends on the string size. You'd definitely save the overhead of a
ZVAL, but for such an object that overhead is likely negligible.

So I guess my question would be: in the actual implementation that
lands,
how much memory would this actually save compared to json_decode()? This
seems like it would make the RFC tricky, as the purported benefit of the
RFC depends very tightly on the implementation that lands.

Jordan

Hello Jordan, thanks for the feedback.

I think the benchmark talks by itself (also for the memory Save question).
Also by the fact that in order to run it for json_decode() rhe memory limit
needs to be super high or -1 (no limit, not a good idea in production
right?)

The advantage here is to be able to parse huge strings without reaching the
memory limit set in the INI settings.

I take It as a "IF THIS IS AS GOOD AS IT SEEMS THEN YES" :D

Once again... Thanks

El dom, 31 jul 2022 a las 0:56, Deleu (deleugyn@gmail.com) escribió:

What I'm asking is what's the practical use for this proposed function?
Where are you likely to need to know if a string is valid JSON but not
have
to (try to, with error handling) parse it almost immediately afterwards
anyway?

I'm still on the fence over the general idea, but I thought I could at
least address this question in particular.

I can definitely see it's usefulness on public HTTP API ingesting data
(specially large data) where if the payload is a valid JSON, it gets stored
and processed by a background queue, making it so that the HTTP layer can
either reject the request with a 4xx status or accept it and only truly
decode it on a separate process that may even be hosted by a separate
server with larger memory size.

Before starting, I want to thank all for taking time from your time, to
give me a feedback, I sincerely respect that, so ... thanks!

Sorry for the long message, but I have the feeling that ... this is it, is
now ... or it will not be, at least not now, so ... here my best effort;
even though, I dont put aside the possibility that I might have an
offuscated view/opinion regarding my proposal, so is possible that I might
not see the things right ... you know .. I am human after all.

So, enough of prologue and let's start ....

Why would I have code that checks if a json-string is a valid json, if I

will not use the content inside it? (or something like that)

• Some of you , asked me this question.
• That depends on the infinite amout of use cases that the human brain can
  imagine, that is why I say that is not the right approach to discuss this
  topic.

Why this change then?

• Is web related, ergo, is PHP related.
• It does not add complexity into PHP, with this functionality we are using
  the existing JSON parser that exists in PHP at the moment, the only thing
  we do is to create an interface between "userland" and the parser itself,
  without the need to use memory as json_decode() is using to check if a
  string is a valid json-string or not.

Proposed functionality (proposed, subject to changes for sure, as now I

have only a working and dirty prototype for this)

function is_json(string $json, int $flags): bool {}

Returns:
TRUE if json-string is valid json, otherwise returns FALSE.

Exceptions:
Optionally set, for the same or subset of exceptions of the actual
json_decode(), like the one Syntax Error for example.

So far this is it, subject to changes for sure.

Real open-source project over github using json_decode() just to check if

a json-string is valid ... and nothing else than that.

• I provide here use cases from major projects, where they ned to have code
  that has to be able to check if an string is a valid JSON and nothing else
  than that.
• Please check the link to see full code
• I provide here some small snippets from the link I provide
• We are not discussing here how they implemented the code, what I want to
  show here is that there is a need to check if an string is a valid
  JSON-string without th need to create an object/array out of it.
• Also, we are not discussing if they are mejor projects or not. They are
  listed in github as major projects, with stars and a big community of users
  and developers maintaining them.
• On some snippets I wrote some notes too, because on some of them is not
  obvious how a funciton like the one I propose could be useful.

Symfony Framework

https://github.com/symfony/symfony/blob/870eeb975feb1abb4b8a1722e1fd57beeab2b230/src/Symfony/Component/Validator/Constraints/JsonValidator.php

class JsonValidator extends ConstraintValidator
...
...
...

Laravel Framework

https://github.com/laravel/framework/blob/302a579f00ebcb2573f481054cbeadad9c970605/src/Illuminate/Validation/Concerns/ValidatesAttributes.php

    public function validateJson($attribute, $value)
    {
        if (is_array($value)) {
            return false;
        }

        if (! is_scalar($value) && ! is_null($value) && !
method_exists($value, '__toString')) {
            return false;
        }

        json_decode($value);

        return `json_last_error()` === JSON_ERROR_NONE;
    }

https://github.com/laravel/framework/blob/61eac9cae4717699ecb3941b16c3d775820d4ca2/src/Illuminate/Support/Str.php

    public static function isJson($value)
    {

Magento

https://github.com/magento/magento2/blob/7c6b6365a3c099509d6f6e6c306cb1821910aab0/app/code/Magento/User/Block/Role/Grid/User.php

    private function getJSONString($input)
    {
        $output = json_decode($input);
        return $output ? $this->_jsonEncoder->encode($output) : '{}';
    }

https://github.com/magento/magento2/blob/7c6b6365a3c099509d6f6e6c306cb1821910aab0/lib/internal/Magento/Framework/DB/DataConverter/SerializedToJson.php

    protected function isValidJsonValue($value)
    {
        if (in_array($value, ['null', 'false', '0', '""', '[]'])
            || (json_decode($value) !== null && `json_last_error()` ===
JSON_ERROR_NONE)
        ) {
            return true;
        }
        //JSON last error reset
        json_encode([]);
        return false;
    }

https://github.com/magento/magento2/blob/7c6b6365a3c099509d6f6e6c306cb1821910aab0/lib/internal/Magento/Framework/Serialize/JsonValidator.php

    public function isValid($string)
    {
        if ($string !== false && $string !== null && $string !== '') {
            json_decode($string);
            if (json_last_error() === JSON_ERROR_NONE) {
                return true;
            }
        }
        return false;
    }

getgrav

https://github.com/getgrav/grav/blob/3e7f67f589267e61f823d19824f3ee1b9a8a38ff/system/src/Grav/Common/Data/Validation.php

    public static function validateJson($value, $params)
    {
        return (bool) (@json_decode($value));
    }

Symfony / http-kernel

https://github.com/symfony/http-kernel/blob/94986633e4c3e7facb7defbd094a2e1170486ab5/DataCollector/RequestDataCollector.php

    public function getPrettyJson()
    {
        $decoded = json_decode($this->getContent());
//<------ here they decode, just to check if is valid json-string or not,
that is th reason of this line.

        return \JSON_ERROR_NONE === `json_last_error()` ?
json_encode($decoded, \JSON_PRETTY_PRINT) : null;
    }

Respect / Validation

https://github.com/Respect/Validation/blob/3dcd859d986f1b586b5539ea19962723ab7352ed/library/Rules/Json.php

final class Json extends AbstractRule
{
    /**
     * {@inheritDoc}
     */
    public function validate($input): bool
    {
        if (!is_string($input) || $input === '') {
            return false;
        }

        json_decode($input);

        return `json_last_error()` === JSON_ERROR_NONE;
    }
}

https://github.com/Respect/Validation/blob/3dcd859d986f1b586b5539ea19962723ab7352ed/library/Rules/Json.php

final class Json extends AbstractRule
{
    /**
     * {@inheritDoc}
     */
    public function validate($input): bool
    {
        if (!is_string($input) || $input === '') {
            return false;
        }

        json_decode($input);

        return `json_last_error()` === JSON_ERROR_NONE;
    }
}

humhub

https://github.com/humhub/humhub/blob/26d7e2667a9317057abe335a056ac8e8f4d675fb/protected/humhub/modules/web/security/controllers/ReportController.php

    public function actionIndex()
    {
        Yii::$app->response->statusCode = 204;

        if(!SecuritySettings::isReportingEnabled()) {
            return;
        }

        $json_data = file_get_contents('php://input');
        if ($json_data = json_decode($json_data)) {
                          //<----- here they `json_decode()` just to check if
is valid json-string only, am I right?
            $json_data = json_encode($json_data, `JSON_PRETTY_PRINT` |
JSON_UNESCAPED_SLASHES);
            $json_data = preg_replace('/\'nonce-[^\']*\'/',
"'nonce-xxxxxxxxxxxxxxxxxxxxxxxx'", $json_data);
            Yii::error($json_data, 'web.security');
        }
    }

Prestashop

https://github.com/PrestaShop/PrestaShop/blob/24f9e510ecb0cb002ac3f4834f3210e8d9359899/classes/Validate.php

    public static function isJson($string)
    {
        json_decode($string);

        return `json_last_error()` == JSON_ERROR_NONE;
    }

Wordpress CLI

https://github.com/wp-cli/wp-cli/blob/f3e4b0785aa3d3132ee73be30aedca8838a8fa06/php/utils.php

function is_json( $argument, $ignore_scalars = true ) {
    if ( ! is_string( $argument ) || '' === $argument ) {
        return false;
    }

    if ( $ignore_scalars && ! in_array( $argument[0], [ '{', '[' ], true )
) {
        return false;
    }

    json_decode( $argument, $assoc = true );

    return `json_last_error()` === JSON_ERROR_NONE;
}

JOOMLA CMS

https://github.com/joomla/joomla-cms/blob/09d14c65f25f9bc76f2698e69c4d7b35f43bc848/libraries/src/Form/Field/AccessiblemediaField.php

if (\is_string($value)) {
    json_decode($value);
 //<---------------------------------------------------------- HERE

    // Check if value is a valid JSON string.
    if ($value !== '' && `json_last_error()` !== JSON_ERROR_NONE) {
        /**
         * If the value is not empty and is not a valid JSON string,
         * it is most likely a custom field created in Joomla 3 and
         * the value is a string that contains the file name.
        */
        if (is_file(JPATH_ROOT . '/' . $value)) {
            $value = '{"imagefile":"' . $value . '","alt_text":""}';
        } else {
            $value = '';
        }
    }

Stackoverflow questions related to this

In PHP, this question is one of the most high ranked questions related

to json && php in stackoverflow, "Fastest way to check if a string is JSON
in PHP?"

The question

https://stackoverflow.com/questions/6041741/fastest-way-to-check-if-a-string-is-json-in-php
Viewed 484k times

The ranking

https://stackoverflow.com/questions/tagged/php%20json?sort=MostVotes&edited=true

Person asking how to do exactly this, also providing a real use case;

eventhough in python, the programming language is not important.

https://stackoverflow.com/questions/5508509/how-do-i-check-if-a-string-is-valid-json-in-python

Someone has also doing exactly this , in JAVA

https://stackoverflow.com/questions/3679479/check-if-file-is-json-java