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

在这个版本中，懒惰的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。

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

1 个答案: