在Mongoose中，时间戳通常适用于想要自动记录文档创建和最后修改时间的场景。启用时间戳的模式选项会为你的文档添加两个字段：`createdAt` 和 `updatedAt`。`createdAt` 字段会在文档首次保存到数据库时设置，而 `updatedAt` 字段会在每次调用 `save()` 方法更新文档时自动更新。

以下是使用时间戳的适合场景：

1. **用户账户系统**：在用户账户系统中，可以通过时间戳轻松追踪用户账户的创建时间和上次更新时间，这对于审计和监控账户行为很有帮助。

2. **日志记录**：如果你正在构建一个需要日志记录的系统，如错误日志或用户活动日志，时间戳是记录事件发生时间的理想方式。

3. **内容管理系统** (CMS)：在CMS中，内容项（如文章、页面或评论）通常需要记录发布和编辑的时间戳，以便追踪内容的版本和历史。

4. **电子商务平台**：在订单管理中，记录订单创建和修改时间对于订单处理流程和客户服务至关重要。

5. **博客平台**：博客文章通常会展示发布和最后修改的日期，通过时间戳可以自动化这一过程。

6. **任务跟踪系统**：在任务或票据等跟踪系统中，了解任务何时被创建和最后更新对于项目管理非常重要。

下面是一个启用时间戳的Mongoose模式的示例：

```javascript
const mongoose = require('mongoose');
const { Schema } = mongoose;

const UserSchema = new Schema(
  {
    username: {
      type: String,
      required: true
    },
    email: {
      type: String,
      required: true,
      unique: true
    },
    password: {
      type: String,
      required: true
    }
    // 其他字段...
  },
  {
    timestamps: true // 启用时间戳
  }
);

const User = mongoose.model('User', UserSchema);

// 当你使用 User 模型创建新用户时，Mongoose会自动设置 createdAt 和 updatedAt 字段。
```

在这个用户账户模型示例中，启用时间戳选项后，每个用户文档都将自动包含 `createdAt` 和 `updatedAt` 字段，这可以帮助我们跟踪用户的注册时间以及他们信息的最后更新时间。如果以后需要对用户表进行数据分析或维护，这些时间戳将非常有用。

**Edit - 20 March 2016**

