您可以在3.4.4版本中使用新的$objectToArray聚合操作符来将所有顶部键-值对转换为文档数组，然后使用$unwind和$group以及$addToSet来获得整个集合中的不同键。(使用$$ROOT来引用顶级文档。)

db.things.aggregate([
  {"$project":{"arrayofkeyvalue":{"$objectToArray":"$$ROOT"}}},
  {"$unwind":"$arrayofkeyvalue"},
  {"$group":{"_id":null,"allkeys":{"$addToSet":"$arrayofkeyvalue.k"}}}
])

您可以使用以下查询来获取单个文档中的键。

db.things.aggregate([
  {"$match":{_id: "<<ID>>"}}, /* Replace with the document's ID */
  {"$project":{"arrayofkeyvalue":{"$objectToArray":"$$ROOT"}}},
  {"$project":{"keys":"$arrayofkeyvalue.k"}}
])

根据mongoldb文档，一个不同的组合

在单个集合或视图中查找指定字段的不同值，并以数组形式返回结果。

索引集合操作将返回给定键或索引的所有可能值:

返回一个数组，其中包含标识和描述集合上现有索引的文档列表

所以在一个给定的方法中，你可以使用下面的方法，为了查询一个集合中所有注册的索引，并返回一个对象，比如一个键的索引(这个例子使用async/await用于NodeJS，但显然你可以使用任何其他异步方法):

async function GetFor(collection, index) {

    let currentIndexes;
    let indexNames = [];
    let final = {};
    let vals = [];

    try {
        currentIndexes = await collection.indexes();
        await ParseIndexes();
        //Check if a specific index was queried, otherwise, iterate for all existing indexes
        if (index && typeof index === "string") return await ParseFor(index, indexNames);
        await ParseDoc(indexNames);
        await Promise.all(vals);
        return final;
    } catch (e) {
        throw e;
    }

    function ParseIndexes() {
        return new Promise(function (result) {
            let err;
            for (let ind in currentIndexes) {
                let index = currentIndexes[ind];
                if (!index) {
                    err = "No Key For Index "+index; break;
                }
                let Name = Object.keys(index.key);
                if (Name.length === 0) {
                    err = "No Name For Index"; break;
                }
                indexNames.push(Name[0]);
            }
            return result(err ? Promise.reject(err) : Promise.resolve());
        })
    }

    async function ParseFor(index, inDoc) {
        if (inDoc.indexOf(index) === -1) throw "No Such Index In Collection";
        try {
            await DistinctFor(index);
            return final;
        } catch (e) {
            throw e
        }
    }
    function ParseDoc(doc) {
        return new Promise(function (result) {
            let err;
            for (let index in doc) {
                let key = doc[index];
                if (!key) {
                    err = "No Key For Index "+index; break;
                }
                vals.push(new Promise(function (pushed) {
                    DistinctFor(key)
                        .then(pushed)
                        .catch(function (err) {
                            return pushed(Promise.resolve());
                        })
                }))
            }
            return result(err ? Promise.reject(err) : Promise.resolve());
        })
    }

    async function DistinctFor(key) {
        if (!key) throw "Key Is Undefined";
        try {
            final[key] = await collection.distinct(key);
        } catch (e) {
            final[key] = 'failed';
            throw e;
        }
    }
}

因此，使用基本_id索引查询一个集合，将返回以下内容(测试集合在测试时只有一个文档):

Mongo.MongoClient.connect(url, function (err, client) {
    assert.equal(null, err);

    let collection = client.db('my db').collection('the targeted collection');

    GetFor(collection, '_id')
        .then(function () {
            //returns
            // { _id: [ 5ae901e77e322342de1fb701 ] }
        })
        .catch(function (err) {
            //manage your error..
        })
});

注意，这使用了NodeJS Driver原生的方法。正如其他一些答案所建议的那样，还有其他方法，例如聚合框架。我个人认为这种方法更灵活，因为您可以轻松地创建和微调如何返回结果。显然，这只处理顶级属性，而不是嵌套属性。 此外，为了保证所有文档都被表示，如果有二级索引(除了主_id索引)，这些索引应该根据需要设置。

我知道这个问题已经10年了，但是c#没有解决方案，我花了好几个小时才弄清楚。我正在使用。net驱动程序和系统。Linq返回键的列表。

var map = new BsonJavaScript("function() { for (var key in this) { emit(key, null); } }");
var reduce = new BsonJavaScript("function(key, stuff) { return null; }");
var options = new MapReduceOptions<BsonDocument, BsonDocument>();
var result = await collection.MapReduceAsync(map, reduce, options);
var list = result.ToEnumerable().Select(item => item["_id"].ToString());

以Kristina的回答为灵感，我创建了一个名为Variety的开源工具，它的功能就是:https://github.com/variety/variety

沿着@James Cropcho的回答，我找到了下面这个我觉得超级好用的方法。这是一个二进制工具，这正是我正在寻找的: mongoeye。

使用这个工具，大约花了2分钟从命令行导出我的模式。

下面是用Python编写的示例: 这个示例内联返回结果。

from pymongo import MongoClient
from bson.code import Code

mapper = Code("""
    function() {
                  for (var key in this) { emit(key, null); }
               }
""")
reducer = Code("""
    function(key, stuff) { return null; }
""")

distinctThingFields = db.things.map_reduce(mapper, reducer
    , out = {'inline' : 1}
    , full_response = True)
## do something with distinctThingFields['results']