Elm Language
Json.Decode
Recherche…
Remarques
Json.Decode expose deux fonctions pour décoder une charge utile, la première est decodeValue qui essaie de décoder une Json.Encode.Value , la seconde est decodeString qui tente de décoder une chaîne JSON. Les deux fonctions prennent 2 paramètres, un décodeur et une Json.Encode.Value ou Json.
Décoder une liste
L'exemple suivant peut être testé sur https://ellie-app.com/m9tk39VpQg/0 .
import Html exposing (..)
import Json.Decode
payload =
"""
["fu", "bar"]
"""
main =
Json.Decode.decodeString decoder payload -- Ok ["fu","bar"]
|> toString
|> text
decoder =
Json.Decode.list Json.Decode.string
Pré-décoder un champ et décoder le reste en fonction de cette valeur décodée
Les exemples suivants peuvent être testés sur https://ellie-app.com/m9vmQ8NcMc/0 .
import Html exposing (..)
import Json.Decode
payload =
"""
[ { "bark": true, "tag": "dog", "name": "Zap", "playful": true }
, { "whiskers": true, "tag" : "cat", "name": "Felix" }
, {"color": "red", "tag": "tomato"}
]
"""
-- OUR MODELS
type alias Dog =
{ bark: Bool
, name: String
, playful: Bool
}
type alias Cat =
{ whiskers: Bool
, name: String
}
-- OUR DIFFERENT ANIMALS
type Animal
= DogAnimal Dog
| CatAnimal Cat
| NoAnimal
main =
Json.Decode.decodeString decoder payload
|> toString
|> text
decoder =
Json.Decode.field "tag" Json.Decode.string
|> Json.Decode.andThen animalType
|> Json.Decode.list
animalType tag =
case tag of
"dog" ->
Json.Decode.map3 Dog
(Json.Decode.field "bark" Json.Decode.bool)
(Json.Decode.field "name" Json.Decode.string)
(Json.Decode.field "playful" Json.Decode.bool)
|> Json.Decode.map DogAnimal
"cat" ->
Json.Decode.map2 Cat
(Json.Decode.field "whiskers" Json.Decode.bool)
(Json.Decode.field "name" Json.Decode.string)
|> Json.Decode.map CatAnimal
_ ->
Json.Decode.succeed NoAnimal
Décryptage de JSON de Rust enum
Ceci est utile si vous utilisez de la rouille dans le backend et de l'orme sur le front
enum Complex{
Message(String),
Size(u64)
}
let c1 = Complex::Message("hi");
let c2 = Complex::Size(1024u64);
Le Json encodé de rouille sera:
c1:
{"variant": "Message",
"fields": ["hi"]
}
c2:
{"variant": "Size",
"fields": [1024]
}
Le décodeur en orme
import Json.Decode as Decode exposing (Decoder)
type Complex = Message String
| Size Int
-- decodes json to Complex type
complexDecoder: Decoder Value
complexDecoder =
("variant" := Decode.string `Decode.andThen` variantDecoder)
variantDecoder: String -> Decoder Value
variantDecoder variant =
case variant of
"Message" ->
Decode.map Message
("fields" := Decode.tuple1 (\a -> a) Decode.string)
"Size" ->
Decode.map Size
("fields" := Decode.tuple1 (\a -> a) Decode.int)
_ ->
Debug.crash "This can't happen"
Utilisation: les données sont demandées à http rest api et le décodage de la charge utile sera
Http.fromJson complexDecoder payload
Le décodage de la chaîne sera
Decode.decodeString complexDecoder payload
Décoder une liste d'enregistrements
Le code suivant peut être trouvé dans une démo ici: https://ellie-app.com/mbFwJT9jD3/0
import Html exposing (..)
import Json.Decode exposing (Decoder)
payload =
"""
[{
"id": 0,
"name": "Adam Carter",
"work": "Unilogic",
"email": "[email protected]",
"dob": "24/11/1978",
"address": "83 Warner Street",
"city": "Boston",
"optedin": true
},
{
"id": 1,
"name": "Leanne Brier",
"work": "Connic",
"email": "[email protected]",
"dob": "13/05/1987",
"address": "9 Coleman Avenue",
"city": "Toronto",
"optedin": false
}]
"""
type alias User =
{ name: String
, work: String
, email: String
, dob: String
, address: String
, city: String
, optedin: Bool
}
main =
Json.Decode.decodeString decoder payload
|> toString
|> text
decoder: Decoder (List User)
decoder =
Json.Decode.map7 User
(Json.Decode.field "name" Json.Decode.string)
(Json.Decode.field "work" Json.Decode.string)
(Json.Decode.field "email" Json.Decode.string)
(Json.Decode.field "dob" Json.Decode.string)
(Json.Decode.field "address" Json.Decode.string)
(Json.Decode.field "city" Json.Decode.string)
(Json.Decode.field "optedin" Json.Decode.bool)
|> Json.Decode.list
Décoder une date
Dans le cas où vous avez json avec une chaîne de date ISO comme ceci
JSON.stringify({date: new Date()})
// -> "{"date":"2016-12-12T13:24:34.470Z"}"
Vous pouvez le mapper sur elm Date type:
import Html exposing (text)
import Json.Decode as JD
import Date
payload = """{"date":"2016-12-12T13:24:34.470Z"}"""
dateDecoder : JD.Decoder Date.Date
dateDecoder =
JD.string
|> JD.andThen ( \str ->
case Date.fromString str of
Err err -> JD.fail err
Ok date -> JD.succeed date )
payloadDecoder : JD.Decoder Date.Date
payloadDecoder =
JD.field "date" dateDecoder
main =
JD.decodeString payloadDecoder payload
|> toString
|> text
Décoder une liste d'objets contenant des listes d'objets
Voir Ellie pour un exemple de travail. Cet exemple utilise le module NoRedInk / elm-decode-pipeline .
Étant donné une liste d'objets JSON, qui contiennent eux-mêmes des listes d'objets JSON:
[
{
"id": 0,
"name": "Item 1",
"transactions": [
{ "id": 0, "amount": 75.00 },
{ "id": 1, "amount": 25.00 }
]
},
{
"id": 1,
"name": "Item 2",
"transactions": [
{ "id": 0, "amount": 50.00 },
{ "id": 1, "amount": 15.00 }
]
}
]
Si la chaîne ci-dessus se trouve dans la chaîne de payload , elle peut être décodée en utilisant les éléments suivants:
module Main exposing (main)
import Html exposing (..)
import Json.Decode as Decode exposing (Decoder)
import Json.Decode.Pipeline as JP
import String
type alias Item =
{ id : Int
, name : String
, transactions : List Transaction
}
type alias Transaction =
{ id : Int
, amount : Float
}
main =
Decode.decodeString (Decode.list itemDecoder) payload
|> toString
|> String.append "JSON "
|> text
itemDecoder : Decoder Item
itemDecoder =
JP.decode Item
|> JP.required "id" Decode.int
|> JP.required "name" Decode.string
|> JP.required "transactions" (Decode.list transactionDecoder)
transactionDecoder : Decoder Transaction
transactionDecoder =
JP.decode Transaction
|> JP.required "id" Decode.int
|> JP.required "amount" Decode.float