JSON'u doğrulamak için normal ifade

91

Json'u doğrulamama izin veren bir Regex arıyorum.

Regex'ler konusunda çok yeniyim ve Regex ile ayrıştırmanın kötü olduğunu yeterince biliyorum, ancak doğrulama için kullanılabilir mi?

regex  json 
— Kırık
kaynak
31
Neden ayrı bir doğrulama adımıyla uğraşasınız? Çoğu dilde JSON'u ayrıştırabilen JSON kitaplıkları vardır ve eğer onu ayrıştırabilirse, geçerliydi. Değilse, kütüphane size söyleyecektir.
— Epcylon
Metni doğrulamak için ayrıştırmanız gerekir ...
— Ken
3
@mario - Bilmiyorum ... Ben regex'i kötüye kullanmaktan yanayım ve "normal ifadenin normal şekilde eşleşmesi gerekir" yanılgısına itirazınıza son derece sempati duyuyorum - ancak pratik, işle ilgili sorularda değil. Buradaki en iyi cevap gerçekten Epcylon'un yorumu ... (belki bu tartışma sohbete aittir?)
— Kobi
1
Başka bir pratik kullanım durumu, JSON ifadelerini daha büyük bir dizede bulmaktır . Yalnızca "bu dize burada bir JSON nesnesi mi?" Diye sormak istiyorsanız, evet, JSON ayrıştırma kitaplığı muhtemelen daha iyi bir araçtır. Ancak JSON nesnelerini sizin için daha büyük bir yapı içinde bulamaz.
— Mark Amery
1
Bu bir cevap değil, ancak Crockford'un JSON-js kütüphanesinin bu bölümünü kullanabilirsiniz . 4 normal ifade kullanır ve bunları akıllıca bir şekilde birleştirir.
— imgx64

Yanıtlar:

187

Evet, tam bir normal ifade doğrulaması mümkündür.

Modern regex uygulamalarının çoğu, eksiksiz bir JSON serileştirilmiş yapıyı doğrulayabilen yinelemeli yeniden ifadelere izin verir. Json.org şartname oldukça basit hale getirir.

$pcre_regex = '
  /
  (?(DEFINE)
     (?<number>   -? (?= [1-9]|0(?!\d) ) \d+ (\.\d+)? ([eE] [+-]? \d+)? )    
     (?<boolean>   true | false | null )
     (?<string>    " ([^"\\\\]* | \\\\ ["\\\\bfnrt\/] | \\\\ u [0-9a-f]{4} )* " )
     (?<array>     \[  (?:  (?&json)  (?: , (?&json)  )*  )?  \s* \] )
     (?<pair>      \s* (?&string) \s* : (?&json)  )
     (?<object>    \{  (?:  (?&pair)  (?: , (?&pair)  )*  )?  \s* \} )
     (?<json>   \s* (?: (?&number) | (?&boolean) | (?&string) | (?&array) | (?&object) ) \s* )
  )
  \A (?&json) \Z
  /six   
';

PHP'de PCRE işlevleriyle oldukça iyi çalışır . Perl'de değiştirilmeden çalışmalıdır; ve kesinlikle diğer diller için uyarlanabilir. Ayrıca JSON test durumlarında başarılı olur .

Daha basit RFC4627 doğrulaması

