Question

也许这是一个愚蠢的问题，但是我最近发现自己经常使用这种抽象：

class FeedViewItem {


    var type: Int = TYPE_CONVERSATION

    var feedViewChat: FeedViewChat? = null

    ...
}

class FeedViewChat {

     var messages: Flowable<List<Message>>? = null


}


    fun getFeedViewItems(): Flowable<MutableList<FeedViewItem>> {
        return dataManager.feedRepository.getFeedItemsFlowable()
                .map { FeedViewItem.convertToViewItems(it, dataManager) }
                .map { currentFeedViewItems -> currentFeedViewItems.groupBy { it.section } }
                .map {
                    it.toSortedMap(Comparator { o1, o2 ->
                        val sectionOneValue = when (o1) {
                            FeedItem.SECTION_NEW -> 1
                            FeedItem.SECTION_LATER -> 2
                            else -> 3
                        }
                        val sectionTwoValue = when (o2) {
                            FeedItem.SECTION_NEW -> 1
                            FeedItem.SECTION_LATER -> 2
                            else -> 3
                        }
                        sectionOneValue - sectionTwoValue
                    })
                }
                .map { currentFeedItemHashMap ->

                    val newFeedSections = mutableMapOf<String, List<FeedViewItem>>()

                    currentFeedItemHashMap.forEach { (key, value) ->

                        val headerText = when (key) {
                            FeedItem.SECTION_LATER -> {
                                "Later"
                            }
                            FeedItem.SECTION_HISTORY -> {
                                "History"
                            }
                            else -> {
                                null
                            }
                        }

                        if (headerText != null) {

                            val feedViewHeader = FeedViewHeader()
                            feedViewHeader.headerText = headerText

                            val feedViewItem = FeedViewItem()
                            feedViewItem.type = FeedViewItem.TYPE_HEADER
                            feedViewItem.feedViewHeader = feedViewHeader
                            feedViewItem.updatedAt = System.currentTimeMillis()
                            feedViewItem.id = headerText.hashCode().toLong()

                            val currentFeedViewItems = value.toMutableList()
                            currentFeedViewItems.add(0, feedViewItem)

                            newFeedSections[key] = currentFeedViewItems

                        } else {

                            newFeedSections[key] = value

                        }

                    }

                    newFeedSections
                }.map {
                    it.values.flatten().toMutableList()
                }.doOnEach {

                    val users: Flowable<List<User>> = dataManager.userRepository.getUsersFlowable()

                    val feedViewContactBar = FeedViewContactBar()
                    feedViewContactBar.users = users

                    val feedViewItem = FeedViewItem()
                    feedViewItem.type = FeedViewItem.TYPE_CONTACT_BAR
                    feedViewItem.feedViewContactBar = feedViewContactBar
                    feedViewItem.updatedAt = System.currentTimeMillis()
                    feedViewItem.id = FeedViewItem.VIEW_ID_CONTACT_BAR

                    it.value?.add(0, feedViewItem)
                }
    }

问题：这是其他任何人的共同任务吗？如果是这样，它有名字吗？如果没有，也许只是部分实现，那么它使您想起什么吗？否则，我可以删除问题。

目前，我正在将此功能用于这组说明。下面的代码将获取路径的所有目录，并收集其中包含package.json的所有目录：

async function giveMeAName(cbAsync, initValue) {
  return await Promise.all(
    initValue.map(cbAsync),
  );
}

Answer 1

几天前您问related question，我曾尝试帮助您，但您从未回答：（

我已经回答了类似的问题（here和here），这些问题已概括了这种模式-

const Parallel = p =>
  ( { map: async f =>
        Promise .all ((await p) .map (x => f (x)))
    , filter: async f =>
        Promise .all ((await p) .filter (x => f (x)))
    , flatMap: async f =>
        Promise .all ((await p) .map (x => f (x))) .then (ys => [] .concat (...ys))
    , // ...
    }
  )

您可以看到files以这种方式使用了该文件，该文件递归列出了目录及其子目录中所有文件的所有路径-

const { readdir, stat } =
  require ("fs") .promises

const { join } =
  require ("path")

const files = async (path = ".") =>
  (await stat (path)) .isDirectory ()
    ? Parallel (readdir (path))
        .flatMap (f => files (join (path, f)))
    : [ path ]

还有一个特殊化search，它返回与查询匹配的所有路径-

const { basename } =
  require ("path")

const search = async (query, path = ".") =>
  Parallel (files (path))
    .filter (f => basename (f) === query)

和readPackages递归地读取指定路径上的所有package.json文件-

const { readFile } =
  require ("fs") .promises

const readPackages = async (path = ".") =>
  Parallel (search ("package.json", path))
    .map (readFile)
    .then
      ( buffers =>
          buffers .map (b => JSON .parse (String (b)))
      )

最后，一个稍微复杂一点的示例dirs，其工作方式类似于files，但仅递归列出目录。递归级别可以通过depth参数-

来控制

const dirs = async (path = ".", depth = Infinity) =>
  (await stat (path)) .isDirectory ()
    ? depth === -1
        ? []
        : Parallel (readdir (path))
            .flatMap (f => dirs (join (path, f), depth - 1))
            .then (results => [ path, ...results ])
    : []

要查看没有Parallel模块的这些程序的外观，请参见上面链接的“问答”。

Answer 2

根据应用程序中的需求，我使用不同的名称。有时我会针对特定用例使用类似的功能，并相应地命名。但是，我经常使用的最通用的名称就是resolveAll()。

但是我不认为有任何（半）官方命名。因此，以对您最有意义的方式命名。

Answer 3

也许是mapAll或awaitAll？

Bluebird具有类似的功能，简称为map()，它的功能非常相似（它返回映射的承诺而不是解决它）。

映射并返回已解决的promise数组的函数的名称？

3 个答案: