使Json.Decode在elm中不区分大小写

Question

是否有一种简单的方法可以使榆树（0.18）中的Json.Decode不区分大小写？

decodeDepartmentDate : Json.Decode.Decoder DepartmentDate
decodeDepartmentDate =
    Json.Decode.map6 DepartmentDate
        (field "nameOfDay" Json.Decode.string) 
        (field "orderDate" Convert.datePart)        
        (field "mealTimeID" Json.Decode.string)        
        (field "mealTime" Json.Decode.string)        
        (field "departmentID" Json.Decode.string)        
        (field "department" Json.Decode.string)        

我希望能够针对多个后端使用相同的elm SPA，并且默认情况下避免这样的问题：

BadPayload "Expecting an object with a field named `nameOfDay` at _[11] 
but instead got: {\"NameOfDay\":\"Wednesday\",\"OrderDate\":\"2018-09-05T00:00:00\",
\"MealTimeID\":\"546ccee0-e070-403e-a15b-63f4e1366054\",\"MealTime\":\"All Day\",
\"StartTime\":\"2018/06/05 05:04:38\",\"DepartmentID\":\"066a1c9f-97da-487e-b82f-f933b159c042\",
\"Department\":\"Side walk\"}"

谢谢

Answer 1

据我所知，没有现成的解决方案。但你可以自己做！

最简单的方法可能是生成不同的外壳并使用field制作您自己的oneOf解码器：

myField name decoder =
    Decode.oneOf
        [ Decode.field name decoder
        , Decode.field (String.toLower) decoder
        ]

另一种方法是将对象解码为键/值对而不解码值，转换键然后重新编码它以便能够使用现有的JSON解码器：

lowerCaseKeys =
    Decode.keyValuePairs Decode.value
    |> Decode.map (List.map (\(key, value) -> (String.toLower key, value)))
    |> Decode.map (Encode.object)

但由于这个值现在被包裹在Decoder中，你必须使用decodeValue并最终得到一个双包裹的Result，这不是很好。我可能会错过一些优雅的方式来完成这项工作。

相反，似乎更好的是不重新编码它，但只是让你自己的field解码器工作在字典。这也允许您忽略指定键的套管。

lowerCaseKeys : Decode.Decoder (Dict.Dict String Decode.Value)
lowerCaseKeys =
    Decode.keyValuePairs Decode.value
        |> Decode.map (List.map (\( key, value ) -> ( String.toLower key, value )))
        |> Decode.map Dict.fromList

myField : String -> Decode.Decoder a -> Dict.Dict String Decode.Value -> Decode.Decoder a
myField name decode dict =
    case Dict.get (String.toLower name) dict of
        Just value ->
            case Decode.decodeValue decode value of
                Ok v ->
                    Decode.succeed v

                Err e ->
                    e |> Decode.errorToString |> Decode.fail

        Nothing ->
            Decode.fail "missing key"


result =
    Decode.decodeString (lowerCaseKeys |> Decode.andThen (myField "fOO" Decode.int)) """{ "Foo": 42 }"""

Answer 2

您可以定义一个忽略大小写的field变体。

fieldInsensitive : String -> Decode.Decoder a -> Decode.Decoder a
fieldInsensitive f d =
    let
       flow = String.toLower f
    in
    Decode.keyValuePairs Decode.value |> Decode.andThen 
      (\ l -> l |> List.filter (\(k, v) -> String.toLower k == flow)
                |> List.map (\(k, v) -> v)
                |> List.head
                |> Maybe.map Decode.succeed
                |> Maybe.withDefault (Decode.fail "field not found")
      ) |> Decode.andThen
      (\ v -> case Decode.decodeValue d v of
                  Ok w -> Decode.succeed w
                  Err e -> Decode.fail (Decode.errorToString e)
      )

这与@ glennsl的答案大致相同，但包含在一个自包含的函数中。优点是界面更简单，缺点是如果在同一对象中查找多个字段，您将重复工作。

请注意，如果有多个具有相同键的字段，则此代码会做出相当随意的决定！对于更可靠的代码，如果密钥存在多次，则最好失败。