json - Aeson如何使用Data.Text.Lazy.IO解析JSON文件

Question

我想将给定目录中的所有 json 文件解析为数据类型 Result。

所以我有一个解码功能

decodeResult :: Data.ByteString.Lazy.ByteString -> Maybe Result

我从 Data.Text.Lazy.IO 开始将文件加载到 Lazy ByteString，

import qualified Data.Text.Lazy.IO as T
import qualified Data.Text.Lazy.Encoding as T

getFileContent :: FilePath -> IO B.ByteString
getFileContent path = T.encodeUtf8 `fmap` T.readFile path

它编译了，但我遇到了打开文件太多的问题，所以我想也许我应该使用 withFile .

import System.IO
import qualified Data.ByteString.Lazy as B
import qualified Data.Text.Lazy.IO as T
import qualified Data.Text.Lazy.Encoding as T

getFileContent :: FilePath -> IO (Maybe Result)
getFileContent path = withFile path ReadMode $ \hnd -> do
   content <- T.hGetContents hnd
   return $ (decodeAnalytic . T.encodeUtf8) content

loadAllResults :: FilePath -> IO [Result]
loadAllResults path = do
   paths <- listDirectory path
   results <- sequence $ fmap getFileContent (fmap (path ++ ) $ filter (endswith ".json") paths)
   return $ catMaybes results

在这个版本中，lazy io 似乎从未被评估过，它总是返回空列表。但是如果我在 getFileContent 函数中打印内容，那么一切似乎都正常。

getFileContent :: FilePath -> IO (Maybe Result)
getFileContent path = withFile path ReadMode $ \hnd -> do
   content <- T.hGetContents hnd
   print content
   return $ (decodeAnalytic . T.encodeUtf8) content

所以我不确定我错过了什么，我应该为这种类型的东西使用管道吗？

Answer 1

一般来说，我建议使用流媒体库来解析任意大小的数据，如 JSON 文件。但是，在使用 aeson 解析 JSON 的特定情况下，内存溢出的问题并不像 IMO 那样重要，因为 aeson 库本身最终会将内存中的整个文件表示为 Value类型。因此，考虑到这一点，您可以选择简单地使用严格的字节串 I/O。我给出了一个使用管道和严格 I/O 来解析 JSON 值的示例。 (我认为某些库中已经存在管道版本，我不确定。)

#!/usr/bin/env stack
{- stack --resolver lts-7.14 --install-ghc runghc
   --package aeson --package conduit-extra
-}
import           Control.Monad.Catch     (MonadThrow, throwM)
import           Control.Monad.IO.Class  (MonadIO, liftIO)
import           Data.Aeson              (FromJSON, Result (..), eitherDecodeStrict',
                                          fromJSON, json, Value)
import           Data.ByteString         (ByteString)
import qualified Data.ByteString         as B
import           Data.Conduit            (ConduitM, runConduitRes, (.|))
import           Data.Conduit.Attoparsec (sinkParser)
import           Data.Conduit.Binary     (sourceFile)

sinkFromJSON :: (MonadThrow m, FromJSON a) => ConduitM ByteString o m a
sinkFromJSON = do
    value <- sinkParser json
    case fromJSON value of
        Error e -> throwM $ userError e
        Success x -> return x

readJSONFile :: (MonadIO m, FromJSON a) => FilePath -> m a
readJSONFile fp = liftIO $ runConduitRes $ sourceFile fp .| sinkFromJSON

-- Or using strict I/O
readJSONFileStrict :: (MonadIO m, FromJSON a) => FilePath -> m a
readJSONFileStrict fp = liftIO $ do
    bs <- B.readFile fp
    case eitherDecodeStrict' bs of
        Left e -> throwM $ userError e
        Right x -> return x

main :: IO ()
main = do
    x <- readJSONFile "test.json"
    y <- readJSONFileStrict "test.json"
    print (x :: Value)
    print (y :: Value)

编辑 忘了提:我强烈建议不要使用文本 I/O 来读取 JSON 文件。 JSON 文件应使用 UTF-8 编码，而文本 I/O 函数将使用系统设置为字符编码指定的任何内容。依托 Data.ByteString.readFile和类似的更可靠。我详细介绍了 in a recent blog post .