El dom, 31 jul 2022 a las 0:56, Deleu (<deleu...@gmail.com>) escribió:
>
>
> On Sat, Jul 30, 2022, 4:48 PM David Gebler <davidgeb...@gmail.com> wrote:
>
>>
>>
>> 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
