स्कैला में JSON पर एक मानचित्र को क्रमबद्ध कैसे करें?

Question

तो मैं इस तरह स्काला में एक नक्शा है:

val m = Map[String, String](
    "a" -> "theA", 
    "b" -> "theB", 
    "c" -> "theC", 
    "d" -> "theD", 
    "e" -> "theE" 
) 

और मैं लिफ्ट json का उपयोग कर JSON स्ट्रिंग में इस संरचना को क्रमानुसार करना चाहते हैं।

क्या आप में से कोई भी यह कैसे जानता है?

Answer 1

इस बारे में कैसे?

implicit val formats = net.liftweb.json.DefaultFormats 
import net.liftweb.json.JsonAST._ 
import net.liftweb.json.Extraction._ 
import net.liftweb.json.Printer._ 
val m = Map[String, String](
    "a" -> "theA", 
    "b" -> "theB", 
    "c" -> "theC", 
    "d" -> "theD", 
    "e" -> "theE" 
) 
println(compact(render(decompose(m)))) 

उत्पादन:

{"e":"theE","a":"theA","b":"theB","c":"theC","d":"theD"} 

संपादित करें: यदि आप नवीनतम स्काला 2.10 उपयोग कर रहे हैं .toMap

Answer 2

:

एक scala.collections.mutable.Map के लिए, आप यह पहली अपरिवर्तनीय मानचित्र में बदलने चाहिए। एक्स और ऊपर:

println(scala.util.parsing.json.JSONObject(m)) 

Answer 3

इयनार के समाधान के समान, आप ऐसा करने के लिए JSONObject Parser Combinators से उपयोग कर सकते हैं। ध्यान दें कि यह रिकर्स नहीं करता है, आपको इसे स्वयं करने की आवश्यकता होगी। पुस्तकालय में डेटा संरचनाओं की सूची के लिए JSONArray भी शामिल है। निम्नलिखित की तरह कुछ नेस्टेड संरचनाओं के बारे में नोएल की चिंताओं को संबोधित करेंगे। यह उदाहरण मनमाने ढंग से स्तर की पुनरावृत्ति नहीं करता है, लेकिन सूची [मानचित्र [स्ट्रिंग, कोई भी]] के मान को संभालेगा।

import scala.util.parsing.json.{JSONArray, JSONObject} 

def toJson(m : Map[String, Any]): String = JSONObject(
    m.mapValues { 
    case mp: Map[String, Any] => JSONObject(mp) 
    case lm: List[Map[String, Any]] => JSONArray(lm.map(JSONObject(_))) 
    case x => x 
    } 
).toString 

Answer 4

आप अपना खुद का सुंदर आसानी से (याय, कोई निर्भरता नहीं) रोल कर सकते हैं। यह एक प्रकार की बुनियादी हैंडलिंग करता है और JSONObject विपरीत प्रत्यावर्तन कि उल्लेख किया गया था क्या करेंगे:

import scala.collection.mutable.ListBuffer 

object JsonConverter { 
    def toJson(o: Any) : String = { 
    var json = new ListBuffer[String]() 
    o match { 
     case m: Map[_,_] => { 
     for ((k,v) <- m) { 
      var key = escape(k.asInstanceOf[String]) 
      v match { 
      case a: Map[_,_] => json += "\"" + key + "\":" + toJson(a) 
      case a: List[_] => json += "\"" + key + "\":" + toJson(a) 
      case a: Int => json += "\"" + key + "\":" + a 
      case a: Boolean => json += "\"" + key + "\":" + a 
      case a: String => json += "\"" + key + "\":\"" + escape(a) + "\"" 
      case _ => ; 
      } 
     } 
     } 
     case m: List[_] => { 
     var list = new ListBuffer[String]() 
     for (el <- m) { 
      el match { 
      case a: Map[_,_] => list += toJson(a) 
      case a: List[_] => list += toJson(a) 
      case a: Int => list += a.toString() 
      case a: Boolean => list += a.toString() 
      case a: String => list += "\"" + escape(a) + "\"" 
      case _ => ; 
      } 
     } 
     return "[" + list.mkString(",") + "]" 
     } 
     case _ => ; 
    } 
    return "{" + json.mkString(",") + "}" 
    } 

    private def escape(s: String) : String = { 
    return s.replaceAll("\"" , "\\\\\""); 
    } 
} 

आप

println(JsonConverter.toJson(
    Map("a"-> 1, 
     "b" -> Map(
      "nes\"ted" -> "yeah{\"some\":true"), 
      "c" -> List(
       1, 
       2, 
       "3", 
       List(
        true, 
        false, 
        true, 
        Map(
         "1"->"two", 
         "3"->"four" 
        ) 
       ) 
      ) 
     ) 
    ) 
) 

{"a":1,"b":{"nes\"ted":"yeah{\"some\":true"},"c":[1,2,"3",[true,false,true,{"1":"two","3":"four"}]]} 

(यह एक Coinbase GDAX पुस्तकालय मैं लिखा है के भाग की तरह कार्रवाई में इसे देख सकते हैं , util.scala देखें)

Answer 5

यदि आप खेलने के ढांचे का उपयोग कर रहे इस आसान तरीका का उपयोग कर सकते हैं:

import play.api.libs.json._ 

Json.toJson(<your_map>) 

Answer 6

यह कोड कई अलग-अलग वस्तुओं को परिवर्तित करेगा, और scala.util.parsing.json._ के अंतर्निहित किसी भी पुस्तकालय की आवश्यकता नहीं है। यह किनारों के रूप में पूर्णांक वाले मानचित्र जैसे किनारे के मामलों को सही तरीके से संभाल नहीं पाएगा।

import scala.util.parsing.json.{JSONArray, JSONObject} 
def toJson(arr: List[Any]): JSONArray = { 
    JSONArray(arr.map { 
    case (innerMap: Map[String, Any]) => toJson(innerMap) 
    case (innerArray: List[Any])  => toJson(innerArray) 
    case (other)      => other 
    }) 
} 
def toJson(map: Map[String, Any]): JSONObject = { 
    JSONObject(map.map { 
    case (key, innerMap: Map[String, Any]) => 
     (key, toJson(innerMap)) 
    case (key, innerArray: List[Any]) => 
     (key, toJson(innerArray)) 
    case (key, other) => 
     (key, other) 
    }) 
} 

Answer 7

@ राजा द्वारा उत्तर का पूरक।

उन नेस्टेड वस्तु के लिए, मैं स्थानीय रूप से संशोधित वर्ग मेरी चाहता था इस तरह की तरह toString() के लिए:

case class MList[T]() extends MutableList[T] { override def toString() = "[" + this.toList.mkString(",") + "]" }

तब मानचित्र ऑब्जेक्ट के अंदर, मैं मानक List के बजाय इस MList का उपयोग करें। इस तरह, map ऑब्जेक्ट JSONObject(map).toString() पर कॉल करके ठीक प्रिंट करता है।