Daha basit bir yaklaşım, RFC4627, bölüm 6'da belirtildiği gibi minimum tutarlılık kontrolüdür . Bununla birlikte, yalnızca güvenlik testi ve temel geçerliliğe karşı önlem olarak tasarlanmıştır:

  var my_JSON_object = !(/[^,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]/.test(
         text.replace(/"(\\.|[^"\\])*"/g, ''))) &&
     eval('(' + text + ')');
— Mario
kaynak
23
+1
— Normal
8
@mario, benim -naysayers-departmanında olduğumu düşünüyor musun emin değilim , ama değilim. Ekstre geldiğini hatırlatırız "Çoğu modern regex uygulamaları özyinelemeli regexpressions izin" son derece tartışmalıdır. AFAIK, yalnızca Perl, PHP ve .NET özyinelemeli kalıpları tanımlama yeteneğine sahiptir. Ben buna "en çok" demezdim.
— Bart Kiers
3
@Bart: Evet, bu haklı olarak tartışmalı. En ironik olanı, Javascript normal ifade motorları JSON'u doğrulamak için (veya yalnızca ayrıntılı geçici çözümlerle) böyle özyinelemeli bir normal ifade kullanamaz. Yani regex == posix regex ise bu bir seçenek değildir. Yine de çağdaş uygulamalarla yapılabilir olması ilginç; birkaç pratik kullanım durumunda bile. (Ama doğru, libpcre her yerde yaygın olan bir motor değil.) - Ayrıca kayıt için: Sentetik bir geri dönüş rozeti bekliyordum, ancak birkaç çoğunluk yükseltmesi almamanız bunu engelliyor. : /
— mario
4
Hayır! Popülist rozetinin peşindeydim, bunun için 20 oya ihtiyacım var ama cevabınız için hala 10 oy. Aksine, sorunuza yapılan olumsuz oylar benim yararıma değil.
— mario
2
Daha ileriye baktığımızda, bu regexp'in başka birçok sorunu var. JSON verileriyle eşleşir, ancak JSON olmayan bazı veriler de eşleşir. Örneğin, tek değişmez falsedeğer eşleşirken üst düzey JSON değeri bir dizi veya bir nesne olmalıdır. Ayrıca karakter kümesinde dizelerde veya boşluklarda izin verilen birçok sorunu vardır.
— dolmen
32

Evet, Normal İfadelerin yalnızca normal dillerle eşleşebileceği yaygın bir yanılgıdır . Aslında, PCRE işlevleri normal dillerden çok daha fazlasıyla eşleşebilir, bağlamdan bağımsız bazı dillerle bile eşleşebilirler! Wikipedia'nın RegExps makalesi bununla ilgili özel bir bölüme sahiptir.

JSON, PCRE kullanılarak çeşitli şekillerde tanınabilir! @mario, adlandırılmış alt şablonlar ve geri referanslar kullanarak harika bir çözüm gösterdi . Sonra özyinelemeli kalıplar kullanan bir çözüm olması gerektiğini belirtti (?R). İşte PHP ile yazılmış böyle bir regexp örneği:

$regexString = '"([^"\\\\]*|\\\\["\\\\bfnrt\/]|\\\\u[0-9a-f]{4})*"';
$regexNumber = '-?(?=[1-9]|0(?!\d))\d+(\.\d+)?([eE][+-]?\d+)?';
$regexBoolean= 'true|false|null'; // these are actually copied from Mario's answer
$regex = '/\A('.$regexString.'|'.$regexNumber.'|'.$regexBoolean.'|';    //string, number, boolean
$regex.= '\[(?:(?1)(?:,(?1))*)?\s*\]|'; //arrays
$regex.= '\{(?:\s*'.$regexString.'\s*:(?1)(?:,\s*'.$regexString.'\s*:(?1))*)?\s*\}';    //objects
$regex.= ')\Z/is';

Ben kullanıyorum (?1)yerine (?R)ikinci referanslar nedeniyle tüm desen, ama biz var \Ave \Zalt şablonların içine kullanılmamalıdır dizileri. (?1)en dıştaki parantezle işaretlenmiş normal ifadeye başvurular (bu nedenle en dıştaki ile ( )başlamaz ?:). Böylece, RegExp 268 karakter uzunluğunda olur :)

/\A("([^"\\]*|\\["\\bfnrt\/]|\\u[0-9a-f]{4})*"|-?(?=[1-9]|0(?!\d))\d+(\.\d+)?([eE][+-]?\d+)?|true|false|null|\[(?:(?1)(?:,(?1))*)?\s*\]|\{(?:\s*"([^"\\]*|\\["\\bfnrt\/]|\\u[0-9a-f]{4})*"\s*:(?1)(?:,\s*"([^"\\]*|\\["\\bfnrt\/]|\\u[0-9a-f]{4})*"\s*:(?1))*)?\s*\})\Z/is

Her neyse, bu pratik bir çözüm olarak değil, bir "teknoloji gösterimi" olarak görülmelidir. PHP'de JSON dizgesini json_decode()işlevi çağırarak doğrulayacağım (aynen @Epcylon'da belirtildiği gibi). Bu JSON'u kullanacaksam (doğrulanmışsa), o zaman bu en iyi yöntemdir.

