स्कैला

Question

में जेसन समानता की तुलना करें यदि स्केल में दो जेसन संरचनाएं समान हैं तो मैं तुलना कैसे कर सकता हूं?

उदाहरण के लिए

, अगर मेरे पास है:

{ 
    resultCount: 1, 
    results: [ 
    { 
     artistId: 331764459, 
     collectionId: 780609005 
    } 
    ] 
} 

और

{ 
    results: [ 
    { 
     collectionId: 780609005, 
     artistId: 331764459 
    } 
    ], 
    resultCount: 1 
} 

वे समान विचार किया जाना चाहिए

Answer 1

आप में सक्षम होना चाहिए बस json1 == json2 ऐसा करने के लिए, अगर json पुस्तकालयों सही ढंग से लिखा है। क्या यह आपके लिए काम नहीं कर रहा है?

यह spray-json साथ है, हालांकि मैं हर json पुस्तकालय से एक ही उम्मीद करेंगे:

import spray.json._ 
import DefaultJsonProtocol._ 
Welcome to Scala version 2.10.4 (OpenJDK 64-Bit Server VM, Java 1.7.0_51). 
Type in expressions to have them evaluated. 
Type :help for more information. 

scala> val json1 = """{ "a": 1, "b": [ { "c":2, "d":3 } ] }""".parseJson 
json1: spray.json.JsValue = {"a":1,"b":[{"c":2,"d":3}]} 

scala> val json2 = """{ "b": [ { "d":3, "c":2 } ], "a": 1 }""".parseJson 
json2: spray.json.JsValue = {"b":[{"d":3,"c":2}],"a":1} 

scala> json1 == json2 
res1: Boolean = true 

स्प्रे-json अपरिवर्तनीय स्केला Map का उपयोग करता सार वाक्य रचना पेड़ एक पार्स से उत्पन्न में एक JSON ऑब्जेक्ट का प्रतिनिधित्व करने, तो यह सिर्फ Map की समानता अर्थशास्त्र है जो यह काम करता है।

Answer 2

विधि को कॉल करना compare_2Json(str1,str2) एक बूलियन मान लौटाएगा। कृपया सुनिश्चित करें कि दो स्ट्रिंग पैरामीटर जेसन हैं। उपयोग और परीक्षण में आपका स्वागत है।

 def compare_2Json(js1:String,js2:String): Boolean = { 
     var js_str1 = js1 
     var js_str2 = js2 

     js_str1=js_str1.replaceAll(" ","") 
     js_str2=js_str2.replaceAll(" ","") 
     var issame = false 
     val arrbuff1 = ArrayBuffer[String]() 
     val arrbuff2 = ArrayBuffer[String]() 
     if(js_str1.substring(0,1)=="{" && js_str2.substring(0,1)=="{" || js_str1.substring(0,1)=="["&&js_str2.substring(0,1)=="["){ 
      for(small_js1 <- split_JsonintoSmall(js_str1);small_js2 <- split_JsonintoSmall((js_str2))) { 
      issame = compare_2Json(small_js1,small_js2) 
      if(issame == true){ 
       js_str1 = js_str1.substring(0,js_str1.indexOf(small_js1))+js_str1.substring(js_str1.indexOf(small_js1)+small_js1.length) 
       js_str2 = js_str2.substring(0,js_str2.indexOf(small_js2))+js_str2.substring(js_str2.indexOf(small_js2)+small_js2.length) 
      } 
      } 
      js_str1 = js_str1.substring(1,js_str1.length-1) 
      js_str2 = js_str2.substring(1,js_str2.length-1) 

      for(str_js1 <- js_str1.split(","); str_js2 <- js_str2.split(",")){ 
      if(str_js1!="" && str_js2!="") 
       if(str_js1 == str_js2){ 
       js_str1 = js_str1.substring(0,js_str1.indexOf(str_js1))+js_str1.substring(js_str1.indexOf(str_js1)+str_js1.length) 
       js_str2 = js_str2.substring(0,js_str2.indexOf(str_js2))+js_str2.substring(js_str2.indexOf(str_js2)+str_js2.length) 
       } 
      } 
      js_str1=js_str1.replace(",","") 
      js_str2=js_str2.replace(",","") 

      if(js_str1==""&&js_str2=="")return true 
      else return false 
     } 
     else return false 
     } 

     def split_JsonintoSmall(js_str: String):ArrayBuffer[String]={ 
     val arrbuff = ArrayBuffer[String]() 

     var json_str = js_str 
     while(json_str.indexOf("{",1)>0 || json_str.indexOf("[",1)>0){ 
      if (json_str.indexOf("{", 1) < json_str.indexOf("[", 1) && json_str.indexOf("{",1)>0 || json_str.indexOf("{", 1) > json_str.indexOf("[", 1) && json_str.indexOf("[",1)<0) { 
      val right = findrealm(1, json_str, '{', '}') 
      arrbuff += json_str.substring(json_str.indexOf("{", 1), right + 1) 
      json_str = json_str.substring(0,json_str.indexOf("{",1))+json_str.substring(right+1) 
      } 
      else { 
      if(json_str.indexOf("[",1)>0) { 
       val right = findrealm(1, json_str, '[', ']') 
       arrbuff += json_str.substring(json_str.indexOf("[", 1), right + 1) 
       json_str = json_str.substring(0, json_str.indexOf("[", 1)) + json_str.substring(right + 1) 
      } 
      } 
     } 
     arrbuff 
     } 

    def findrealm(begin_loc: Int, str: String, leftch: Char, rightch: Char): Int = { 
    var left = str.indexOf(leftch, begin_loc) 
    var right = str.indexOf(rightch, left) 
    left = str.indexOf(leftch, left + 1) 
    while (left < right && left > 0) { 
     right = str.indexOf(rightch, right + 1) 
     left = str.indexOf(leftch, left + 1) 
    } 
    right 
    } 

Answer 3

spray-json निश्चित रूप से महान है, लेकिन मैं Gson का उपयोग के बाद से मैं पहले से ही अपने प्रोजेक्ट पर Gson पुस्तकालय पर निर्भरता था। मैं इन्हें अपने यूनिट परीक्षणों में उपयोग कर रहा हूं, सरल जेसन के लिए अच्छा काम करता है।

import com.google.gson.{JsonParser} 
import org.apache.flume.event.JSONEvent 
import org.scalatest.FunSuite 

class LogEnricherSpec extends FunSuite { 
    test("compares json to json") { 

    val parser = new JsonParser() 

    assert(parser.parse(""" 
     { 
      "eventType" : "TransferItems", 
      "timeMillis" : "1234567890", 
      "messageXml":{ 
      "TransferId" : 123456 
      } 
     } """.stripMargin) 
     == 
     parser.parse(""" 
     { 
      "timeMillis" : "1234567890", 
      "eventType" : "TransferItems", 
      "messageXml":{ 
      "TransferId" : 123456 
      } 
     } 
     """.stripMargin)) 
}