Mongoose now support [timestamps for collections](https://github.com/Automattic/mongoose/blob/master/History.md#4111--2015-10-12).

Please consider the [answer of @bobbyz below](https://stackoverflow.com/a/34398826/1139105). Maybe this is what you are looking for.

Original answer
===============

Mongoose supports a `Date` type (which is basically a timestamp):

    time : { type : Date, default: Date.now }
    

With the above field definition, any time you save a document with an unset `time` field, Mongoose will fill in this field with the current time.

Source: [http://mongoosejs.com/docs/guide.html](http://mongoosejs.com/docs/guide.html)

The current version of Mongoose (v4.x) has time stamping as a built-in option to a schema:

    var mySchema = new mongoose.Schema( {name: String}, {timestamps: true} );
    

This option adds `createdAt` and `updatedAt` properties that are timestamped with a `Date`, and which does all the work for you. Any time you update the document, it updates the `updatedAt` property. [Schema Timestamps Docs.](http://mongoosejs.com/docs/guide.html#timestamps)

In case you want custom names for your `createdAt` and `updatedAt`

    const mongoose = require('mongoose');  
    const { Schema } = mongoose;
        
    const schemaOptions = {
      timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' },
    };
    
    const mySchema = new Schema({ name: String }, schemaOptions);

var ItemSchema = new Schema({
        name : { type: String }
    });
    
    ItemSchema.set('timestamps', true); // this will add createdAt and updatedAt timestamps
    

Docs: [https://mongoosejs.com/docs/guide.html#timestamps](https://mongoosejs.com/docs/guide.html#timestamps)

Mongoose now supports the timestamps in schema.

    const item = new Schema(
      {
        id: {
          type: String,
          required: true,
        },
      { timestamps: true },
    );
    

This will add the `createdAt` and `updatedAt` fields on each record create.

Timestamp interface has fields

      interface SchemaTimestampsConfig {
        createdAt?: boolean | string;
        updatedAt?: boolean | string;
        currentTime?: () => (Date | number);
      }
    

This would help us to choose which fields we want and overwrite the date format.

Which schematype in mongoose is best for a timestamp

在使用Mongoose进行分页查询时，通常需要两个参数：`page`（当前页码）和`limit`（每页显示的记录数）。页码和记录数可以让我们计算出需要跳过多少条记录来获取当前页的数据。

这里有一个基础的例子，演示了怎样实现分页：

假设我们有一个模型 `Item`，我们需要实现一个查询来获取第 `page` 页的数据，每页显示 `limit` 条记录。

```javascript
const page = req.query.page; // 从请求中获取页码
const limit = req.query.limit; // 从请求中获取每页显示的记录数

const options = {
  page: parseInt(page, 10) || 1, // 设置默认页码为1
  limit: parseInt(limit, 10) || 10, // 设置默认每页显示记录数为10
};

// 计算跳过多少条记录
const skip = (options.page - 1) * options.limit;

// 分页查询
Item.find()
  .skip(skip)
  .limit(options.limit)
  .exec((err, items) => {
    if (err) {
      // 处理错误
    } else {
      // 处理查询结果
    }
  });
```

在上面的代码中，我们首先从请求中获取页码和每页记录数。然后，我们计算出需要跳过的记录数，这是通过将当前页码减去1，然后乘以每页的记录数来实现的。这个值就是 `.skip()` 方法需要的参数。`.limit()` 方法则告诉Mongoose每页需要获取的记录数。

这样，每次调用这个分页查询，你只需要传递相应的 `page` 和 `limit` 参数即可。如果用户没有提供这些参数，我们会使用默认值。

值得注意的是，这种方法适用于数据量不是非常大时的分页。当处理大量数据时，每次都用 `.skip()` 和 `.limit()` 方法可能会导致性能问题，因为 `.skip()` 实际上是通过读取并跳过前面的记录来实现的，这在记录数非常多的时候可能很慢。解决这个问题的一种方法是使用类似于 "无限滚动" 的策略，根据最后加载的记录的ID来获取下一批记录。

I suggest you to use 2 queries:

1.  `db.collection.count()` will return total number of items. This value is stored somewhere in Mongo and it is not calculated.
    
2.  `db.collection.find().skip(20).limit(10)` here I assume you could use a sort by some field, so do not forget to add an index on this field. This query will be fast too.
    

I think that you shouldn't query all items and than perform skip and take, cause later when you have big data you will have problems with data transferring and processing.

Instead of using 2 separate queries, you can use `aggregate()` in a single query:

Aggregate **"$facet"** can be fetch more quickly, the _**Total Count**_ and the _**Data with skip & limit**_

        db.collection.aggregate([
    
          //{$sort: {...}}
    
          //{$match:{...}}
    
          {$facet:{
    
            "stage1" : [ {"$group": {_id:null, count:{$sum:1}}} ],
    
            "stage2" : [ { "$skip": 0}, {"$limit": 2} ]
      
          }},
         
         {$unwind: "$stage1"},
      
          //output projection
         {$project:{
            count: "$stage1.count",
            data: "$stage2"
         }}
    
     ]);
    

**output as follows:-**

    [{
         count: 50,
         data: [
            {...},
            {...}
          ]
     }]
    

Also, have a look at [https://docs.mongodb.com/manual/reference/operator/aggregation/facet/](https://docs.mongodb.com/manual/reference/operator/aggregation/facet/)

db.collection_name.aggregate([
        { '$match'    : { } },
        { '$sort'     : { '_id' : -1 } },
        { '$facet'    : {
            metadata: [ { $count: "total" } ],
            data: [ { $skip: 1 }, { $limit: 10 },{ '$project' : {"_id":0} } ] // add projection here wish you re-shape the docs
        } }
    ] )
    

Instead of using two queries to find the total count and skip the matched record.  
$facet is the best and optimized way.  

1.  Match the record  
    
2.  Find total\_count  
    
3.  skip the record  
    
4.  And also can reshape data according to our needs in the query.

There is a library that will do all of this for you, check out [mongoose-paginate-v2](https://github.com/aravindnc/mongoose-paginate-v2)

You don't have to use two queries or one complicated query with aggregate and such.

You can use one query

example:

    const getNames = async (queryParams) => {
    
      const cursor = db.collection.find(queryParams).skip(20).limit(10);
      return {
        count: await cursor.count(),
        data: await cursor.toArray()
      }
      
    }
    

mongo returns a cursor that has predefined functions such as count, which will return the full count of the queried results regardless of skip and limit

So in count property, you will get the full length of the collection and in data, you will get just the chunk with offset of 20 and limit of 10 documents

Mongoose limit offset and count query

在Node.js中实现面向对象编程（OOP）的方法主要是通过使用JavaScript的类和原型继承特性。以下是实现OOP的几个步骤：

### 1. 定义类

在ES6中引入了`class`关键字，可以使定义类更加直观。类是对象的蓝图，可以定义属性和方法。

```javascript
class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  greet() {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}
```

### 2. 创建对象实例

使用`new`关键字从类创建对象实例。

```javascript
const person1 = new Person('Alice', 30);
person1.greet(); // 输出: Hello, my name is Alice and I am 30 years old.
```

### 3. 继承

可以通过`extends`关键字使一个类继承另一个类的特性。

```javascript
class Employee extends Person {
  constructor(name, age, jobTitle) {
    super(name, age); // 调用父类的构造器
    this.jobTitle = jobTitle;
  }

  work() {
    console.log(`${this.name} is working as a ${this.jobTitle}.`);
  }
}

const employee1 = new Employee('Bob', 25, 'Software Developer');
employee1.greet();   // 输出: Hello, my name is Bob and I am 25 years old.
employee1.work();    // 输出: Bob is working as a Software Developer.
```

### 4. 封装

封装是OOP中的一个核心概念，意味着将对象的状态和行为包含在内部，并只暴露有限的接口与外界通信。

```javascript
class BankAccount {
  #balance; // 私有属性，使用 # 标记

  constructor(initialBalance) {
    this.#balance = initialBalance;
  }

  deposit(amount) {
    if (amount > 0) {
      this.#balance += amount;
    }
  }

  withdraw(amount) {
    if (amount <= this.#balance) {
      this.#balance -= amount;
    }
  }

  getBalance() {
    return this.#balance;
  }
}

const account = new BankAccount(1000);
account.deposit(500);
console.log(account.getBalance()); // 输出: 1500
```

在这个例子中，`#balance`是一个私有属性，它不可以直接从类的外部访问，而只能通过类的方法来操作。

### 5. 多态

多态性意味着子类可以定义一个与父类相同的方法，但具有不同的行为。

```javascript
class Animal {
  speak() {
    console.log('Animal speaks');
  }
}

class Dog extends Animal {
  speak() {
    console.log('Woof woof');
  }
}

const animal = new Animal();
const dog = new Dog();

animal.speak(); // 输出: Animal speaks
dog.speak();    // 输出: Woof woof
```

在这个例子中，`Dog`类重写了`Animal`类的`speak`方法，实现了多态。

通过这些步骤，我们可以在Node.js中实现面向对象编程的基本概念，包括类的定义、继承、封装和多态。这些原则有助于组织和模块化代码，使其更易于理解和维护。

This is an example that works out of the box. If you want less "hacky", you should use inheritance library or such.

Well in a file animal.js you would write:

    var method = Animal.prototype;
    
    function Animal(age) {
        this._age = age;
    }
    
    method.getAge = function() {
        return this._age;
    };
    
    module.exports = Animal;
    

To use it in other file:

    var Animal = require("./animal.js");
    
    var john = new Animal(3);
    

If you want a "sub class" then inside mouse.js:

    var _super = require("./animal.js").prototype,
        method = Mouse.prototype = Object.create( _super );
    
    method.constructor = Mouse;
    
    function Mouse() {
        _super.constructor.apply( this, arguments );
    }
    //Pointless override to show super calls
    //note that for performance (e.g. inlining the below is impossible)
    //you should do
    //method.$getAge = _super.getAge;
    //and then use this.$getAge() instead of super()
    method.getAge = function() {
        return _super.getAge.call(this);
    };
    
    module.exports = Mouse;
    

Also you can consider "Method borrowing" instead of vertical inheritance. You don't need to inherit from a "class" to use its method on your class. For instance:

     var method = List.prototype;
     function List() {
    
     }
    
     method.add = Array.prototype.push;
    
     ...
    
     var a = new List();
     a.add(3);
     console.log(a[0]) //3;

As Node.js community ensure new features from the JavaScript ECMA-262 specification are brought to Node.js developers in a timely manner.

You can take a look at **JavaScript classes**. [MDN link to JS classes](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes) In the ECMAScript 6 JavaScript classes are introduced, this method provide easier way to model OOP concepts in Javascript.

**Note** : JS classes will work in only **strict mode**.

Below is some skeleton of class,inheritance written in Node.js ( Used Node.js Version **v5.0.0** )

**Class declarations :**

    'use strict'; 
    class Animal{
    
     constructor(name){
        this.name = name ;
     }
    
     print(){
        console.log('Name is :'+ this.name);
     }
    }
    
    var a1 = new Animal('Dog');
    

**Inheritance :**

    'use strict';
    class Base{
    
     constructor(){
     }
     // methods definitions go here
    }
    
    class Child extends Base{
     // methods definitions go here
     print(){ 
     }
    }
    
    var childObj = new Child();

I suggest to use the `inherits` helper that comes with the standard `util` module: [http://nodejs.org/api/util.html#util\_util\_inherits\_constructor\_superconstructor](http://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor)

There is an example of how to use it on the linked page.

This is the best video about Object-Oriented JavaScript on the internet:

[The Definitive Guide to Object-Oriented JavaScript](https://www.youtube.com/watch?v=PMfcsYzj-9M)

Watch from beginning to end!!

Basically, Javascript is a [Prototype-based](https://en.wikipedia.org/wiki/Prototype-based_programming) language which is quite different than the classes in Java, C++, C#, and other popular friends. The video explains the core concepts far better than any answer here.

With ES6 (released 2015) we got a "class" keyword which allows us to use Javascript "classes" like we would with Java, C++, C#, Swift, etc.

Screenshot from the video showing how to write and instantiate a Javascript class/subclass: [![enter image description here](https://i.stack.imgur.com/gZlB4.png)](https://en.wikipedia.org/wiki/Prototype-based_programming)

In the Javascript community, lots of people argue that OOP should not be used because the prototype model does not allow to do a strict and robust OOP natively. However, I don't think that OOP is a matter of langage but rather a matter of architecture.

If you want to use a real strong OOP in Javascript/Node, you can have a look at the full-stack open source framework [Danf](https://github.com/gnodi/danf). It provides all needed features for a strong OOP code (classes, interfaces, inheritance, dependency-injection, ...). It also allows you to use the same classes on both the server (node) and client (browser) sides. Moreover, you can code your own danf modules and share them with anybody thanks to Npm.

How to achieve oop in nodejs

Mongoose 是一个 MongoDB 对象文档模型（ODM）库，它提供了一种在 Node.js 环境中优雅地处理 MongoDB 数据库的方式。在 Mongoose 中，一个集合通常通过一个模型来表示，这个模型定义了文档的结构和它们的行为。

要从 Mongoose 集合中删除所有文档，您可以使用模型的 `deleteMany()` 函数，无需指定过滤条件，就可以删除所有匹配的文档。下面是一个如何使用 `deleteMany()` 函数的示例：

```javascript
// 引入 Mongoose 和连接到数据库
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost:27017/mydatabase', {useNewUrlParser: true, useUnifiedTopology: true});

// 定义模型和模式
const Schema = mongoose.Schema;
const mySchema = new Schema({
    // 定义文档的结构...
});
const MyModel = mongoose.model('MyCollection', mySchema);

// 删除集合中的所有文档
MyModel.deleteMany({}, (err) => {
    if (err) {
        console.error('发生错误:', err);
    } else {
        console.log('成功删除集合中的所有文档。');
    }
});
```

在这个例子中，`MyModel` 表示连接到 MongoDB 数据库中名为 `'MyCollection'` 的集合。我们调用 `deleteMany()` 函数并传递了一个空对象 `{}` 作为第一个参数，这表示没有任何删除条件，即删除集合中的所有文档。回调函数提供了一个错误参数，用于处理可能发生的错误，如果删除操作成功，会执行 `else` 代码块。

还有另一种方式是使用 `async/await` 语法：

```javascript
// 异步函数来删除所有文档
async function deleteAllDocuments() {
    try {
        const result = await MyModel.deleteMany({});
        console.log('成功删除集合中的所有文档。', result);
    } catch (err) {
        console.error('发生错误:', err);
    }
}

// 调用异步函数
deleteAllDocuments();
```

在这个版本中，我们创建了一个异步函数 `deleteAllDocuments`，在这个函数中，我们使用 `await` 关键字等待 `deleteMany()` 操作完成。这样可以让代码更加干净和易于理解，尤其是在更复杂的逻辑中。如果操作成功，我们会记录输出结果，如果遇到错误，我们会捕获错误并记录。

请注意，在实际场景中删除所有文档是一个具有破坏性的操作，因此在生产环境中应该非常小心地使用，并确保有适当的备份和恢复计划。

`DateTime.remove({}, callback)` The empty object will match all of them.

`.remove()` is deprecated. instead we can use deleteMany

`DateTime.deleteMany({}, callback)`.

In MongoDB, the db.collection.remove() method removes documents from a collection. You can remove all documents from a collection, remove all documents that match a condition, or limit the operation to remove just a single document.

Source: [Mongodb](http://docs.mongodb.org/manual/tutorial/remove-documents/).

If you are using mongo sheel, just do:

    db.Datetime.remove({})
    

In your case, you need:

You didn't show me the delete button, so this button is just an example:

    <a class="button__delete"></a>
    

Change the controller to:

    exports.destroy = function(req, res, next) {
        Datetime.remove({}, function(err) {
                if (err) {
                    console.log(err)
                } else {
                    res.end('success');
                }
            }
        );
    };
    

Insert this ajax delete method in your client js file:

            $(document).ready(function(){
                $('.button__delete').click(function() {
                    var dataId = $(this).attr('data-id');
    
                    if (confirm("are u sure?")) {
                        $.ajax({
                            type: 'DELETE',
                            url: '/',
                            success: function(response) {
                                if (response == 'error') {
                                    console.log('Err!');
                                }
                                else {
                                    alert('Success');
                                    location.reload();
                                }
                            }
                        });
                    } else {
                        alert('Canceled!');
                    }
                });
            });

**MongoDB shell version v4.2.6**  
**Node v14.2.0**

Assuming you have a Tour Model: tourModel.js

    const mongoose = require('mongoose');
    
    const tourSchema = new mongoose.Schema({
      name: {
        type: String,
        required: [true, 'A tour must have a name'],
        unique: true,
        trim: true,
      },
      createdAt: {
        type: Date,
        default: Date.now(),
      },
    });
    const Tour = mongoose.model('Tour', tourSchema);
    
    module.exports = Tour;
    

Now you want to delete all tours at once from your MongoDB, I also providing connection code to connect with the remote cluster. I used deleteMany(), if you do not pass any args to deleteMany(), then it will delete all the documents in Tour collection.

    const mongoose = require('mongoose');
    const Tour = require('./../../models/tourModel');
    const conStr = 'mongodb+srv://lord:<PASSWORD>@cluster0-eeev8.mongodb.net/tour-guide?retryWrites=true&w=majority';
    const DB = conStr.replace('<PASSWORD>','ADUSsaZEKESKZX');
    mongoose.connect(DB, {
        useNewUrlParser: true,
        useCreateIndex: true,
        useFindAndModify: false,
        useUnifiedTopology: true,
      })
      .then((con) => {
        console.log(`DB connection successful ${con.path}`);
      });
    
    const deleteAllData = async () => {
      try {
        await Tour.deleteMany();
        console.log('All Data successfully deleted');
      } catch (err) {
        console.log(err);
      }
    };

`Your_Mongoose_Model.deleteMany({})` can do the job  
  
References:  
[https://mongoosejs.com/docs/api.html#query\_Query-deleteMany](https://mongoosejs.com/docs/api.html#query_Query-deleteMany) [https://www.geeksforgeeks.org/mongoose-deletemany-function/](https://www.geeksforgeeks.org/mongoose-deletemany-function/)

How can you remove all documents from a collection with mongoose

Mongoose 是一个 MongoDB 对象建模工具，设计用于在异步环境中工作。在 Mongoose 中保护密码字段通常需要两个步骤：加密密码和确保在查询时不包括密码字段。

### 加密密码

保护密码字段的第一步是在保存到数据库之前对其进行加密。通常，这是通过使用 bcrypt 或类似的库来实现的。bcrypt 是一个安全的方式，因为它可以对密码进行散列，并且包含了一个盐（salt）来保护密码免受彩虹表攻击。

在 Mongoose 中，你可以使用 pre-save 钩子来在文档保存之前自动加密密码。以下是一个例子：

```javascript
const bcrypt = require('bcrypt');
const mongoose = require('mongoose');
const Schema = mongoose.Schema;

const userSchema = new Schema({
  username: String,
  password: String,
  // 其他字段...
});

// Pre-save hook 用于加密密码
userSchema.pre('save', async function(next) {
  // 当密码字段被修改时才进行加密
  if (this.isModified('password') || this.isNew) {
    try {
      const salt = await bcrypt.genSalt(10);
      const hash = await bcrypt.hash(this.password, salt);
      this.password = hash;
      next();
    } catch (error) {
      next(error);
    }
  } else {
    next();
  }
});

const User = mongoose.model('User', userSchema);

module.exports = User;
```

### 确保查询时不包括密码字段

即使密码被加密，你通常也不想在查询的响应中包含它。在 Mongoose 中，可以使用查询投影来排除特定字段，或者通过在 schema 中设置 `select: false` 选项来默认排除某些字段。

在 schema 设置中排除密码字段的例子：

```javascript
const userSchema = new Schema({
  username: String,
  password: { type: String, select: false },
  // 其他字段...
});

// ...其余的schema和模型定义
```

当你使用这种方式时，即使你执行了一个普通的查询，像是 `User.find()`，密码字段也不会被返回。如果你在某个特定的查询中需要密码字段，你可以使用 `.select('+password')` 来明确请求它：

```javascript
User.findOne({ username: 'exampleUser' }).select('+password').exec((err, user) => {
  // 现在 `user` 对象将包括密码字段
  // ...
});
```

通过这两个步骤，Mongoose 可以帮助你确保密码字段得到妥善保护并在默认情况下不被查询返回。

You can change the default behavior at the schema definition level using the [`select`](http://mongoosejs.com/docs/api.html#schematype_SchemaType-select) attribute of the field:

    password: { type: String, select: false }
    

Then you can pull it in as needed in `find` and `populate` calls via field selection as `'+password'`. For example:

    Users.findOne({_id: id}).select('+password').exec(...);

.populate('user' , '-password')
    

[http://mongoosejs.com/docs/populate.html](http://mongoosejs.com/docs/populate.html)

JohnnyHKs answer using Schema options is probably the way to go here.

Also note that `query.exclude()` only exists in the 2.x branch.

Edit:

After trying both approaches, I found that the exclude always approach wasn't working for me for some reason using passport-local strategy, don't really know why.

So, this is what I ended up using:

    Blogs.findOne({_id: id})
        .populate("user", "-password -someOtherField -AnotherField")
        .populate("comments.items.user")
        .exec(function(error, result) {
            if(error) handleError(error);
            callback(error, result);
        });
    

There's nothing wrong with the exclude always approach, it just didn't work with passport for some reason, my tests told me that in fact the password was being excluded / included when I wanted. The only problem with the include always approach is that I basically need to go through every call I do to the database and exclude the password which is a lot of work.

* * *

After a couple of great answers I found out there are two ways of doing this, the "always include and exclude sometimes" and the "always exclude and include sometimes"?

An example of both:

**The include always but exclude sometimes** example:

    Users.find().select("-password")
    

or

    Users.find().exclude("password")
    

**The exclude always but include sometimes** example:

    Users.find().select("+password")
    

but you must define in the schema:

    password: { type: String, select: false }

You can achieve that using the schema, for example:

    const UserSchema = new Schema({/* */})
    
    UserSchema.set('toJSON', {
        transform: function(doc, ret, opt) {
            delete ret['password']
            return ret
        }
    })
    
    const User = mongoose.model('User', UserSchema)
    User.findOne() // This should return an object excluding the password field

`User.find().select('-password')` is the right answer. You can not add `select: false` on the Schema since it will not work, if you want to login.

How to protect the password field in mongoose and it wont return in a query

在 Mongoose 中，通常我们是通过定义一个 `Schema` 来指定集合中文档的结构，这样既可以确保数据的一致性，也方便开发者理解和操作数据库。然而，在某些情况下，我们可能需要在不定义 schema 的情况下执行操作，Mongoose 提供了这样的灵活性，通过所谓的“不严格”模式或者使用 `mongoose.model` 和 `mongoose.connection` 对象来直接操作。

如果想在不定义 schema 的情况下执行 Mongoose 指令，可以采用以下方法：

### 使用不严格模式的 Schema

即使你定义了一个 Schema，你也可以设置它为“不严格”模式，在这个模式下，Mongoose 不会限制数据的结构，允许存储任何形状的文档。

```javascript
const mongoose = require('mongoose');
const { Schema } = mongoose;

// 定义一个不严格的 Schema
const anySchema = new Schema({}, { strict: false });
const AnyModel = mongoose.model('AnyCollection', anySchema);

// 现在你可以存储任何形状的文档
const anyDocument = new AnyModel({ any: { thing: 'you want' } });
anyDocument.save();
```

### 使用 `mongoose.model` 和 `mongoose.connection` 对象

另外，你也可以不定义 Schema 而直接使用 `mongoose.model` 和 `mongoose.connection` 对象进行操作。

```javascript
const mongoose = require('mongoose');

// 连接到数据库
mongoose.connect('mongodb://localhost:27017/test', { useNewUrlParser: true });

// 直接获取 Model，注意这里不需要定义 Schema
const AnyModel = mongoose.model('AnyCollection', new mongoose.Schema({}, { strict: false }));

// 通过 Model 创建并保存一个新文档
AnyModel.create({ any: { thing: 'you wish' } }, function (err, result) {
  if (err) throw err;
  // 执行一些其他操作
});

// 直接使用 mongoose.connection 对象操作数据库
const collection = mongoose.connection.collection('anycollection');
collection.insertOne({ anything: 'you want' }, function (err, result) {
  if (err) throw err;
  // 插入成功后的操作
});
```

在这些例子中，我们没有为 `AnyCollection` 定义 Schema，而是利用 Mongoose 提供的机制来执行操作。

不过需要注意的是，虽然这种方法提供了灵活性，但它也有缺点。没有 Schema 的 Mongoose 模型无法利用 Mongoose 提供的很多内置功能，如验证、中间件、静态方法等。此外，无法确保数据的一致性，这可能会导致一些意外的行为和难以调试的问题。所以在开发中应当权衡利弊，并在确实需要灵活性时才考虑不定义 Schema。

I think this is what are you looking for [Mongoose Strict](http://mongoosejs.com/docs/guide.html#strict)

**option: strict**

The strict option, (enabled by default), ensures that values added to our model instance that were not specified in our schema do not get saved to the db.

**Note: Do not set to false unless you have good reason.**

        var thingSchema = new Schema({..}, { strict: false });
        var Thing = mongoose.model('Thing', thingSchema);
        var thing = new Thing({ iAmNotInTheSchema: true });
        thing.save() // iAmNotInTheSchema is now saved to the db!!

Actually "Mixed" (`Schema.Types.Mixed`) mode appears to do exactly that in Mongoose...

it accepts a **schema-less**, **freeform JS object** - so whatever you can throw at it. It seems you have to trigger saves on that object manually afterwards, but it seems like a fair tradeoff.

> Mixed
> -----
> 
> An "anything goes" SchemaType, its flexibility comes at a trade-off of it being harder to maintain. Mixed is available either through `Schema.Types.Mixed` or by passing an empty object literal. The following are equivalent:
> 
>     var Any = new Schema({ any: {} });
>     var Any = new Schema({ any: Schema.Types.Mixed });
>     
> 
> Since it is a schema-less type, you can change the value to anything else you like, but Mongoose loses the ability to auto detect and save those changes. To "tell" Mongoose that the value of a Mixed type has changed, call the `.markModified(path)` method of the document passing the path to the Mixed type you just changed.
> 
>     person.anything = { x: [3, 4, { y: "changed" }] };
>     person.markModified('anything');
>     person.save(); // anything will now get saved
>     

*   [Mongoose Schema Types](http://mongoosejs.com/docs/schematypes.html#mixed)

Hey Chris, take a look at [Mongous](https://github.com/amark/mongous). I was having the same issue with mongoose, as my Schemas change extremely frequently right now in development. Mongous allowed me to have the simplicity of Mongoose, while being able to loosely define and change my 'schemas'. I chose to simply build out standard JavaScript objects and store them in the database like so

    function User(user){
      this.name = user.name
    , this.age = user.age
    }
    
    app.post('save/user', function(req,res,next){
      var u = new User(req.body)
      db('mydb.users').save(u)
      res.send(200)
      // that's it! You've saved a user
    });
    

Far more simple than Mongoose, although I do believe you miss out on some cool middleware stuff like "pre". I didn't need any of that though. Hope this helps!!!

Here is the details description: \[[https://www.meanstack.site/2020/01/save-data-to-mongodb-without-defining.html\]\[1\]](https://www.meanstack.site/2020/01/save-data-to-mongodb-without-defining.html][1])

        const express = require('express')()
        const mongoose = require('mongoose')
        const bodyParser = require('body-parser')
        const Schema = mongoose.Schema
    
        express.post('/', async (req, res) => {
            // strict false will allow you to save document which is coming from the req.body
            const testCollectionSchema = new Schema({}, { strict: false })
            const TestCollection = mongoose.model('test_collection', testCollectionSchema)
            let body = req.body
            const testCollectionData = new TestCollection(body)
            await testCollectionData.save()
            return res.send({
                "msg": "Data Saved Successfully"
            })
        })
    
    
      [1]: https://www.meanstack.site/2020/01/save-data-to-mongodb-without-defining.html

You can also use `mongoose.connection.collection`

    import mongoose from 'mongoose';
    
    const collection = mongoose.connection.collection('user')
    
    // use it like a mongodb collection
    await collection.updateOne({ name: "name" }, { $set: { name: "new_name" } })
    

See [mongoose documentation](https://mongoosejs.com/docs/api/connection.html#Connection.prototype.collection())

How do you use mongoose without defining a schema

在 Mongoose 中，限制查询返回的数据长度通常是通过两个方法来实现的：`limit()` 和 `skip()`。这两种方法对应于 MongoDB 的分页功能，`limit()` 用于指定返回结果的最大数量，而 `skip()` 用于指定跳过记录的数量。

例如，如果你想查询某个集合并只获取前10条记录，可以如下使用 `limit()` 方法：

```javascript
const query = Model.find();
query.limit(10);
query.exec((err, documents) => {
  // 处理查询结果或错误
});
```

如果你还需要实现分页功能，比如跳过前20条记录，只获取接下来的10条记录，可以组合使用 `skip()` 和 `limit()` 方法：

```javascript
const query = Model.find();
query.skip(20); // 跳过前20条
query.limit(10); // 限制返回的记录数为10
query.exec((err, documents) => {
  // 处理查询结果或错误
});
```

此外，Mongoose 还允许你在一条链式查询中直接调用 `limit()` 和 `skip()` 方法：

```javascript
Model.find()
  .skip(20) // 跳过前20条
  .limit(10) // 限制返回的记录数为10
  .exec((err, documents) => {
    // 处理查询结果或错误
  });
```

以上就是在 Mongoose 中限制查询返回数据长度的基本方法。在实际应用中，根据需求你可能还需要结合排序（`sort()` 方法）和投影（选择性返回某些字段，使用 `select()` 方法）来进一步控制查询结果。

How do i limit the number of returned items

当您使用Mongoose查询一个预先存在的集合时，您首先需要定义一个与该集合匹配的模型。这涉及到两个主要步骤：定义您的模式（Schema），然后根据该模式创建一个模型。以下是具体的步骤：

1. **定义模式（Schema）**：模式是一个对象，它定义了存储在MongoDB集合中的文档的结构和规则。这包括每个字段的类型、是否必填、默认值、验证等。

    ```javascript
    const mongoose = require('mongoose');
    const { Schema } = mongoose;

    const myExistingCollectionSchema = new Schema({
      // 在这里定义字段和它们的类型
      name: String,
      age: Number,
      // 更多字段...
    });
    ```

2. **创建模型（Model）**：模型是一个与定义的模式相对应的构造函数，你可以使用这个构造函数与数据库中的集合进行交云。

    ```javascript
    const MyModel = mongoose.model('MyExistingCollection', myExistingCollectionSchema);
    ```

    请注意，`mongoose.model`的第一个参数是你希望Mongoose连接到的集合名称。Mongoose默认会将模型名字转为小写并且复数形式来查找集合。如果您的集合名不符合这个转换规则，您需要在第三个参数中明确指定集合的名称：

    ```javascript
    const MyModel = mongoose.model('MyExistingCollection', myExistingCollectionSchema, 'custom_collection_name');
    ```

3. **执行查询**：一旦你有了一个模型，你就可以使用它来查询集合。Mongoose提供了多种方法来检索和操作数据，如 `find`, `findOne`, `findById` 等。

    ```javascript
    // 查询所有文档
    MyModel.find({}, function(err, results) {
      if (err) throw err;
      // 处理查询结果
      console.log(results);
    });

    // 根据条件查询单个文档
    MyModel.findOne({ age: { $gte: 18 } }, function(err, result) {
      if (err) throw err;
      // 处理查询结果
      console.log(result);
    });

    // 根据ID查询单个文档
    MyModel.findById('某个文档的ID', function(err, result) {
      if (err) throw err;
      // 处理查询结果
      console.log(result);
    });
    ```

**示例**：

假设我们有一个名为 `users` 的集合，其中包含姓名（name）、年龄（age）等信息。下面的示例代码展示了如何定义对应的模型并查询所有年龄大于等于18的用户。

```javascript
const mongoose = require('mongoose');
const { Schema } = mongoose;

// 连接到数据库
mongoose.connect('mongodb://localhost/mydatabase', { useNewUrlParser: true, useUnifiedTopology: true });

// 定义模式
const userSchema = new Schema({
  name: String,
  age: Number,
});

// 创建模型，假设集合名字正好是 `users` 的复数小写形式
const User = mongoose.model('User', userSchema);

// 执行查询
User.find({ age: { $gte: 18 } }, (err, users) => {
  if (err) {
    console.error(err);
  } else {
    console.log('成年用户:', users);
  }
});
```

这样就可以查询到预先存在的 `users` 集合中所有年龄大于等于18的文档了。

Mongoose added the ability to specify the collection name under the schema, or as the third argument when declaring the model. Otherwise it will use the pluralized version given by the name you map to the model.

Try something like the following, either schema-mapped:

    new Schema({ url: String, text: String, id: Number}, 
               { collection : 'question' });   // collection name
    

or model mapped:

    mongoose.model('Question', 
                   new Schema({ url: String, text: String, id: Number}), 
                   'question');     // collection name

Here's an abstraction of Will Nathan's answer if anyone just wants an easy copy-paste add-in function:

    function find (name, query, cb) {
        mongoose.connection.db.collection(name, function (err, collection) {
           collection.find(query).toArray(cb);
       });
    }
    

simply do `find(collection_name, query, callback);` to be given the result.

for example, if I have a document { a : 1 } in a collection 'foo' and I want to list its properties, I do this:

    find('foo', {a : 1}, function (err, docs) {
                console.dir(docs);
            });
    //output: [ { _id: 4e22118fb83406f66a159da5, a: 1 } ]

You can do something like this, than you you'll access the native mongodb functions inside mongoose:

    var mongoose = require("mongoose");
    mongoose.connect('mongodb://localhost/local');
    
    var connection = mongoose.connection;
    
    connection.on('error', console.error.bind(console, 'connection error:'));
    connection.once('open', function () {
    
        connection.db.collection("YourCollectionName", function(err, collection){
            collection.find({}).toArray(function(err, data){
                console.log(data); // it will print your collection data
            })
        });
    
    });
    

* * *

**Update 2022**

If you get an `MongoInvalidArgumentError: The callback form of this helper has been removed.` error message, here's the new syntax using `async/await`:

    const mongoose = require("mongoose");
    mongoose.connect('mongodb://localhost/productsDB');
    
    const connection = mongoose.connection;
    
    connection.on('error', console.error.bind(console, 'connection error:'));
    connection.once('open', async function () {
    
      const collection  = connection.db.collection("Products");
      collection.find({}).toArray(function(err, data){
          console.log(data); // it will print your collection data
      });
    
    });

I had the same problem and was able to run a schema-less query using an existing Mongoose connection with the code below. I've added a simple constraint 'a=b' to show where you would add such a constraint:

    var action = function (err, collection) {
        // Locate all the entries using find
        collection.find({'a':'b'}).toArray(function(err, results) {
            /* whatever you want to do with the results in node such as the following
                 res.render('home', {
                     'title': 'MyTitle',
                     'data': results
                 });
            */
        });
    };
    
    mongoose.connection.db.collection('question', action);

Are you sure you've connected to the db? (I ask because I don't see a port specified)

try:

    mongoose.connection.on("open", function(){
      console.log("mongodb is connected!!");
    });
    

Also, you can do a "show collections" in mongo shell to see the collections within your db - maybe try adding a record via mongoose and see where it ends up?

From the look of your connection string, you should see the record in the "test" db.

Hope it helps!

How to access a preexisting collection with mongoose?

在Mongoose中，如果您想获取所有model的总数，您通常需要对每个model分别执行一个count操作，并将结果累加。下面给出一个如何在Mongoose中实现这一过程的示例：

假设您有多个model，比如`User`, `Post`, 和 `Comment`，您可以如下进行：

```javascript
const mongoose = require('mongoose');

// 假设您已经定义并连接了models
const User = mongoose.model('User');
const Post = mongoose.model('Post');
const Comment = mongoose.model('Comment');

async function getTotalCountOfModels() {
  try {
    // 分别获取每个model的数量
    const userCount = await User.countDocuments().exec();
    const postCount = await Post.countDocuments().exec();
    const commentCount = await Comment.countDocuments().exec();

    // 将所有model的数量累加
    const totalCount = userCount + postCount + commentCount;
    
    console.log(`总数为: ${totalCount}`);
    return totalCount;
  } catch (error) {
    console.error('获取model总数时发生错误', error);
    throw error;
  }
}

// 调用函数
getTotalCountOfModels()
  .then(total => console.log('总数量为:', total))
  .catch(err => console.error(err));
```

在这个例子中，`countDocuments()` 方法被用来计算每个model中document的数量。我们通过`async/await`进行异步操作，并使用`try/catch`来处理可能出现的错误。

这是一个基础的例子，实际应用中可能会涉及更复杂的逻辑，比如过滤条件、关联查询等。此外，如果模型非常多，可能需要一个更自动化的方法来循环处理所有模型，而不是手动一个一个地调用。

The reason your code doesn't work is because the count function is asynchronous, it doesn't synchronously return a value.

Here's an example of usage:

    userModel.count({}, function( err, count){
        console.log( "Number of users:", count );
    })

The code below works. Note the use of [countDocuments](https://mongoosejs.com/docs/api.html#model_Model.countDocuments).

     var mongoose = require('mongoose');
     var db = mongoose.connect('mongodb://localhost/myApp');
     var userSchema = new mongoose.Schema({name:String,password:String});
     var userModel =db.model('userlists',userSchema);
     var anand = new userModel({ name: 'anand', password: 'abcd'});
     anand.save(function (err, docs) {
       if (err) {
           console.log('Error');
       } else {
           userModel.countDocuments({name: 'anand'}, function(err, c) {
               console.log('Count is ' + c);
          });
       }
     });

You should give an object as argument

    userModel.countDocuments({name: "sam"});
    

or

    userModel.countDocuments({name: "sam"}).exec(); //if you are using promise
    

or

    userModel.countDocuments({}); // if you want to get all counts irrespective of the fields
    

For the older versions of mongoose, use

    userModel.count({name: "sam"});

The collection.count is deprecated, and will be removed in a future version. Use collection.**countDocuments** or collection.**estimatedDocumentCount** instead.

    userModel.countDocuments(query).exec((err, count) => {
        if (err) {
            res.send(err);
            return;
        }
    
        res.json({ count: count });
    });

Background for the solution
===========================

As stated in the mongoose documentation and in the answer by Benjamin, the method [`Model.count()`](https://mongoosejs.com/docs/api.html#model_Model.count) is deprecated. Instead of using `count()`, the alternatives are the following:

**[`Model.countDocuments(filterObject, callback)`](https://mongoosejs.com/docs/api.html#model_Model.countDocuments)**

Counts how many documents match the filter in a collection. Passing an empty object {} as filter executes a full collection scan. If the collection is large, the following method might be used.

**[`Model.estimatedDocumentCount()`](https://mongoosejs.com/docs/api.html#model_Model.estimatedDocumentCount)**

This model method estimates the number of documents in the MongoDB collection. This method is faster than the previous `countDocuments()`, because it uses collection metadata instead of going through the entire collection. However, as the method name suggests, and depending on db configuration, the result is an estimate as the metadata might not reflect the actual count of documents in a collection at the method execution moment.

Both methods return a mongoose query object, which can be executed in one of the following two ways. Use `.exec()` if you want to execute a query at a later time.

The solution
============

Option 1: Pass a callback function
----------------------------------

For example, count all documents in a collection using `.countDocuments()`:

    someModel.countDocuments({}, function(err, docCount) {
        if (err) { return handleError(err) } //handle possible errors
        console.log(docCount)
        //and do some other fancy stuff
    })
    

Or, count all documents in a collection having a certain name using `.countDocuments()`:

    someModel.countDocuments({ name: 'Snow' }, function(err, docCount) {
        //see other example
    }
    

Option 2: Use `.then()`
-----------------------

A mongoose query has `.then()` so it’s “thenable”. This is for a convenience and query itself is not a promise.

For example, count all documents in a collection using `.estimatedDocumentCount()`:

    someModel
        .estimatedDocumentCount()
        .then(docCount => {
            console.log(docCount)
            //and do one super neat trick
        })
        .catch(err => {
            //handle possible errors
        })
    

Option 3: Use async/await
-------------------------

When using async/await approach, the [recommended](https://mongoosejs.com/docs/promises.html#should-you-use-exec-with-await?) way is to use it with `.exec()` as it provides better stack traces.

    const docCount = await someModel.countDocuments({}).exec();
    

_Learning by stackoverflowing,_

How to get all count of mongoose model

在 Mongoose 中，`ObjectId` 是 MongoDB 的一种数据类型，用于唯一标识文档。Mongoose 使用 MongoDB 下层的 `bson` 库来生成 `ObjectId`。

当你在 Mongoose 模型中定义了一个字段类型为 `ObjectId`，比如在用户模型的定义中：

```js
const mongoose = require('mongoose');
const { Schema } = mongoose;

const userSchema = new Schema({
  name: String,
  // 定义 ObjectId 类型字段
  _id: Schema.Types.ObjectId 
});

const User = mongoose.model('User', userSchema);
```

在你创建一个新文档并保存到数据库中时，Mongoose 会自动为这个 `_id` 字段生成一个新的 `ObjectId`。例如：

```js
const newUser = new User({
  name: 'John Doe'
});

newUser.save((err, savedUser) => {
  if (err) throw err;
  // savedUser._id 将会是一个自动生成的 ObjectId
  console.log(savedUser._id);
});
```

如果你没有显式地在你的模型定义中声明 `_id` 字段，Mongoose 会默认为你的每个文档添加一个 `_id` 字段，并自动生成一个 `ObjectId`。

`ObjectId` 是一个 12 字节的值，通常由以下几部分构成：

1. 4字节的时间戳，表示 ObjectId 的创建时间。
2. 5字节的随机值，为了确保在同一时间生成的 ObjectId 是唯一的。
3. 3字节的增量计数器，从随机值开始。

这种结构确保即使在大量操作下，生成的 ObjectId 也是唯一且按时间顺序排列的。

在某些情况下，你可能需要手动生成一个 `ObjectId`。你可以使用 Mongoose 提供的 `Types` 对象来做到这一点：

```js
const { Types } = require('mongoose');
const objectId = new Types.ObjectId();
```

现在 `objectId` 变量就包含了一个新生成的 `ObjectId` 实例，可以用在任何需要 ObjectId 的地方。

You can find the `ObjectId` constructor on `require('mongoose').Types`. Here is an example:

    var mongoose = require('mongoose');
    var id = mongoose.Types.ObjectId();
    

`id` is a newly generated `ObjectId`.

* * *

**Note**: As [Joshua Sherman](https://stackoverflow.com/questions/17899750/how-can-i-generate-an-objectid-with-mongoose/17899751?noredirect=1#comment122158950_17899751) points out, with Mongoose 6 you must prefix the call with `new`:

    var id = new mongoose.Types.ObjectId();
    

* * *

You can read more about the `Types` object at [Mongoose#Types documentation](https://mongoosejs.com/docs/schematypes.html#objectids).

You can create a new MongoDB `ObjectId` like this using mongoose:

    var mongoose = require('mongoose');
    var newId = new mongoose.mongo.ObjectId('56cb91bdc3464f14678934ca');
    // or leave the id string blank to generate an id with a new hex identifier
    var newId2 = new mongoose.mongo.ObjectId();

I needed to generate mongodb ids on client side.

After digging into the mongodb source code i found they generate ObjectIDs using npm `bson` lib.

If ever you need only to generate an ObjectID without installing the whole mongodb / mongoose package, you can import the lighter `bson` library :

    const bson = require('bson');
    new bson.ObjectId(); // 5cabe64dcf0d4447fa60f5e2
    

Note: There is also an npm project named `bson-objectid` being even lighter

With ES6 syntax

    import mongoose from "mongoose";
    
    // Generate a new new ObjectId
    const newId2 = new mongoose.Types.ObjectId();
    // Convert string to ObjectId
    const newId = new mongoose.Types.ObjectId('56cb91bdc3464f14678934ca');

The import is mongo from mongoose, the node-mongodb-native driver. If you open the package you can verify !

    import { mongo } from 'mongoose'
    const newId = new mongo.ObjectId()

How can i generate an objectid with mongoose

在使用Mongoose进行分页搜索时，通常会涉及到两个关键概念：`limit` 和 `skip`。这两个参数可以在MongoDB的查询中使用，以实现分页的效果。`limit` 用于限制查询结果的数量，而 `skip` 用于跳过指定数量的文档。

以下是如何使用Mongoose进行分页的步骤：

1. **确定每页的大小（即limit）：** 这是你想要每页显示的记录数。
2. **计算跳过的文档数（即skip）：** 这是根据当前的页码计算出需要跳过的记录数。例如，如果你每页显示10条记录，那么在第二页你需要跳过的记录数为 `10 * (当前页码 - 1)`。

### 示例代码

这是一个简单的例子，展示了如何使用Mongoose来实现分页搜索：

```javascript
const mongoose = require('mongoose');
const { Schema } = mongoose;

// 假设我们有一个用户模型
const UserSchema = new Schema({
  name: String,
  age: Number,
  // 更多字段...
});

const User = mongoose.model('User', UserSchema);

// 分页函数
async function findUsersWithPagination(page, limit) {
  try {
    // 计算需要跳过的文档数
    const skip = (page - 1) * limit;

    // 获取分页的数据
    const users = await User.find()
      .skip(skip)   // 跳过前面的文档
      .limit(limit) // 限制返回的文档数
      .exec();      // 执行查询

    // 获取总的文档数以计算总页数
    const count = await User.countDocuments();

    return {
      total: count,           // 总文档数
      perPage: limit,         // 每页文档数
      currentPage: page,      // 当前页码
      totalPages: Math.ceil(count / limit), // 总页数
      data: users             // 当前页的数据
    };
  } catch (error) {
    throw error;
  }
}

// 使用分页函数，比如获取第2页的数据，每页5条记录
findUsersWithPagination(2, 5).then(paginatedResults => {
  console.log(paginatedResults);
}).catch(err => {
  console.error(err);
});
```

在这个示例中，`findUsersWithPagination` 函数接收 `page` 和 `limit` 作为参数，然后使用这些参数来调整查询。它先计算需要跳过的记录数，然后应用 `skip` 和 `limit` 方法到查询中。最后，它还计算出总的文档数，以便可以返回有关分页的详细信息。

请注意，在实际的应用程序中，你可能还需要考虑排序问题，以确保文档以一致的顺序返回，这通常可以通过在 `find` 查询中使用 `.sort()` 方法来实现。

此外，如果你正在处理大量的数据，频繁地使用 `skip` 可能会导致性能问题，因为 `skip` 会导致数据库遍历过多的文档。在这种情况下，你可能需要考虑使用游标或者其他分页策略。

I'm am very disappointed by the accepted answers in this question. This will not scale. If you read the fine print on cursor.skip( ):

> The cursor.skip() method is often expensive because it requires the server to walk from the beginning of the collection or index to get the offset or skip position before beginning to return result. As offset (e.g. pageNumber above) increases, cursor.skip() will become slower and more CPU intensive. With larger collections, cursor.skip() may become IO bound.

To achieve pagination in a scaleable way combine a limit( ) along with at least one filter criterion, a createdOn date suits many purposes.

    MyModel.find( { createdOn: { $lte: request.createdOnBefore } } )
    .limit( 10 )
    .sort( '-createdOn' )

After taking a closer look at the Mongoose API with the information provided by Rodolphe, I figured out this solution:

    MyModel.find(query, fields, { skip: 10, limit: 5 }, function(err, results) { ... });

Pagination using mongoose, express and jade - [Here's a link to my blog with more detail](http://madhums.me/2012/08/20/pagination-using-mongoose-express-and-jade/)

    var perPage = 10
      , page = Math.max(0, req.params.page)
    
    Event.find()
        .select('name')
        .limit(perPage)
        .skip(perPage * page)
        .sort({
            name: 'asc'
        })
        .exec(function(err, events) {
            Event.count().exec(function(err, count) {
                res.render('events', {
                    events: events,
                    page: page,
                    pages: count / perPage
                })
            })
        })

You can chain just like that:

    var query = Model.find().sort('mykey', 1).skip(2).limit(5)
    

Execute the query using `exec`

    query.exec(callback);

In this case, you can add the query `page` and/ or `limit` to your URL as a query string.

For example:  
`?page=0&limit=25 // this would be added onto your URL: http:localhost:5000?page=0&limit=25`

Since it would be a `String` we need to convert it to a `Number` for our calculations. Let's do it using the `parseInt` method and let's also provide some default values.

    const pageOptions = {
        page: parseInt(req.query.page, 10) || 0,
        limit: parseInt(req.query.limit, 10) || 10
    }
    
    sexyModel.find()
        .skip(pageOptions.page * pageOptions.limit)
        .limit(pageOptions.limit)
        .exec(function (err, doc) {
            if(err) { res.status(500).json(err); return; };
            res.status(200).json(doc);
        });
    

**BTW** Pagination starts with `0`

How to paginate with mongoose in node js

在Mongoose中，排序可以通过在查询后使用 `.sort()` 方法来实现。该方法接受一个参数，该参数可以是字符串或对象，用于指定根据哪些字段进行排序以及排序的方向（升序或降序）。在MongoDB中，升序使用 `1` 表示，而降序使用 `-1` 表示。

以下是如何使用 `.sort()` 方法的一些例子：

### 使用字符串进行排序

如果您只需要根据一个字段进行排序，可以直接传递一个字段名，前面带有 `-` 表示降序，不带任何符号表示升序。

```javascript
// 升序排序
MyModel.find().sort('field').exec((err, docs) => {
  // 处理结果或错误
});

// 降序排序
MyModel.find().sort('-field').exec((err, docs) => {
  // 处理结果或错误
});
```

### 使用对象进行排序

如果您要根据多个字段进行排序，可以传递一个对象，键是字段名，值是 `1` 或 `-1` 来分别表示升序或降序。

```javascript
// 根据多个字段进行排序
MyModel.find().sort({ field1: 1, field2: -1 }).exec((err, docs) => {
  // 处理结果或错误
});
```

### 示例

假设您有一个用户模型 `User`，并且您想根据年龄进行升序排序，然后根据用户名进行降序排序，您可以这样做：

```javascript
User.find().sort({ age: 1, username: -1 }).exec((err, users) => {
  if (err) {
    console.error(err);
  } else {
    console.log(users); // 这将输出根据年龄升序、用户名降序排序的用户数组
  }
});
```

通过这种方式，您可以轻松地根据一个或多个字段对查询结果进行排序，这在处理大量数据时尤其有用，可以帮助您更快地定位到感兴趣的记录。

In Mongoose, a sort can be done in any of the following ways:

        Post.find({}).sort('test').exec(function(err, docs) { ... });
        Post.find({}).sort([['date', -1]]).exec(function(err, docs) { ... });
        Post.find({}).sort({test: 1}).exec(function(err, docs) { ... });
        Post.find({}, null, {sort: {date: 1}}, function(err, docs) { ... });

This is how I got sort to work in mongoose 2.3.0 :)

    // Find First 10 News Items
    News.find({
        deal_id:deal._id // Search Filters
    },
    ['type','date_added'], // Columns to Return
    {
        skip:0, // Starting Row
        limit:10, // Ending Row
        sort:{
            date_added: -1 //Sort by Date Added DESC
        }
    },
    function(err,allNews){
        socket.emit('news-load', allNews); // Do something with the array of 10 objects
    })

As of Mongoose 3.8.x:

    model.find({ ... }).sort({ field : criteria}).exec(function(err, model){ ... });
    

**Where:**

`criteria` can be `asc`, `desc`, `ascending`, `descending`, `1`, or `-1`

**Note: Use quotation marks or double quote**

use `"asc"`, `"desc"`, `"ascending"`, `"descending"`, `1`, or `-1`

UPDATE:

    Post.find().sort({'updatedAt': -1}).all((posts) => {
      // do something with the array of posts
    });
    

* * *

Try:

    Post.find().sort([['updatedAt', 'descending']]).all((posts) => {
      // do something with the array of posts
    });

**Mongoose v5.x.x**

sort by ascending order

    Post.find({}).sort('field').exec(function(err, docs) { ... });
    Post.find({}).sort({ field: 'asc' }).exec(function(err, docs) { ... });
    Post.find({}).sort({ field: 'ascending' }).exec(function(err, docs) { ... });
    Post.find({}).sort({ field: 1 }).exec(function(err, docs) { ... });
    
    Post.find({}, null, {sort: { field : 'asc' }}), function(err, docs) { ... });
    Post.find({}, null, {sort: { field : 'ascending' }}), function(err, docs) { ... });
    Post.find({}, null, {sort: { field : 1 }}), function(err, docs) { ... });
    

sort by descending order

    Post.find({}).sort('-field').exec(function(err, docs) { ... });
    Post.find({}).sort({ field: 'desc' }).exec(function(err, docs) { ... });
    Post.find({}).sort({ field: 'descending' }).exec(function(err, docs) { ... });
    Post.find({}).sort({ field: -1 }).exec(function(err, docs) { ... });
    
    
    Post.find({}, null, {sort: { field : 'desc' }}), function(err, docs) { ... });
    Post.find({}, null, {sort: { field : 'descending' }}), function(err, docs) { ... });
    Post.find({}, null, {sort: { field : -1 }}), function(err, docs) { ... });
    

For Details: [https://mongoosejs.com/docs/api.html#query\_Query-sort](https://mongoosejs.com/docs/api.html#query_Query-sort)

How to sort in mongoose

要从全局维度完全删除 Node.js，通常需要执行几个步骤，具体步骤会根据您使用的操作系统有所不同。以下是在不同操作系统上卸载 Node.js 的一般指导：

### 在 macOS 上：

1. 如果你是通过 Homebrew 安装的 Node.js，你可以使用以下命令来卸载：
   ```sh
   brew uninstall node
   ```
   
2. 如果是通过包安装器安装，你可以删除 Node.js 的安装目录。通常情况下，Node.js 安装在 `/usr/local/bin/node`，npm 安装在 `/usr/local/bin/npm`。可以使用以下命令删除：
   ```sh
   sudo rm -rf /usr/local/{bin/{node,npm},lib/node_modules/npm,include/node,share/man/man1/node.*}
   ```

3. 然后，清除系统中任何残留的缓存文件或本地配置：
   ```sh
   sudo rm -rf ~/.npm
   sudo rm -rf ~/.node-gyp
   sudo rm -rf /opt/local/bin/node
   sudo rm -rf /opt/local/include/node
   sudo rm -rf /opt/local/lib/node_modules
   ```

4. 您还可以通过查找 ‘node’ 或 ‘npm’ 相关的任何文件来确保所有内容都已删除：
   ```sh
   sudo find / -name node
   sudo find / -name npm
   ```

### 在 Windows 上：

1. 打开 `控制面板` > `程序` > `程序和功能`，然后从列表中选择 Node.js，点击 `卸载`。

2. 删除 Node.js 的安装目录，通常是 `C:\Program Files\nodejs`。

3. 清除系统路径中的 Node.js 相关条目。可以通过编辑环境变量来做到这一点。

4. 清除 npm 缓存：
   ```sh
   npm cache clean --force
   ```

5. 删除用户目录下的 npm 相关文件和目录，例如：
   ```sh
   del /s /q %userprofile%\AppData\Roaming\npm
   del /s /q %userprofile%\AppData\Roaming\npm-cache
   ```

6. 使用文件资源管理器或命令行搜索并删除任何遗留的 Node.js 文件。

### 在 Linux 上：

1. 如果你使用的是像 apt、yum 或 dnf 这样的包管理器，可以使用相应的卸载命令。例如，在基于 Debian 的系统上，可以使用：
   ```sh
   sudo apt-get remove --purge nodejs npm
   ```

2. 删除 Node.js 的安装目录和配置文件：
   ```sh
   sudo rm -rf /usr/local/bin/node
   sudo rm -rf /usr/local/bin/npm
   sudo rm -rf /usr/local/lib/node_modules
   sudo rm -rf /usr/local/include/node
   sudo rm -rf /usr/local/share/man/man1/node.*
   ```

3. 清除 npm 的缓存和本地配置：
   ```sh
   sudo rm -rf ~/.npm
   sudo rm -rf ~/.node-gyp
   ```

4. 查找并删除系统中剩余的 Node.js 文件：
   ```sh
   sudo find / -name node
   sudo find / -name npm
   ```

在执行以上操作后，Node.js 应该已经从您的系统中完全删除。记得在执行某些命令时，特别是那些包含 `rm -rf` 的命令时，要非常小心，因为这些命令可以删除大量文件，而且不可撤销。如果你不确定某个文件或目录是否应该删除，请先进行检查。

How to completely remove node.js from Windows

在Mongoose中，更新文档（通常在 MongoDB 中称为记录）可以通过几种不同的方法来实现。如果你提到的 "upstart" 文档是指需要更新的文档，那么我将展示几种在 Mongoose 中更新文档的常用方法，并提供示例。

### 使用 `save()` 方法更新文档

如果你已经查询到了一个 Mongoose 文档实例，你可以直接修改它的属性，然后调用 `.save()` 方法来更新它。

```javascript
const mongoose = require('mongoose');
const { Schema } = mongoose;

const UserSchema = new Schema({ name: String, age: Number });
const User = mongoose.model('User', UserSchema);

async function updateUser(userId) {
  try {
    // 查询文档
    const user = await User.findById(userId);
    if (user) {
      // 修改文档的属性
      user.name = '新的名字';
      user.age = 30;

      // 保存文档
      await user.save();
      console.log('Document updated successfully');
    } else {
      console.log('Document not found');
    }
  } catch (error) {
    console.error('Error updating document:', error);
  }
}
```

### 使用 `updateOne()` 或 `updateMany()` 方法

如果你不需要先检索整个文档，你可以直接使用 `updateOne()` 或 `updateMany()` 方法来更新一个或多个文档。

```javascript
async function updateUserName(userId, newName) {
  try {
    // 更新单个文档
    const result = await User.updateOne({ _id: userId }, { $set: { name: newName } });
    if (result.matchedCount === 1) {
      console.log('Document updated successfully');
    } else {
      console.log('No documents matched the query. Document not updated');
    }
  } catch (error) {
    console.error('Error updating document:', error);
  }
}
```

### 使用 `findOneAndUpdate()` 方法

如果你想在更新文档的同时检索更新后的文档，你可以使用 `findOneAndUpdate()` 方法。

```javascript
async function findAndUpdateUser(userId, newName) {
  try {
    const options = { new: true }; // 返回更新后的文档
    const updatedUser = await User.findOneAndUpdate({ _id: userId }, { $set: { name: newName } }, options);
    if (updatedUser) {
      console.log('Document updated and retrieved successfully:', updatedUser);
    } else {
      console.log('Document not found');
    }
  } catch (error) {
    console.error('Error finding and updating document:', error);
  }
}
```

在这些示例中，我们使用了 MongoDB 的更新操作符 `$set` 来指定我们希望更新的字段。同时还可以使用其他更新操作符来执行更复杂的更新操作。根据你的需求，你可以选择最适合你的更新策略。

注意：确保在执行更新操作时遵循最佳实践，比如验证输入、处理错误等。

Mongoose now supports this natively with [findOneAndUpdate](https://mongoosejs.com/docs/api.html#model_Model-findOneAndUpdate) (calls MongoDB [findAndModify](https://www.mongodb.com/docs/manual/reference/method/db.collection.findAndModify/)).

The upsert = true option creates the object if it doesn't exist. _defaults to false_.

    var query = {'username': req.user.username};
    req.newData.username = req.user.username;
    
    MyModel.findOneAndUpdate(query, req.newData, {upsert: true}, function(err, doc) {
        if (err) return res.send(500, {error: err});
        return res.send('Succesfully saved.');
    });
    

* * *

In older versions Mongoose does not support these hooks with this method:

*   defaults
*   setters
*   validators
*   middleware

I just burned a solid 3 hours trying to solve the same problem. Specifically, I wanted to "replace" the entire document if it exists, or insert it otherwise. Here's the solution:

    var contact = new Contact({
      phone: request.phone,
      status: request.status
    });
    
    // Convert the Model instance to a simple object using Model's 'toObject' function
    // to prevent weirdness like infinite looping...
    var upsertData = contact.toObject();
    
    // Delete the _id property, otherwise Mongo will return a "Mod on _id not allowed" error
    delete upsertData._id;
    
    // Do the upsert, which works like this: If no Contact document exists with 
    // _id = contact.id, then create a new doc using upsertData.
    // Otherwise, update the existing doc with upsertData
    Contact.update({_id: contact.id}, upsertData, {upsert: true}, function(err{...});
    

I created [an issue on the Mongoose project page](https://github.com/LearnBoost/mongoose/issues/571) requesting that info about this be added to the docs.

You were close with

    Contact.update({phone:request.phone}, contact, {upsert: true}, function(err){...})
    

but your second parameter should be an object with a modification operator for example

    Contact.update({phone:request.phone}, {$set: { phone: request.phone }}, {upsert: true}, function(err){...})

Well, I waited long enough and no answer. Finally gave up the whole update/upsert approach and went with:

    ContactSchema.findOne({phone: request.phone}, function(err, contact) {
        if(!err) {
            if(!contact) {
                contact = new ContactSchema();
                contact.phone = request.phone;
            }
            contact.status = request.status;
            contact.save(function(err) {
                if(!err) {
                    console.log("contact " + contact.phone + " created at " + contact.createdAt + " updated at " + contact.updatedAt);
                }
                else {
                    console.log("Error: could not save contact " + contact.phone);
                }
            });
        }
    });
    

Does it work? Yep. Am I happy with this? Probably not. 2 DB calls instead of one.  
Hopefully a future Mongoose implementation would come up with a `Model.upsert` function.

I'm the maintainer of Mongoose. The more modern way to upsert a doc is to use the [`Model.updateOne()` function](https://mongoosejs.com/docs/api/model.html#model_Model.updateOne).

    await Contact.updateOne({
        phone: request.phone
    }, { status: request.status }, { upsert: true });
    

If you need the upserted doc, you can use [`Model.findOneAndUpdate()`](https://mongoosejs.com/docs/tutorials/findoneandupdate.html)

    const doc = await Contact.findOneAndUpdate({
        phone: request.phone
    }, { status: request.status }, { upsert: true, useFindAndModify: false });
    

The key takeaway is that you need to put the unique properties in the `filter` parameter to `updateOne()` or `findOneAndUpdate()`, and the other properties in the `update` parameter.

Here's a tutorial on [upserting documents with Mongoose](https://masteringjs.io/tutorials/mongoose/upsert).

How do I update/upsert a document in Mongoose?

要清除 `node_modules` 文件夹中没有在 `package.json` 中定义的包，可以使用几种方法。以下是解决这个问题的两种常见方式：

### 使用 `npm prune` 命令

`npm` 提供了一个内置的命令 `prune`，它用于移除 `node_modules` 目录中未在 `package.json` 文件的 `dependencies` 或 `devDependencies` 中声明的包。要使用 `npm prune`，您只需要在项目的根目录下打开终端，并执行以下命令：

```bash
npm prune
```

这条命令会根据当前 `package.json` 文件中定义的依赖项，删除所有不匹配的包。

### 手动清理和重新安装

如果想确保 `node_modules` 文件夹完全反映 `package.json` 文件中指定的依赖关系，您可以先手动删除 `node_modules` 文件夹，然后运行 `npm install` 重新安装所有依赖。以下是这个方法的步骤：

1. 删除 `node_modules` 文件夹：

   ```bash
   rm -rf node_modules
   ```
2. 清理 `npm` 缓存(可选)：

   ```bash
   npm cache clean --force
   ```
3. 使用 `npm install` 重新安装依赖：

   ```bash
   npm install
   ```

这将创建一个新的 `node_modules` 文件夹，其中仅包含 `package.json` 文件中声明的依赖包。

### 实际例子

假设我之前为了测试某些功能，临时安装了一个名为 `example-package` 的包，但后来发现它并不适合我的项目需求，所以我没有将它加入到 `package.json` 中。现在我的 `node_modules` 文件夹里有很多这样的包，我想清理它们。我会这样做：

1. 打开终端并导航到我的项目目录。
2. 运行 `npm prune` 命令。
3. `npm` 会检查 `package.json` 并自动移除所有未列出的包，包括 `example-package`。

这样，`node_modules` 文件夹就只包含了真正需要的依赖，我的项目也就更加整洁、更容易维护。


I think you're looking for `npm prune`

> `npm prune [<name> [<name ...]]`
> 
> This command removes "extraneous" packages. If a package name is provided, then only packages matching one of the supplied names are removed.
> 
> Extraneous packages are packages that are not listed on the parent package's dependencies list.

See the docs: [https://docs.npmjs.com/cli/prune](https://docs.npmjs.com/cli/prune)

You could remove your node\_modules/ folder and then reinstall the dependencies from package.json.

    rm -rf node_modules/
    npm install
    

This would erase all installed packages in the current folder and only install the dependencies from package.json. If the dependencies have been previously installed npm will try to use the cached version, avoiding downloading the dependency a second time.

> Due to its folder nesting Windows can’t delete the folder as its name is too long. To solve this, install RimRaf:

    npm install rimraf -g
    
    rimraf node_modules

From version 6.5.0 `npm` supports the command `clean-install` (`ci`) to hard refresh all the packages.

Please, see the references:

*   `npm` 6.x: [npm-ci | npm Docs](https://docs.npmjs.com/cli/v6/commands/npm-ci).
*   `npm` 7.x: [npm-ci | npm Docs](https://docs.npmjs.com/cli/v7/commands/npm-ci).
*   [npm Blog Archive: Introducing `npm ci` for faster, more reliable builds](https://blog.npmjs.org/post/171556855892/introducing-npm-ci-for-faster-more-reliable).

simple just run

    rm -r node_modules
    

in fact, you can delete any folder with this.

like **rm -r AnyFolderWhichIsNotDeletableFromShiftDeleteOrDelete**.

just open the **gitbash** move to root of the folder and run this command

Hope this will help.

How to clean node_modules folder of packages that are not in package. Json ?

要更新全局安装的npm工具，您可以执行以下步骤：

1. **打开终端或命令提示符**: 这是您将输入命令的地方。

2. **检查是否有更新的工具**: 使用如下命令可以查看全局安装的npm包：
   ```
   npm outdated -g --depth=0
   ```
   这将列出所有已经过时的全局npm包和它们的当前版本、需要更新的版本以及最新版本。

3. **更新特定的npm工具**: 如果您只想更新一个特定的工具，可以使用命令：
   ```
   npm update <工具名> -g
   ```
   其中`<工具名>`是您想要更新的工具的名称。

4. **一次性更新所有全局工具**: 如果您想要更新所有过时的工具，您可以使用命令：
   ```
   npm update -g
   ```
   这会更新所有全局安装的且有新版本可用的npm工具。

5. **强制更新**: 如果因为某些原因`npm update`命令没有更新到最新版本，您可以通过先卸载再安装的方式强制更新。例如：
   ```
   npm uninstall -g <工具名>
   npm install -g <工具名>@latest
   ```
   这样会确保您安装的是该工具的最新版本。

6. **确认更新**: 更新完成后，您可以确认工具是否更新到了最新版本：
   ```
   npm list -g <工具名>
   ```
   或者，如果您想查看所有全局安装的工具及其版本，可以运行：
   ```
   npm list -g --depth=0
   ```

### 示例

假设我们想更新全局安装的`create-react-app`工具。以下是更新流程的步骤：

1. 打开您的命令行工具。

2. 检查是否有可用的更新：
   ```
   npm outdated -g --depth=0
   ```
   这可能会告诉您`create-react-app`的当前版本和最新版本。

3. 更新`create-react-app`到最新版本：
   ```
   npm update create-react-app -g
   ```

4. 确认更新：
   ```
   npm list -g create-react-app
   ```

以上步骤将帮助您保持全局npm工具的最新状态。

Note: The question is specifically asking how to upgrade npm, not Node.js. If you want to update Node.js over a CLI on windows, I recommend running `winget upgrade -q NodeJS` or use [chocolatey](https://community.chocolatey.org/packages/nodejs-lts) for that.

What method should I choose to update NPM?
------------------------------------------

*   Node.js v16 or higher?
    *   `npm install -g npm`
*   Node.js v14 or below?
    *   Consider updating to latest LTS release of Node.js
    *   `npm-windows-upgrade`

### [Upgrade with npm-windows-upgrade](https://github.com/felixrieseberg/npm-windows-upgrade)

Run PowerShell as Administrator

    Set-ExecutionPolicy Unrestricted -Scope CurrentUser -Force
    npm install -g npm-windows-upgrade
    npm-windows-upgrade
    

Note: if you run the Node.js installer, it will replace the Node.js version.

*   Upgrades npm in-place, where Node.js installed it.
*   Does not modify the default path.
*   Does not change the default global package location.
*   Allows easy upgrades and downgrades and to install a specific version.
*   A list of versions matched between NPM and Node.js ([https://nodejs.org/en/download/releases/](https://nodejs.org/en/download/releases/)) - but you will need to download the _Node.js installer_ and run that to update Node.js ([https://nodejs.org/en/](https://nodejs.org/en/))

### Upgrade with npm

    npm install -g npm
    

Note: some users still report issues updating npm with npm, but I haven't had that experience with v16+.

[Download](https://nodejs.org/en/download) and run the latest MSI. The MSI will update your installed node and npm.

To update NPM, this worked for me:

*   Navigate in your shell to your node installation directory, eg `C:\Program Files (x86)\nodejs`
*   run `npm install npm` (no `-g` option)

Like some people, I _needed_ to combine multiple answers, and I also needed to set a proxy.

This _should_ work for anyone. I have zero desire to run an EXE file or MSI file .. uninstall/ reinstall, or manually delete files and folders. That is so 1999 :P

1.  Run this to update NPM:
    
    Run PowerShell as **administrator**
    
        npm i -g npm    // This works
        
    
    I am _not_ thinking this code actually upgrades your npm version below
    
        Set-ExecutionPolicy Unrestricted -Scope CurrentUser -Force
        npm install -g npm-windows-upgrade
        npm-windows-upgrade
        
        (courtesy of "Robert" answer)
        
    

**Run this to update Node.js:**

    wget https://nodejs.org/download/release/latest/win-x64/node.exe -OutFile 'C:\Program Files (x86)\nodejs\node.exe'    (courtesy of BrunoLM answer)
    

If you get \`wget : Could not find a part of the path .... "\*\*, see below ...scroll down. Reading Web Response... It's at least punching through the firewall /proxy (if you have one or have already ran the code get through ...

**_Otherwise_**

**You might need to set your proxy**

    npm config set proxy "http://proxy.yourcorp.com:811"    (yes, use quotes)
    

**2 possible errors**

1.  It cannot find path of the path solution **"where.exe node"** (courtesy of Lonnie Best Answer)
    
    E.g. if Node.js is NOT living in "Program Files (x86)" perhaps with where.exe, it is living in 'C:\\Program Files\\nodejs\\node.exe'.
    
        wget https://nodejs.org/download/release/latest/win-x64/node.exe -OutFile 'C:\Program Files\nodejs\node.exe'
        
    
2.  Now perhaps it tries to upgrade but you get _another_ error, _"node.exe is being used by another process."_
    
    *   Close /shutdown other consoles .. command prompts and PowerShell windows, etc. Even if you're using npm in a command prompt, close it.

npm -v (3.10.8)

node -v ( v6.6.0)

**DONE. I'm at the version that I _want_.**

You can update your npm to the latest stable version with the following command:

     npm install npm@latest -g
    

Use PowerShell to run it. This command doesn't need windows administrator privileges and you can verify the result with `npm -v`

How can I update npm on Windows?

当然，`nvm`（Node Version Manager）是一个用于管理和切换不同Node.js版本的工具。它也允许用户为不同的Node.js版本安装与之兼容的`npm`版本。以下是如何使用`nvm`来更改`npm`版本的步骤：

1. **安装 nvm：**
   首先，您需要确保已经安装了`nvm`。可以通过运行以下命令在Linux或macOS上安装`nvm`：

   ```sh
   curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash
   ```

   或者，如果您使用的是Windows，则可以使用`nvm-windows`：

   ```sh
   nvm install-latest-npm
   ```

2. **列出可用的 Node.js 版本：**
   安装好`nvm`后，您可以查看所有可用的Node.js版本：

   ```sh
   nvm ls-remote
   ```

3. **安装 Node.js：**
   使用`nvm`安装一个特定版本的Node.js。`npm`会与该版本捆绑安装：

   ```sh
   nvm install 14.17.0
   ```

   这将安装Node.js 14.17.0版本和与之兼容的`npm`版本。

4. **切换 Node.js 版本：**
   安装多个版本的Node.js后，可以使用以下命令在它们之间切换：

   ```sh
   nvm use 14.17.0
   ```

   这将切换到Node.js 14.17.0版本和相应的`npm`版本。

5. **升级 npm：**
   如果你想要为当前使用的Node.js版本升级`npm`，可以运行：

   ```sh
   npm install -g npm@latest
   ```

   这将为当前选中的Node.js版本安装最新版本的`npm`。

6. **查看 npm 版本：**
   可以通过运行以下命令来验证`npm`的版本：

   ```sh
   npm --version
   ```

7. **为特定的 Node.js 版本安装特定的 npm 版本：**
   如果需要为特定的Node.js版本安装一个特定版本的`npm`，可以先切换到该Node.js版本，然后指定`npm`版本进行安装：

   ```sh
   nvm use 14.17.0
   npm install -g npm@6.14.13
   ```

   这样，您就可以为Node.js 14.17.0安装npm 6.14.13版本。

以上就是使用`nvm`管理和更改`npm`版本的基本步骤。这使得在不同的项目之间切换开发环境变得非常简单，因为每个项目可能需要不同的Node.js和`npm`版本。

As noted in [another answer](https://stackoverflow.com/a/47519162/56817), there is now a command for this:

> nvm now has a command to update npm. It's `nvm install-latest-npm` or `nvm install --latest-npm`.

`nvm install-latest-npm`: Attempt to upgrade to the latest working `npm` on the current Node.js version.

`nvm install --latest-npm`: After installing, attempt to upgrade to the latest working npm on the given Node.js version.

Below are previous revisions of the correct answer to this question.

For later versions of npm it is much simpler now. Just update the version that nvm installed, which lives in `~/.nvm/versions/node/[your-version]/lib/node_modules/npm`.

I installed Node.js 4.2.2, which comes with npm 2.14.7, but I want to use npm 3. So I did:

    cd ~/.nvm/versions/node/v4.2.2/lib
    npm install npm
    

Easy!

And yes, this should work for any module, not just npm, that you want to be "global" for a specific version of node.

* * *

In a newer version, `npm -g` is smart and installs modules into the path above instead of the system global path.

Use

    npm install npm@x.x.x -g
    npm install npm@5.4.0 -g

nvm doesn't handle npm.

So if you want to install Node.js 0.4.x (which many packages still depend on) and use NPM, you can still use npm 1.0.x.

Install Node.js 0.6.x (which comes with npm 1.1.x) and install nvm with npm:

    npm install nvm
    . ~/nvm/nvm.sh
    

Install Node.js 0.4.x with nvm:

    nvm install v0.4.12
    nvm use v0.4.12
    

Install npm using _install.sh_ (note the `-L` parameter to follow any redirects):

    curl -L https://npmjs.org/install.sh | sh
    

This will detect Node.js 0.4.12 and install npm 1.0.106 in your _~/nvm/v0.4.12/lib/node\_modules_ folder and create a symbolic link for nvm:

    ~/nvm/v0.4.12/bin/npm -> ../lib/node_modules/npm/bin/npm-cli.js
    

If you try to run npm, it will still give an error, but if you do `nvm use v0.4.12` again, it should now work.

nvm now has a command to update npm. It's `nvm install-latest-npm` or `npm install --latest-npm`.

I'm on Windows and I couldn't get any of this stuff to work. I kept getting errors about files being in the way. This worked though:

    cd %APPDATA%\nvm\v8.10.0           # or whatever version you're using
    mv npm npm-old
    mv npm.cmd npm-old.cmd
    cd node_modules\
    mv npm npm-old
    cd npm-old\bin
    node npm-cli.js i -g npm@latest
    
    cd %APPDATA%\nvm\v8.10.0 # or whatever version you're using
    rm npm-old
    rm npm-old.cmd
    cd node_modules\
    rm -rf npm-old
    

And boom, I'm back in business.

`nvm`（Node Version Manager）是一个用于管理和切换不同Node.js版本的工具。它也允许用户为不同的Node.js版本安装与之兼容的 `npm`版本。以下是如何使用 `nvm`来更改 `npm`版本的步骤： 

1. **安装 nvm：**
   首先，您需要确保已经安装了 `nvm`。可以通过运行以下命令在Linux或macOS上安装 `nvm`：

   ```sh
   curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash
   ```

   或者，如果您使用的是Windows，则可以使用 `nvm-windows`：

   ```sh
   nvm install-latest-npm
   ```
2. **列出可用的 Node.js 版本：**
   安装好 `nvm`后，您可以查看所有可用的Node.js版本：

   ```sh
   nvm ls-remote
   ```
3. **安装 Node.js：**
   使用 `nvm`安装一个特定版本的Node.js。`npm`会与该版本捆绑安装：

   ```sh
   nvm install 14.17.0
   ```

   这将安装Node.js 14.17.0版本和与之兼容的 `npm`版本。
4. **切换 Node.js 版本：**
   安装多个版本的Node.js后，可以使用以下命令在它们之间切换：

   ```sh
   nvm use 14.17.0
   ```

   这将切换到Node.js 14.17.0版本和相应的 `npm`版本。
5. **升级 npm：**
   如果你想要为当前使用的Node.js版本升级 `npm`，可以运行：

   ```sh
   npm install -g npm@latest
   ```

   这将为当前选中的Node.js版本安装最新版本的 `npm`。
6. **查看 npm 版本：**
   可以通过运行以下命令来验证 `npm`的版本：

   ```sh
   npm --version
   ```
7. **为特定的 Node.js 版本安装特定的 npm 版本：**
   如果需要为特定的Node.js版本安装一个特定版本的 `npm`，可以先切换到该Node.js版本，然后指定 `npm`版本进行安装：

   ```sh
   nvm use 14.17.0
   npm install -g npm@6.14.13
   ```

   这样，您就可以为Node.js 14.17.0安装npm 6.14.13版本。

以上就是使用 `nvm`管理和更改 `npm`版本的基本步骤。这使得在不同的项目之间切换开发环境变得非常简单，因为每个项目可能需要不同的Node.js和 `npm`版本。

How can I change the version of npm using nvm?

`npm install`和`npm ci`是Node.js生态系统中常用的两个命令，它们都用于安装依赖项，但是它们的工作方式和用途略有不同：

1. **npm install**:
   - **用途**：`npm install`是最常用的命令之一，用于安装依赖项。它根据`package.json`文件中列出的依赖项来安装模块，并且可以更新`package-lock.json`文件。
   - **行为**：`npm install`会根据`package.json`或`npm-shrinkwrap.json`中定义的依赖版本范围来查找并安装最新版本的依赖。如果`package-lock.json`存在，它也会考虑这个文件，但是它允许根据`package.json`中指定的语义版本控制规则更新依赖项。
   - **例子**：如果你的`package.json`文件指定了某个包的版本为`^1.0.0`，这意味着运行`npm install`时可以安装这个包的任何`1.x.x`版本，只要这个版本是最新的并且满足`package.json`中的约束。

2. **npm ci**:
   - **用途**：`npm ci`（ci代表Continous Integration持续集成）主要用在自动化环境中，比如测试平台、持续集成和部署流程。这个命令需要在存在`package-lock.json`或`npm-shrinkwrap.json`文件的情况下运行。
   - **行为**：`npm ci`会忽略`package.json`中的依赖项版本，而是严格根据`package-lock.json`或`npm-shrinkwrap.json`文件来安装依赖项的特定版本。这确保了在不同环境和开发人员之间的一致性。
   - **速度**：`npm ci`通常比`npm install`更快，因为它跳过了某些面向用户的功能，如更新`package-lock.json`文件或安装新版本的包。
   - **例子**：如果你将项目的代码库和`package-lock.json`文件一起部署到持续集成服务器上，运行`npm ci`将确保服务器上安装的依赖项与你在本地开发环境中使用的完全相同。

总之，如果你希望在本地开发环境中安装或更新依赖项，通常会使用`npm install`。而如果你在自动化环境中，需要一个可重复的、确定的依赖项安装过程，就会使用`npm ci`。

From [the official documentation for npm ci](https://docs.npmjs.com/cli/ci):

> In short, the main differences between using npm install and npm ci are:
> 
> *   The project must have an existing package-lock.json or npm-shrinkwrap.json.
> *   If dependencies in the package lock do not match those in package.json, npm ci will exit with an error, instead of updating the package lock.
> *   npm ci can only install entire projects at a time: individual dependencies cannot be added with this command.
> *   If a node\_modules is already present, it will be automatically removed before npm ci begins its install.
> *   It will never write to package.json or any of the package-locks: installs are essentially frozen.

* * *

Essentially, **`npm install`** reads `package.json` to create a list of dependencies and uses `package-lock.json` to inform which versions of these dependencies to install. **If a dependency is not in `package-lock.json` it will be added by `npm install`**.

**`npm ci`** (also known as **C**lean **I**nstall) is meant to be used in automated environments — such as test platforms, continuous integration, and deployment — or, any situation where you want to make sure you're doing a clean install of your dependencies.

It installs dependencies directly from `package-lock.json` and uses `package.json` only to validate that there are no mismatched versions. **If any dependencies are missing or have incompatible versions, it will throw an error**.

Use `npm install` to add new dependencies, and to update dependencies on a project. Usually, you would use it during development after pulling changes that update the list of dependencies but it may be a good idea to use `npm ci` in this case.

Use `npm ci` if you need a deterministic, repeatable build. For example during continuous integration, automated jobs, etc. and when installing dependencies for the first time, instead of `npm install`.

[`npm install`](https://docs.npmjs.com/cli/install.html)
--------------------------------------------------------

*   Installs a package and all its dependencies.
*   Dependencies are driven by `npm-shrinkwrap.json` and `package-lock.json` (in that order).
*   **without arguments**: installs dependencies of a local module.
*   Can install global packages.
*   Will install any missing dependencies in `node_modules`.
*   It may write to `package.json` or `package-lock.json`.
    *   When used with an argument (`npm i packagename`) it may write to `package.json` to add or update the dependency.
    *   when used without arguments, (`npm i`) it may write to `package-lock.json` to lock down the version of some dependencies if they are not already in this file.

[`npm ci`](https://docs.npmjs.com/cli/ci)
-----------------------------------------

*   Requires at least npm [v5.7.1](https://github.com/npm/npm/releases/tag/v5.7.1).
*   Requires `package-lock.json` or `npm-shrinkwrap.json` to be present.
*   Throws an error if dependencies from these two files don't match `package.json`.
*   Removes `node_modules` and install _all dependencies_ at once.
*   It never writes to `package.json` or `package-lock.json`.

Algorithm
---------

While `npm ci` generates the entire dependency tree from `package-lock.json` or `npm-shrinkwrap.json`, `npm install` _updates the contents of `node_modules`_ using the following algorithm ([source](https://docs.npmjs.com/cli/install#algorithm)):

>     load the existing node_modules tree from disk
>     clone the tree
>     fetch the package.json and assorted metadata and add it to the clone
>     walk the clone and add any missing dependencies
>       dependencies will be added as close to the top as is possible
>       without breaking any other modules
>     compare the original tree with the cloned tree and make a list of
>     actions to take to convert one to the other
>     execute all of the actions, deepest first
>       kinds of actions are install, update, remove and move
>

`npm ci` will delete any existing `node_modules` folder and relies on the `package-lock.json` file to install the specific version of each package. It is significantly faster than npm install because it skips some features. Its clean state install is great for ci/cd pipelines and docker builds! You also use it to install everything all at once and not specific packages.

While everyone else has answered the technical differences none explain in what situations to use both.
-------------------------------------------------------------------------------------------------------

You should use them in different situations.

`npm install` is great for development and in the CI when you want to cache the `node_modules` directory. When to use this? You can do this if you are making a package for other people to use _(you do NOT include `node_modules` in such a release)_. Regarding the caching, be careful, if you plan to support different versions of `Node.js` remember that `node_modules` might have to be reinstalled due to differences between the `Node.js` runtime requirements. If you wish to stick to one version, stick to the latest `LTS`.

`npm ci` should be used when you are to test and release a production application (a final product, not to be used by other packages) since it is important that you have the installation be as deterministic as possible, this install will take longer but will ultimately make your application more reliable _(you do include `node_modules` in such a release)_. Stick with `LTS` version of `Node.js`.

`npm i` and `npm ci` both utilize the npm cache if it exists, this cache lives normally at `~/.npm`.

Also, `npm ci` respects the `package-lock.json` file. Unlike `npm install`, which rewrites the file and always installs new versions.

_Bonus: You could mix them depending on how complex you want to make it. On feature branches in `git` you could cache the `node_modules` to increase your teams productivity and on the merge request and master branches rely on `npm ci` for a deterministic outcome._

*   `npm ci` - install exactly what is listed in package-lock.json
*   `npm install` - without changing any versions in package.json, use package.json to write package-lock.json, then install exactly what is listed in package-lock.json
*   `npm update` - similar to `npm install` but will also install updates for "blurred version" stuff (e.g. `*`, `^1.2.3`)
*   `npx npm-check-updates -u; npm install` - Will try to update absolutely everything to the latest version. Be careful of breaking changes when using this one.

Or said a different way, `npm ci` changes 0 package files, `npm install` and `npm update` change 1 package file (package-lock.json), and `npx npm-check-updates -u; npm install` changes 2 package files (package.json and package-lock.json).

The documentation you linked had the summary:

> In short, the main differences between using npm install and npm ci are:
> 
> *   The project must have an existing package-lock.json or npm-shrinkwrap.json.
> *   If dependencies in the package lock do not match those in package.json, npm ci will exit with an error, instead of updating the package lock.
> *   npm ci can only install entire projects at a time: individual dependencies cannot be added with this command.
> *   If a node\_modules is already present, it will be automatically removed before npm ci begins its install.
> *   It will never write to package.json or any of the package-locks: installs are essentially frozen.

What is the difference between npm install and npm ci

在`package.json`中，您通常不会直接设置环境变量，因为这个文件主要是用来定义项目的依赖、脚本和配置信息。然而，您可以在`package.json`的`scripts`部分定义脚本命令，在执行这些命令时设置环境变量。

例如，如果您使用的是Unix-like系统（如Linux或MacOS），可以使用`export`命令设置环境变量，然后执行其他命令。如果您在Windows上，则可能需要使用`set`命令，或者使用跨平台的解决方案，比如`cross-env`。

下面是一个如何在`scripts`部分设置环境变量的例子：

```json
{
  "name": "your-package",
  "version": "1.0.0",
  "scripts": {
    "start": "export NODE_ENV=production && node app.js",
    "start:windows": "set NODE_ENV=production && node app.js"
  }
}
```

在上面的例子中，我们在`start`脚本中设置了`NODE_ENV`环境变量为`production`，然后执行了`node app.js`。

使用`cross-env`，您可以写一个跨平台的脚本命令：

```json
{
  "name": "your-package",
  "version": "1.0.0",
  "scripts": {
    "start": "cross-env NODE_ENV=production node app.js"
  },
  "devDependencies": {
    "cross-env": "^7.0.3"
  }
}
```

在这个例子中，不管您在什么操作系统上，`start`脚本都会设置`NODE_ENV`环境变量为`production`，然后运行`node app.js`。注意，您需要先安装`cross-env`作为开发依赖（使用命令`npm install --save-dev cross-env`）。

这种方式是非常灵活的，允许您在不同的环境（开发、测试、生产等）中运行不同的命令。记住，这里设置的环境变量只会在脚本运行时存在，脚本执行完毕后，这些环境变量不会影响到其他的shell进程。

Set the environment variable in the script command:

    ...
    "scripts": {
      "start": "node app.js",
      "test": "NODE_ENV=test mocha --reporter spec"
    },
    ...
    

Then use `process.env.NODE_ENV` in your app.

Note: This is for _Mac & Linux only_. For Windows refer to the comments.

Just use NPM package [cross-env](https://www.npmjs.com/package/cross-env). Super easy. Works on Windows, Linux, and all environments. Notice that you don't use && to move to the next task. You just set the env and then start the next task. Credit to [@mikekidder](https://stackoverflow.com/users/2130585/mikekidder) for the suggestion in [one of the comments](https://stackoverflow.com/questions/25112510/how-to-set-environment-variables-from-within-package-json-node-js#comment57929242_27090755) here.

From documentation:

    {
      "scripts": {
        "build": "cross-env NODE_ENV=production OTHERFLAG=myValue webpack --config build/webpack.config.js"
      }
    }
    

Notice that if you want to set multiple global vars, you just state them in succession, followed by your command to be executed.

Ultimately, the command that is executed (using spawn) is:

    webpack --config build/webpack.config.js
    

The `NODE_ENV` environment variable will be set by cross-env

Because I often find myself working with multiple environment variables, I find it useful to keep them in a separate `.env` file (make sure to ignore this from your source control). Then (in Linux) prepend `export $(cat .env | xargs) &&` in your script command before starting your app.

Example `.env` file:

    VAR_A=Hello World
    VAR_B=format the .env file like this with new vars separated by a line break
    

Example `index.js`:

    console.log('Test', process.env.VAR_A, process.env.VAR_B);
    

Example `package.json`:

    {
      ...
      "scripts": {
        "start": "node index.js",
    
        "env-linux": "export $(cat .env | xargs) && env",
        "start-linux": "export $(cat .env | xargs) && npm start",
    
        "env-windows": "(for /F \"tokens=*\" %i in (.env) do set %i)",
        "start-windows": "(for /F \"tokens=*\" %i in (.env) do set %i) && npm start",
    
      }
      ...
    }
    

Unfortunately I can't seem to set the environment variables by calling a script from a script -- like `"start-windows": "npm run env-windows && npm start"` -- so there is some redundancy in the scripts.

For a test you can see the env variables by running `npm run env-linux` or `npm run env-windows`, and test that they make it into your app by running `npm run start-linux` or `npm run start-windows`.

I just wanted to add my two cents here for future Node-explorers. On my Ubuntu 14.04 the `NODE_ENV=test` didn't work, I had to use `export NODE_ENV=test` after which `NODE_ENV=test` started working too, weird.

On Windows as have been said you have to use `set NODE_ENV=test` but for a cross-platform solution the cross-env library didn't seem to do the trick and do you really need a library to do this:

    export NODE_ENV=test || set NODE_ENV=test&& yadda yadda
    

The vertical bars are needed as otherwise Windows would crash on the unrecognized `export NODE_ENV` command. I don't know about the trailing space, but just to be sure I removed them too.

Try this on Windows by replacing `YOURENV`:

      {
        ...
         "scripts": {
           "help": "set NODE_ENV=YOURENV && tagove help",
           "start": "set NODE_ENV=YOURENV && tagove start"
         }
        ...
      }

How to set environment variables from within package.json ?

要列出用户在其本地环境中成功安装的 npm 软件包，您可以执行以下步骤：

1. 打开命令行界面。
2. 使用 `cd` 命令导航到项目的根目录，这样可以确保您查看的是特定项目的依赖项。如果您想查看全局安装的软件包，则可以跳过这一步。
3. 运行以下命令：

   - 查看项目的本地安装的软件包：
     ```sh
     npm list
     ```
   - 查看全局安装的软件包：
     ```sh
     npm list -g --depth=0
     ```
   这个命令会列出全局安装的顶级（也就是说不包括它们的依赖）软件包。`--depth=0` 参数确保只列出顶级包，而不是它们所有的依赖项。

4. 命令执行后，终端会输出一个树形结构，显示所有已安装的软件包及其版本号。

例如，如果您运行 `npm list` 在一个包含 `express` 和 `lodash` 的项目中，输出可能看起来像这样：

```plaintext
project-name@1.0.0 /path/to/project-name
├── express@4.17.1
└── lodash@4.17.20
```

这表明您的项目成功安装了 `express` v4.17.1 和 `lodash` v4.17.20。

还有一些其他的参数可以用来自定义输出内容，例如：

- `--prod` 只显示生产环境的依赖。
- `--dev` 只显示开发环境的依赖。
- `--json` 以 JSON 格式输出结果。

这些命令和参数可以帮助任何使用 npm 的开发者快速查看已安装的软件包信息。

npm list -g --depth=0
    

*   **npm**: the Node.js package manager command line tool
*   **list -g**: display a tree of every package found in the user’s folders (without the `-g` option it only shows the current directory’s packages)
*   **\--depth 0 / --depth=0**: avoid including every package’s dependencies in the tree view

You can get a list of all globally installed modules using:

    ls `npm root -g`

**As of 13 December 2015**

[![npm list illustration](https://i.stack.imgur.com/VQVGv.gif)](https://i.stack.imgur.com/VQVGv.gif)

_While I found the accepted answer 100% correct, and useful, I wished to expand upon it a little based on my own experiences, and hopefully for the benefit of others too. (Here I am using the terms package and module interchangeably)_

In an answer to the question, yes the accepted answer would be:

    npm list -g --depth=0
    

You might wish to check for a particular module installed globally, on Unix-like systems or when [grep](https://en.wikipedia.org/wiki/Grep) is available. This is particularly useful when checking what version of a module you are using (globally installed; just remove the `-g` flag if checking a local module):

    npm list -g --depth=0 | grep <module_name>
    

If you'd like to see all available (remote) versions for a particular module, then do:

    npm view <module_name> versions
    

Note, _versions_ is plural. This will give you the full listing of versions to choose from.

For the latest remote version:

    npm view <module_name> version
    

Note, _version_ is singular.

To find out which packages need to be updated, you can use:

    npm outdated -g --depth=0
    

To update global packages, you can use

    npm update -g <package>
    

To update all global packages, you can use:

    npm update -g
    

(However, for npm versions less than 2.6.1, please also see [this link](https://docs.npmjs.com/getting-started/updating-global-packages) as there is a special script that is recommended for globally updating all packages.)

The above commands should work across NPM versions 1.3.x, 1.4.x, 2.x and 3.x.

List NPM packages with some friendly GUI!
-----------------------------------------

This is what I personally prefer and it may be for others too, it may also help during presentations or meetings.

With `npm-gui` you can list local and global packages with a better visualization.

You can find the package at

*   _[npm-gui](https://www.npmjs.com/package/npm-gui)_ (npm)
*   _[npm-gui](https://github.com/q-nick/npm-gui)_ (GitHub)

Run the following

    // Once
    npm install -g npm-gui
    
    cd c:\your-prject-folder
    npm-gui localhost:9000
    

Then open your browser at `http:\\localhost:9000`

[![npm-gui](https://i.stack.imgur.com/WAd0c.png)](https://i.stack.imgur.com/WAd0c.png)

For project dependencies use:

    npm list --depth=0
    

For global dependencies use:

    npm list -g --depth=0

所有问题