— Hrant Haçatriyen
kaynak
1
Kullanmak \dtehlikelidir. Pek çok regexp uygulamasında \d, yalnızca [0-9]değil, bunun yerine alternatif komut dosyaları içeren bir rakamın Unicode tanımıyla eşleşir .
— dolmen
@dolmen: haklı olabilirsin, ancak bunu kendi başına soruya dönüştürmemelisin. Sadece yorum olarak eklemek yeterli olacaktır.
— Dennis Haarbrink
\dPHP'nin PCRE uygulamasında unicode sayılarıyla eşleşmediğini düşünüyorum . Örneğin ٩sembol (0x669 arapça işaretli rakam dokuz) desen kullanılarak eşleştirilecek #\p{Nd}#uancak eşleşmeyecek#\d#u
— Hrant Khachatrian
@ hrant-khachatrian: /uBayrağı kullanmadığınız için değil . JSON, UTF-8 olarak kodlanmıştır. Düzgün bir regexp için bu bayrağı kullanmalısınız.
— dolmen
1
@dolmen uDeğiştiriciyi kullandım , lütfen önceki yorumumdaki kalıplara tekrar bakın :) Dizeler, sayılar ve boole'lar en üst seviyede doğru şekilde eşleşiyor. Uzun regexp'i buraya quanetic.com/Regex yapıştırabilir ve kendinizi deneyebilirsiniz
— Hrant Khachatrian
14

JSON'un (iç içe geçmiş {...}-s) yinelemeli doğası nedeniyle , normal ifade onu doğrulamak için uygun değildir. Elbette, bazı normal ifade çeşitleri, kalıplarla * tekrar tekrar eşleşebilir (ve bu nedenle JSON ile eşleşebilir), ancak ortaya çıkan kalıplara bakmak korkunçtur ve asla IMO üretim kodunda kullanılmamalıdır!

* Olsa birçok regex uygulamalar değil Dikkat değil özyinelemeli desenleri destekler. Popüler programlama dillerinden bunlar yinelemeli kalıpları destekler: Perl, .NET, PHP ve Ruby 1.9.2

— Bart Kiers
kaynak
3
— Darien
16
@all down seçmenler: "regex bunu doğrulamak için uygun değil" , belirli normal ifade motorlarının bunu yapamayacağı anlamına gelmez (en azından ben bunu kastediyorum). Elbette, bazı normal ifade uygulamaları yapabilir , ancak aklı başında herkes bir JSON ayrıştırıcısı kullanır. Tıpkı birisi sadece bir çekiçle nasıl eksiksiz bir ev inşa edileceğini sorarsa, çekicin iş için uygun olmadığını, eksiksiz bir alet takımına ve makineye ihtiyacınız olduğunu söylerim. Elbette, yeterli dayanıklılığa sahip biri bunu sadece çekiçle yapabilir.
— Bart Kiers
1
Bu geçerli bir uyarı olabilir, ancak soruyu yanıtlamaz . Normal ifade doğru araç olmayabilir, ancak bazı kişilerin başka seçeneği yoktur. Sağlığını kontrol etmek için bir hizmetin çıktısını değerlendiren bir satıcı ürününe kilitlendik ve satıcının özel durum denetimi için sağladığı tek seçenek, bir normal ifadeyi kabul eden bir web formu. Hizmet durumunu değerlendiren satıcı ürün ekibimin kontrolü altında değil. Bizim için JSON'u regex ile değerlendirmek artık bir gerekliliktir, bu nedenle "uygun değil" cevabı uygun değildir. (Yine de size olumsuz oy vermedim.)
— John Deters
12

@ Mario'nun yanıtını denedim, ancak benim için işe yaramadı, çünkü JSON.org'dan ( arşiv ) test paketini indirdim ve 4 başarısız test vardı (fail1.json, fail18.json, fail25.json, fail27. json).

Hataları araştırdım ve fail1.jsonbunun aslında doğru olduğunu buldum (kılavuzun notuna ve RFC-7159 geçerli dizesinin de geçerli bir JSON olduğunu). Dosya da fail18.jsonböyle değildi, çünkü aslında doğru derinlemesine yerleştirilmiş JSON içeriyor:

[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]

Yani iki dosya kaldı: fail25.jsonve fail27.json:

["  tab character   in  string  "]

ve

