Come posso costruire e analizzare una stringa JSON in Scala / Ascensore

Question

Sto tentando di usare JSON per inviare i dati tra il browser e il mio app.

Sto tentando di usare Ascensore 1.0 per creare e analizzare le stringhe JSON, ma per qualche motivo non sono in grado di analizzare il JSON ho appena costruita:

scala>import scala.util.parsing.json.JSON._
import scala.util.parsing.json.JSON._

scala> import net.liftweb.http.js._
import net.liftweb.http.js._

scala> import net.liftweb.http.js.JE._
import net.liftweb.http.js.JE._

scala> val json = JsObj(("foo", 4), ("bar", "baz")).toJsCmd
json: String = {'foo': 4, 'bar': 'baz'}

scala>  parseFull(json)  
res3: Option[Any] = None

Come faccio a livello di codice costruisco un messaggio valido JSON a Scala / Ascensore che può anche essere analizzato di nuovo?

Answer 1

Si utilizza JsCmd Ascensore 1.0 di, che produce JSON con le stringhe racchiuse tra virgolette singole e il tentativo di analizzarlo con il parser di Scala, che supporta solo stringhe tra doppi apici.

E 'importante rendersi conto che ci sono più definizioni per JSON.

sono stringhe racchiuse tra virgolette singole valido JSON?

• Si sono secondo ECMAScript 5th Ed
• Non sono secondo

Sollevare e Scala forniscono molti modi per analizzare JSON, a volte con diverse comportamento tra le versioni.

Le stringhe accettati da questi parser non sono equivalenti.

Ecco alcuni commenti ed esempi dei vari metodi per prodotto e di analizzare le stringhe JSON.

---

Produrre JSON con la LIFT-JSON libreria DSL

• consigliato
• Nonostante il suo nome, si tratta di un progetto separato senza dipendenze sul resto del sollevamento

Esempio:

scala> import net.liftweb.json.JsonAST
import net.liftweb.json.JsonAST

scala> import net.liftweb.json.JsonDSL._
import net.liftweb.json.JsonDSL._

scala> import net.liftweb.json.Printer._
import net.liftweb.json.Printer._

scala> val json1 = ("foo" -> 4) ~ ("bar" -> "baz")
json1: net.liftweb.json.JsonAST.JObject = JObject(List(JField(foo,JInt(4)), JField(bar,JString(baz))))

scala> compact(JsonAST.render(json1))
res0: String = {"foo":4,"bar":"baz"}

scala> val json2 = List(1,2,3)
json2: List[Int] = List(1, 2, 3)

scala> compact(JsonAST.render(json2))
res1: String = [1,2,3]

scala> val json3 = ("foo", 4) ~ ("bar", List(1,2,3))
json3: net.liftweb.json.JsonAST.JObject = JObject(List(JField(foo,JInt(4)), JField(bar,JArray(List(JInt(1), JInt(2), JInt(3))))))

scala> compact(JsonAST.render(json3))
res2: String = {"foo":4,"bar":[1,2,3]}

---

durante l'analisi di JSON con la rel="nofollow LIFT-JSON libreria

• consigliato
• Fornisce mappatura implicita a / da Scala casi di classi
• Case-classi definite nella console non sono attualmente supportate (getterà un com.thoughtworks.paranamer.ParameterNamesNotFoundException: Unable to get class bytes)
• L'esempio che segue utilizza PublicID, una preesistente scala caso di classe in modo che funzioni sulla console Scala.

Esempio:

scala> import scala.xml.dtd.PublicID
import scala.xml.dtd.PublicID

scala> import net.liftweb.json._
import net.liftweb.json._

scala> import net.liftweb.json.JsonAST._
import net.liftweb.json.JsonAST._

scala> import net.liftweb.json.JsonDSL._
import net.liftweb.json.JsonDSL._

scala> implicit val formats = DefaultFormats 
formats: net.liftweb.json.DefaultFormats.type = net.liftweb.json.DefaultFormats$@7fa27edd

scala> val jsonAst = ("publicId1" -> "idString") ~ ("systemId" -> "systemIdStr")
jsonAst: net.liftweb.json.JsonAST.JObject = JObject(List(JField(publicId,JString(idString)), JField(systemId,JString(systemIdStr))))

scala> jsonAst.extract[PublicID]
res0: scala.xml.dtd.PublicID = PUBLIC "idString" "systemIdStr"

---

Analisi JSON in scala 2.7.7 e 2.8.1

• Not Recommended - " Non più davvero supportato "
• Scala 2.7.7 del parser non analizzare singoli apici JSON
• Questo metodo di analisi utilizzato per la questione

Esempio:

scala>import scala.util.parsing.json.JSON._
import scala.util.parsing.json.JSON._

scala>  parseFull("{\"foo\" : 4 }")        
res1: Option[Any] = Some(Map(foo -> 4.0))

scala> parseFull("[ 1,2,3 ]")
res2: Option[Any] = Some(List(1.0, 2.0, 3.0))

scala>  parseFull("{'foo' : 4 }")  
res3: Option[Any] = None

---

