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

在elm（0.18）中，有没有一种简单的方法使Json.Decode不区分大小写

我希望能够对多个后端使用同一个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\"}"

---

谢谢

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

最简单的方法可能只是生成不同的外壳，并使用

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)

但是由于值现在被包装在

解码器中

，因此您必须在上面使用

解码值

，最终得到双重包装的

结果

，这不是很好。不过，我可能错过了一些优雅的制作方法

取而代之的是，最好不要对它进行重新编码，而只是制作自己的

字段

解码器来处理dict。这也将允许您忽略指定键的大小写

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 }"""

---

您可以定义忽略大小写的

字段

变量

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的答案大致相同，但包含在一个自包含的函数中。优点是界面更简单，缺点是如果在同一对象中查找多个字段，将重复工作

---

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

谢谢，我们正在寻找类似的代码。将使用并查看多个查找对性能的影响

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)
      )