["line
break"]

Her ikisi de geçersiz karakterler içeriyor. Bu yüzden kalıbı şu şekilde güncelledim (dize alt şablonu güncellendi):

$pcreRegex = '/
          (?(DEFINE)
             (?<number>   -? (?= [1-9]|0(?!\d) ) \d+ (\.\d+)? ([eE] [+-]? \d+)? )
             (?<boolean>   true | false | null )
             (?<string>    " ([^"\n\r\t\\\\]* | \\\\ ["\\\\bfnrt\/] | \\\\ u [0-9a-f]{4} )* " )
             (?<array>     \[  (?:  (?&json)  (?: , (?&json)  )*  )?  \s* \] )
             (?<pair>      \s* (?&string) \s* : (?&json)  )
             (?<object>    \{  (?:  (?&pair)  (?: , (?&pair)  )*  )?  \s* \} )
             (?<json>   \s* (?: (?&number) | (?&boolean) | (?&string) | (?&array) | (?&object) ) \s* )
          )
          \A (?&json) \Z
          /six';

Artık json.org'daki tüm yasal testler geçilebilir.

— Gino Bölmesi
kaynak
Bu, bir JSON nesnesi / dizisi olmayan yalnızca JSON değerleriyle (dizeler, mantıksal değerler ve sayılar) eşleşir.
— kowsikbabu
4

JSON belgelerine bakıldığında , amaç sadece uygunluğu kontrol etmekse normal ifadenin üç bölümden oluşabileceği görülmektedir:

  1. Dize veya ile başlar ve biter[]{}
    • [{\[]{1}...[}\]]{1}
  2. ve
    1. Karakter, izin verilen bir JSON kontrol karakteridir (yalnızca bir)
      • ... [,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]...
    2. veya bir""
      • ... ".*?"...

Hep birlikte: [{\[]{1}([,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]|".*?")+[}\]]{1}

JSON dizesi newlinekarakterler içeriyorsa singleline, .eşleşmesi için normal ifade çeşidinizdeki anahtarı kullanmanız gerekir newline. Lütfen bunun tüm bozuk JSON'larda başarısız olmayacağını, ancak temel JSON yapısı geçersizse başarısız olacağını unutmayın; bu, bir ayrıştırıcıya geçmeden önce temel bir mantık doğrulaması yapmanın basit bir yoludur.

— cjbarth
kaynak
1
Önerilen normal ifadenin, belirli test durumlarında kötü bir geri izleme davranışı vardır. '{"A": false, "b": true, "c": 100, "' bu eksik json üzerinde çalıştırmayı denerseniz , durur. Örnek: regex101.com/r/Zzc6sz . Basit bir düzeltme : [{[] {1} ([,: {} [] 0-9. \ - + Eaeflnr-u \ n \ r \ t] | ". *?") + [}]] {1}
— Toonijn
@Toonijn Yorumunuzu yansıtacak şekilde güncelledim. Teşekkürler!
— cjbarth
@Cjbarth'ın bu biraz değiştirilmiş sürümü, metindeki tüm JSON benzeri yapıları bulma durumum için mükemmel çalışıyor (benim durumumda küresel olarak bir HTML dosyasına uygulandı):[{\[]{1}([,:{}\[\]0-9.\-+A-zr-u \n\r\t]|".*:?")+[}\]]{1}
— C2BB
3

Mario'nun çözümünün bir Ruby uygulamasını yarattım, bu işe yarıyor:

# encoding: utf-8

module Constants
  JSON_VALIDATOR_RE = /(
         # define subtypes and build up the json syntax, BNF-grammar-style
         # The {0} is a hack to simply define them as named groups here but not match on them yet
         # I added some atomic grouping to prevent catastrophic backtracking on invalid inputs
         (?<number>  -?(?=[1-9]|0(?!\d))\d+(\.\d+)?([eE][+-]?\d+)?){0}
         (?<boolean> true | false | null ){0}
         (?<string>  " (?>[^"\\\\]* | \\\\ ["\\\\bfnrt\/] | \\\\ u [0-9a-f]{4} )* " ){0}
         (?<array>   \[ (?> \g<json> (?: , \g<json> )* )? \s* \] ){0}
         (?<pair>    \s* \g<string> \s* : \g<json> ){0}
         (?<object>  \{ (?> \g<pair> (?: , \g<pair> )* )? \s* \} ){0}
         (?<json>    \s* (?> \g<number> | \g<boolean> | \g<string> | \g<array> | \g<object> ) \s* ){0}
       )
    \A \g<json> \Z
    /uix
end

########## inline test running
if __FILE__==$PROGRAM_NAME

  # support
  class String
    def unindent
      gsub(/^#{scan(/^(?!\n)\s*/).min_by{|l|l.length}}/u, "")
    end
  end

  require 'test/unit' unless defined? Test::Unit
  class JsonValidationTest < Test::Unit::TestCase
    include Constants

    def setup

    end

    def test_json_validator_simple_string
      assert_not_nil %s[ {"somedata": 5 }].match(JSON_VALIDATOR_RE)
    end

    def test_json_validator_deep_string
      long_json = <<-JSON.unindent
      {
          "glossary": {
              "title": "example glossary",
          "GlossDiv": {
                  "id": 1918723,
                  "boolean": true,
                  "title": "S",
            "GlossList": {
                      "GlossEntry": {
                          "ID": "SGML",
                "SortAs": "SGML",
                "GlossTerm": "Standard Generalized Markup Language",
                "Acronym": "SGML",
                "Abbrev": "ISO 8879:1986",
                "GlossDef": {
                              "para": "A meta-markup language, used to create markup languages such as DocBook.",
                  "GlossSeeAlso": ["GML", "XML"]
                          },
                "GlossSee": "markup"
                      }
                  }
              }
          }
      }
      JSON

      assert_not_nil long_json.match(JSON_VALIDATOR_RE)
    end

  end
end
— Pmarreck
kaynak
\ D kullanmak tehlikelidir. Pek çok regexp uygulamasında \ d, yalnızca [0-9] değil, bunun yerine alternatif komut dosyaları içeren bir rakamın Unicode tanımıyla eşleşir. Dolayısıyla, Ruby'deki Unicode desteği hala bozuk değilse, kodunuzdaki regexp'yi düzeltmeniz gerekir.
— dolmen
Bildiğim kadarıyla Ruby, "digit" in TÜM unicode tanımlarıyla eşleşmeyen PCRE'yi kullanıyor. Yoksa olması gerektiğini mi söylüyorsun?
— pmarreck
Bunun dışında. Yanlış pozitif: "\ x00", [Doğru]. Yanlış negatif: "\ u0000", "\ n". Bekleyen: "[{" ": [{" ": [{" ":" (1000x tekrarlandı).
— nst
Test senaryoları olarak eklemek ve ardından geçmek için kodu değiştirmek çok zor değil. O 1000+ derinliğe sahip yığını darbe değil almak nasıl ... gerçi, tamamen farklı bir konudur
— pmarreck
1

"Dizeler ve sayılar" için, sayılar için kısmi normal ifadenin:

-?(?:0|[1-9]\d*)(?:\.\d+)(?:[eE][+-]\d+)?

bunun yerine şöyle olmalıdır:

-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+\-]?\d+)?

