Haskell中使用Data.Aeson处理JSON遇到问题求助

嘿，作为Haskell新手搞JSON处理确实容易头大，我懂那种搜了一堆方法却不管用的挫败感！先别慌，咱们一步步来拆解你的问题——从你的描述来看，你的JSON结构是外层键用下划线拼接两个字符串，对应的值里正好包含这两个字符串作为键、浮点数作为值，对吧？比如完整的结构大概是这样：

{
"stringA1_stringA2": {"stringA1": 1.5, "stringA2": 3.2},
"stringB1_stringB2": {"stringB1": 2.7, "stringB2": 4.9}
}

Haskell的静态类型特性确实会让动态结构的JSON处理有点绕，但用标准的aeson库完全能搞定，下面给你具体的解决方案：

第一步：准备依赖 #

首先确保你的项目cabal文件里添加了aeson依赖（这是Haskell处理JSON的事实标准库）：

build-depends: base >=4.14 && <5, aeson >=2.0, unordered-containers, text

第二步：基础解析——获取原始结构 #

如果你只是想先把JSON读进来，看看里面的内容，可以先解析成HashMap Text Object类型（外层是键值对，内层是JSON对象）：

{-# LANGUAGE OverloadedStrings #-}

import Data.Aeson
import Data.HashMap.Strict (HashMap)
import qualified Data.Text as T
import qualified Data.Aeson.Types as AT

-- 解析JSON文件，返回外层键值对的HashMap
parseRawJson :: FilePath -> IO (Maybe (HashMap Text AT.Object))
parseRawJson path = decodeFileStrict path

main :: IO ()
main = do
  maybeMap <- parseRawJson "path/to/json"
  case maybeMap of
    Just objMap -> print objMap
    Nothing -> putStrLn "JSON解析失败，请检查文件格式！"

这里的OverloadedStrings扩展是为了让字符串字面量自动转换成Text类型，避免频繁手动转换。

第三步：转换成结构化数据 #

如果你的目标是把每个条目转换成更易处理的自定义类型（比如把拼接键拆分，和对应的值结合），可以这样做：

首先定义你想要的最终数据类型：

data JsonEntry = JsonEntry
  { firstKeyPart :: T.Text
  , secondKeyPart :: T.Text
  , firstValue :: Double  -- 用Double比Float更稳妥，aeson默认解析Double
  , secondValue :: Double
  } deriving (Show)

然后写两个辅助函数：一个用来拆分外层的拼接键，另一个用来从内层对象里取出对应的值：

-- 拆分下划线连接的键，返回两个部分（格式不对则返回Nothing）
splitCompositeKey :: T.Text -> Maybe (T.Text, T.Text)
splitCompositeKey key = case T.splitOn "_" key of
  [part1, part2] -> Just (part1, part2)
  _ -> Nothing

-- 从内层Object中取出对应键的浮点数
extractValues :: T.Text -> T.Text -> AT.Object -> Maybe (Double, Double)
extractValues k1 k2 obj = do
  v1 <- obj AT..: k1  -- 用.:操作符从Object中取值，自动处理JSON到Double的转换
  v2 <- obj AT..: k2
  return (v1, v2)

最后把这两个函数结合，处理整个HashMap：

-- 把原始HashMap转换成结构化的JsonEntry列表
processEntries :: HashMap Text AT.Object -> [JsonEntry]
processEntries = foldMap processSingleEntry . HashMap.toList
  where
    processSingleEntry (compositeKey, innerObj) = case splitCompositeKey compositeKey of
      Just (k1, k2) -> case extractValues k1 k2 innerObj of
        Just (v1, v2) -> [JsonEntry k1 k2 v1 v2]
        Nothing -> []  -- 内层对象缺少对应键的情况
      Nothing -> []    -- 外层键格式不符合的情况

更新main函数来测试：

main :: IO ()
main = do
  maybeMap <- parseRawJson "path/to/json"
  case maybeMap of
    Just objMap -> print $ processEntries objMap
    Nothing -> putStrLn "JSON解析失败，请检查文件格式！"

额外提示：固定内层键的情况 #

如果你的内层键是固定的（比如所有内层对象都叫stringA1和stringA2），那可以用Generic自动生成解析器，更省心：

{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveAnyClass #-}

import GHC.Generics

data InnerData = InnerData
  { stringA1 :: Double
  , stringA2 :: Double
  } deriving (Show, Generic, FromJSON)  -- 自动生成FromJSON实例

-- 直接解析成HashMap Text InnerData
parseStructuredJson :: FilePath -> IO (Maybe (HashMap Text InnerData))
parseStructuredJson path = decodeFileStrict path

这样就不用手动处理内层对象的解析了，aeson会自动帮你完成。

希望这些步骤能帮你搞定问题！Haskell的JSON处理确实需要适应它的静态类型思维，但熟悉之后会发现它的类型安全能帮你避免很多潜在bug～

内容的提问来源于stack exchange，提问作者Orbit