Analisi JSON Alzata 2.0 e 2.2 con util.JSONParser

• raccomandazione Neutral
• util.JSONParser di sollevamento sarà analizzare le stringhe JSON singolo o doppi apici:

Esempio:

scala> import net.liftweb.util.JSONParser._
import net.liftweb.util.JSONParser._

scala> parse("{\"foo\" : 4 }")    
res1: net.liftweb.common.Box[Any] = Full(Map(foo -> 4.0))

scala> parse("[ 1,2,3 ]")
res2: net.liftweb.common.Box[Any] = Full(List(1.0, 2.0, 3.0))

scala> parse("{'foo' : 4}")           
res3: net.liftweb.common.Box[Any] = Full(Map(foo -> 4.0))

---

Analisi JSON Alzata 2.0 e 2.2 con json.JsonParser

• raccomandazione Neutral
• json.JsonParser di sollevamento non sarà analizzare le stringhe racchiuse tra virgolette singole JSON:

Esempio:

scala> import net.liftweb.json._
import net.liftweb.json._

scala> import net.liftweb.json.JsonParser._
import net.liftweb.json.JsonParser._

scala> parse("{\"foo\" : 4 }")
res1: net.liftweb.json.JsonAST.JValue = JObject(List(JField(foo,JInt(4))))

scala> parse("[ 1,2,3 ]")
res2: net.liftweb.json.JsonAST.JValue = JArray(List(JInt(1), JInt(2), JInt(3)))

scala> parse("{'foo' : 4}")    
net.liftweb.json.JsonParser$ParseException: unknown token '
Near: {'foo' : 4}
    at net.liftweb.json.JsonParser$Parser.fail(JsonParser.scala:216)
    at net.liftweb.json.JsonParser$Parser.nextToken(JsonParser.scala:308)
    at net.liftweb.json.JsonParser$$anonfun$1.apply(JsonParser.scala:172)
    at net.liftweb.json.JsonParser$$anonfun$1.apply(JsonParser.scala:129)
    at net.liftweb.json.JsonParse...

---

Produrre JSON con Ascensore 1.0 JsCmd

• Not Recommended - uscita non valida per tutti i parser JSON
• Si notino le singole-citazioni intorno stringhe:

Esempio:

scala> import net.liftweb.http.js._
import net.liftweb.http.js._

scala> import net.liftweb.http.js.JE._
import net.liftweb.http.js.JE._

scala> JsObj(("foo", 4), ("bar", "baz")).toJsCmd
res0: String = {'foo': 4, 'bar': 'baz'}

scala> JsArray(1,2,3).toJsCmd
res1: String = 
[1, 2, 3]

scala>  JsObj(("foo", 4), ("bar", JsArray(1,2,3))).toJsCmd
res2: String = 
{'foo': 4, 'bar': [1, 2, 3]
}

---

Produrre JSON con Ascensore 2.0 JsCmd

• raccomandazione Neutral
• Si notino le doppie citazioni intorno stringhe:

Esempio:

scala> import net.liftweb.http.js._
import net.liftweb.http.js._

scala> import net.liftweb.http.js.JE._
import net.liftweb.http.js.JE._

scala> JsObj(("foo", 4), ("bar", "baz")).toJsCmd
res0: String = {"foo": 4, "bar": "baz"}

scala> JsArray(1,2,3).toJsCmd
res1: String = 
[1, 2, 3]

scala> JsObj(("foo", 4), ("bar", JsArray(1,2,3))).toJsCmd
res3: String = 
{"foo": 4, "bar": [1, 2, 3]
}

---

Produrre JSON a Scala (testati con 2,10)

• " Non più in realtà supportato ", ma funziona ed è lì.

Esempio:

scala> import scala.util.parsing.json._
import scala.util.parsing.json._

scala> JSONObject (Map ("foo" -> 4, "bar" -> JSONArray (1 :: 2 :: 3 :: Nil))) .toString()
res0: String = {"foo" : 4, "bar" : [1, 2, 3]}

Answer 2

Date un'occhiata a Circe . E 'davvero bello da usare e sfrutta alcuni dei nuovi strumenti da informe e Gatti . Inoltre, è possibile utilizzarlo da Scala compilato Javascript .

Tratto da Circe readme :

  

scala> importazione io.circe. , io.circe.generic.auto. , io.circe.parser. ,   io.circe.syntax. di importazione io.circe._ importazione io.circe.generic.auto._   Importa Importa io.circe.parser._ io.circe.syntax ._

     

scala> tratto sigillato Foo tratto definito Foo

     

scala> caso classe Bar (xs: List [String]) estende Foo classe definita Bar

     

scala> classe caso Qux (i: int, d: Opzione [Doppia]) si estende Foo definito   Classe Qux

     

scala> val foo: Foo = Qux (13, alcuni (14.0)) foo: Foo =   Qux (13, alcuni (14.0))

     

scala> foo.asJson.noSpaces res0: String = { "Qux": { "d": 14,0, "i": 13}}

     

scala> decodeFoo res1:   cats.data.Xor [io.circe.Error, Foo] = Destra (Qux (13, alcuni (14.0)))