sayının ondalık kısmı isteğe bağlı olduğundan ve ayrıca parantezler arasında özel bir anlamı olduğu için -sembolden kaçmak muhtemelen daha güvenlidir[+-]

— Mikaeru
kaynak
Kullanmak \dtehlikelidir. Pek çok regexp uygulamasında \d, yalnızca [0-9]değil, bunun yerine alternatif komut dosyaları içeren bir rakamın Unicode tanımıyla eşleşir .
— dolmen
Biraz tuhaf görünüyor, -0 geçerli bir sayı, ancak RFC 4627 buna izin veriyor ve normal ifadeniz buna uyuyor.
— 2013 saat
1

JSON dizisindeki son virgül, Perl 5.16'mın askıda kalmasına neden oldu, çünkü muhtemelen geriye doğru izlemeyi sürdürüyordu. Bir geri izleme sonlandırma yönergesi eklemem gerekiyordu:

(?<json>   \s* (?: (?&number) | (?&boolean) | (?&string) | (?&array) | (?&object) )(*PRUNE) \s* )
                                                                                   ^^^^^^^^

Bu şekilde, 'isteğe bağlı' ( *veya ?) olmayan bir yapıyı tanımladığında , onu başka bir şey olarak tanımlamaya çalışmak için geriye dönmeyi denememelidir.

— user117529
kaynak
0

Yukarıda yazıldığı gibi, kullandığınız dilde bir JSON kitaplığı geliyorsa, dizeyi çözmeyi denemek için kullanın ve başarısız olursa istisnayı / hatayı yakalayın! Dil yoksa (FreeMarker'da böyle bir durum söz konusuysa) aşağıdaki normal ifade en azından bazı çok temel doğrulama sağlayabilir (PHP / PCRE'nin daha fazla kullanıcı için test edilebilir / kullanılabilir olması için yazılmıştır). Kabul edilen çözüm kadar kusursuz değil, aynı zamanda o kadar da korkutucu değil =):

~^\{\s*\".*\}$|^\[\n?\{\s*\".*\}\n?\]$~s

kısa açıklama:

// we have two possibilities in case the string is JSON
// 1. the string passed is "just" a JSON object, e.g. {"item": [], "anotheritem": "content"}
// this can be matched by the following regex which makes sure there is at least a {" at the
// beginning of the string and a } at the end of the string, whatever is inbetween is not checked!

^\{\s*\".*\}$

// OR (character "|" in the regex pattern)
// 2. the string passed is a JSON array, e.g. [{"item": "value"}, {"item": "value"}]
// which would be matched by the second part of the pattern above

^\[\n?\{\s*\".*\}\n?\]$

// the s modifier is used to make "." also match newline characters (can happen in prettyfied JSON)

Bunu istemeden bozacak bir şeyi kaçırırsam, yorumlar için minnettarım!

— exside
kaynak
0

JSONArray'i değil basit JSON'u doğrulayan normal ifade

anahtarı (dize) doğrular: değer (dize, tam sayı, [{anahtar: değer}, {anahtar: değer}], {anahtar: değer})

^\{(\s|\n\s)*(("\w*"):(\s)*("\w*"|\d*|(\{(\s|\n\s)*(("\w*"):(\s)*("\w*(,\w+)*"|\d{1,}|\[(\s|\n\s)*(\{(\s|\n\s)*(("\w*"):(\s)*(("\w*"|\d{1,}))((,(\s|\n\s)*"\w*"):(\s)*("\w*"|\d{1,}))*(\s|\n)*\})){1}(\s|\n\s)*(,(\s|\n\s)*\{(\s|\n\s)*(("\w*"):(\s)*(("\w*"|\d{1,}))((,(\s|\n\s)*"\w*"):(\s)*("\w*"|\d{1,}))*(\s|\n)*\})?)*(\s|\n\s)*\]))((,(\s|\n\s)*"\w*"):(\s)*("\w*(,\w+)*"|\d{1,}|\[(\s|\n\s)*(\{(\s|\n\s)*(("\w*"):(\s)*(("\w*"|\d{1,}))((,(\s|\n\s)*"\w*"):(\s)*("\w*"|\d{1,}))*(\s|\n)*\})){1}(\s|\n\s)*(,(\s|\n\s)*\{(\s|\n\s)*(("\w*"):(\s)*(("\w*"|\d{1,}))((,(\s|\n\s)*"\w*"):("\w*"|\d{1,}))*(\s|\n)*\})?)*(\s|\n\s)*\]))*(\s|\n\s)*\}){1}))((,(\s|\n\s)*"\w*"):(\s)*("\w*"|\d*|(\{(\s|\n\s)*(("\w*"):(\s)*("\w*(,\w+)*"|\d{1,}|\[(\s|\n\s)*(\{(\s|\n\s)*(("\w*"):(\s)*(("\w*"|\d{1,}))((,(\s|\n\s)*"\w*"):(\s)*("\w*"|\d{1,}))*(\s|\n)*\})){1}(\s|\n\s)*(,(\s|\n\s)*\{(\s|\n\s)*(("\w*"):(\s)*(("\w*"|\d{1,}))((,(\s|\n\s)*"\w*"):(\s)*("\w*"|\d{1,}))*(\s|\n)*\})?)*(\s|\n\s)*\]))((,(\s|\n\s)*"\w*"):(\s)*("\w*(,\w+)*"|\d{1,}|\[(\s|\n\s)*(\{(\s|\n\s)*(("\w*"):(\s)*(("\w*"|\d{1,}))((,(\s|\n\s)*"\w*"):(\s)*("\w*"|\d{1,}))*(\s|\n)*\})){1}(\s|\n\s)*(,(\s|\n\s)*\{(\s|\n\s)*(("\w*"):(\s)*(("\w*"|\d{1,}))((,(\s|\n\s)*"\w*"):("\w*"|\d{1,}))*(\s|\n)*\})?)*(\s|\n\s)*\]))*(\s|\n\s)*\}){1}))*(\s|\n)*\}$

bu JSON ile doğrulanan örnek veriler

{
"key":"string",
"key": 56,
"key":{
        "attr":"integer",
        "attr": 12
        },
"key":{
        "key":[
            {
                "attr": 4,
                "attr": "string"
            }
        ]
     }
}
— Ravi Nandasana
kaynak
-3

Bunun 6 yıldan fazla bir süre önce olduğunun farkındayım. Bununla birlikte, burada kimsenin bahsetmediği ve normal ifadelerden çok daha kolay bir çözüm olduğunu düşünüyorum.

function isAJSON(string) {
    try {
        JSON.parse(string)  
    } catch(e) {
        if(e instanceof SyntaxError) return false;
    };  
    return true;
}
— Jamie
kaynak
Bu cevap soruyu çözmez.
— kszosze
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.