Elasticsearch 中的 `connect` 与 `createConnection` 并非是 Elasticsearch 官方提供的 API 或函数，这两个词可能是在特定的上下文或库中使用的，比如说某些客户端库可能会提供这样的方法来管理与 Elasticsearch 集群的连接。

假设您提到的是某个特定的 Elasticsearch 客户端库，那么通常：

- `connect` 方法可能用于建立与 Elasticsearch 集群的连接。它可能是一个简便方法，用于连接到集群并确认连接是活跃的。这个方法可能不需要太多参数，或者它可能会使用一些默认的配置。

- `createConnection` 方法可能更加灵活，允许开发者指定更多的配置选项，比如连接的地址、端口、使用的协议、认证信息等。`createConnection` 方法可能会返回一个连接实例，该实例可以用于后续的操作和查询。

举个例子，如果我们使用的是 Node.js 的 Elasticsearch 客户端，我们可能会这样使用这两个方法（以伪代码为例）：

```javascript
// 假设这是一个假想的Elasticsearch客户端库
const esClient = require('elasticsearch-client');

// 使用connect方法简单地连接到Elasticsearch集群
esClient.connect('http://localhost:9200');

// 使用createConnection创建一个带有详细配置的连接
const connection = esClient.createConnection({
  host: 'http://localhost:9200',
  log: 'trace',
  auth: {
    username: 'user',
    password: 'pass'
  }
});
```

在实际的 Elasticsearch 客户端中，例如官方提供的 `elasticsearch.js` 或者新的 `@elastic/elasticsearch`，您通常直接在客户端实例化时传递配置参数，而不会有单独的 `connect` 或 `createConnection` 方法。如下所示：

```javascript
const { Client } = require('@elastic/elasticsearch');

const client = new Client({
  node: 'http://localhost:9200',
  auth: {
    username: 'user',
    password: 'pass'
  }
});
```

在上面的官方客户端代码示例中，您只需创建一个 `Client` 实例，并通过构造函数传递配置参数来连接 Elasticsearch 集群。

因此，为了提供准确的答案，我需要知道具体是哪个客户端库或应用程序中的 `connect` 和 `createConnection`。如果你能提供更多的上下文或详细信息，我将能够给出更加具体的答案。

> 我对官方文档的理解是，通常当只有一个连接时使用 mongoose.connect() ，而如果有多个连接实例则使用 mongoose.createConnection() 。

是的。确切地说，`.connect()`实际上创建了一个保持打开状态的套接字/连接池（在`poolSize`连接设置中定义，默认值为 5），因此实际上有多个连接，但在单个池中。话虽如此，如果您想要多个具有不同属性的连接池，您应该使用`createConnection`

> 另外，如果我的理解是正确的，那么在单连接中使用 mongoose.createConnection() 有什么缺点？为什么不建议我们在每种情况下都使用 mongoose.createConnection() 来标准化连接？

[这是一个很好的问题，文档](https://mongoosejs.com/docs/connections.html#multiple_connections)中也已经有答案：

> > 当您调用 mongoose.connect() 时，Mongoose 会创建一个默认连接。您可以使用 mongoose.connection 访问默认连接。

基本上`.connect`是一组（大部分）最佳实践设置的简写`createConnection`

在大多数简单的项目中，您不必担心指定不同的读取或写入设置、池大小、与不同副本服务器的单独连接等，这就是`.connect`存在的原因。

但是，如果您有更苛刻的要求（例如出于法律或性能原因），您可能必须使用`createConnection`.

几周前，我遇到了一种情况，我的一个（内部）统计包需要零星但大负载的数据库访问。由于我不想将 db/mongoose 对象传递给包以使其尽可能模块化，因此我只是创建了一个新连接。这非常有效，因为我只需要访问我在包中定义的某个模型，而不是我的“父”包中定义的模型。由于新包只需要读取访问，并且可以从不同的从属/副本数据库读取以减少主数据库的负载，因此我切换到两端的 createConnection 以将连接与主数据库分开。

对我来说，在同一模块中创建多个连接的一大缺点是，如果模型是在不同的连接中定义的，则您无法通过 直接访问模型`mongoose.model`。该答案详细说明了该问题：[https://stackoverflow.com/a/22838614/2856218](https://stackoverflow.com/a/22838614/2856218)

What is the diffence between connect and createconnection in elasticsearch?

在CSS中，`display`属性非常重要，它决定了一个元素如何在页面上显示和布局。以下是 `display`属性的一些常用值及其作用：

1. `none`:

   - 作用：完全隐藏元素，并且不为该元素保留空间。
   - 例子：当您希望在某些条件下不显示一些元素，比如用JavaScript动态隐藏或显示内容。
2. `block`:

   - 作用：使元素表现为块级元素，占据一行的全部宽度，之后的元素会在新的一行显示。
   - 例子：用于布局时，如创建一个自包含的内容区块，例如段落、标题和容器等。
3. `inline`:

   - 作用：使元素在行内显示，不会独占一行，元素的宽度仅由内容决定。
   - 例子：用于格式化文本，如 `<span>`或 `<a>`元素，让它们在段落中内联显示。
4. `inline-block`:

   - 作用：结合了 `inline`和 `block`的特点，不会独占一行，但是可以设置宽度和高度。
   - 例子：当你需要在一行中显示多个块，并且控制它们的大小时，如导航菜单的每个项。
5. `flex`:

   - 作用：使元素成为一个flex容器，其子元素可以使用flex布局的强大特性。
   - 例子：用于创建一个响应式的布局，其中子元素的大小和顺序可以灵活调整。
6. `grid`:

   - 作用：使元素成为一个grid容器，可以定义行和列，创建复杂的二维布局。
   - 例子：用于设计复杂的页面布局，如杂志或报纸式的布局。
7. `table`、`table-row`、`table-cell`等：

   - 作用：这些值模仿了HTML表格标签的行为，允许以表格格式布局页面内容。
   - 例子：当你想用CSS的方式呈现表格数据时，可以选择这些值。
8. `list-item`:

   - 作用：使元素表现为列表项，通常与列表标记一起显示。
   - 例子：用于定制列表的外观，如自定义列表项目符号或项目布局。

这些是 `display`属性中一些常用的值。此外，还有许多其他值和属性组合可以用来实现特定的布局需求。随着Web技术的发展，CSS规范也在不断增加新的显示类型以应对更复杂的设计挑战。继续解释更多的 `display` 属性的值：

9. `inline-flex`:

   - 作用：使元素成为一个行内级的flex容器，这意味着元素可以像 `inline`元素一样在文本行中布局，同时其内部的子元素可以使用flexbox模型。
   - 例子：如果你想要一个小的布局单元能够在文本行中布局，同时又想在这个小单元内部使用flexbox布局，比如在一个段落中的小卡片。
10. `inline-grid`:

    - 作用：使元素成为一个行内级的grid容器，结合了 `inline`和 `grid`的特性。
    - 例子：当你需要在文本流中嵌入一个小的网格布局时使用，例如一个复杂的数学公式或图表。
11. `contents`:

    - 作用：使元素的子元素看起来像是直接放置在其父元素所在的位置，父元素本身不会被渲染成任何盒模型，但是其子元素会正常显示。
    - 例子：当你需要一个容器仅用于语义组织，而不希望它在布局中创建一个新层级时使用。
12. `run-in`:

    - 作用：根据上下文，元素可能表现为 `block`或 `inline`元素。
    - 例子：这个值比较少见，某些情况下可以用于标题和段落之间的布局。
13. `flex-start`、`flex-end`、`center`、`space-between`、`space-around`、`space-evenly`:

    - 作用：这些值多用于flex容器的 `align-items`、`align-content`、`justify-content`等属性，而不是 `display`属性，用来定义flex项目在主轴或交叉轴上的对齐方式。
    - 例子：当你需要在一个flex容器内对齐或分散排列子项时使用。
14. `grid-auto-columns`、`grid-auto-rows`:

    - 作用：这些值用于 `grid`容器上，定义网格中隐式创建的行或列的大小。
    - 例子：当你有一个动态数量的网格项，并且需要自动的行或列大小时。
15. `grid-template-columns`、`grid-template-rows`:

    - 作用：这些值用于 `grid`容器上，定义显式创建的行或列的大小和数量。
    - 例子：当你在设计一个明确的网格布局，需要指定每一列或行的大小。
16. `grid-column-start`、`grid-column-end`、`grid-row-start`、`grid-row-end`:

    - 作用：这些值用于 `grid`项上，定义它们在网格中的位置和跨越的列或行数。
    - 例子：当你需要在网格中放置一个元素，占据多列或多行时。

CSS的 `display`属性是个非常复杂且强大的工具，能够应对各种各样的布局需求。随着CSS规范的不断发展，新的 `display`值和布局模型如Flexbox和Grid提供了前所未有的灵活性和控制力。


使用文件加载器模块请求资源是 webpack 的使用方式（[source](https://github.com/webpack/webpack/issues/395)）。但是，如果您需要更大的灵活性或想要更清晰的界面，您也可以使用我的`copy-webpack-plugin`（[npm](https://www.npmjs.com/package/copy-webpack-plugin)、[Github](https://github.com/kevlened/copy-webpack-plugin)）直接复制静态文件。以你`static`为例`build`：

    const CopyWebpackPlugin = require('copy-webpack-plugin');
     
    module.exports = {
        context: path.join(__dirname, 'your-app'),
        plugins: [
            new CopyWebpackPlugin({
                patterns: [
                    { from: 'static' }
                ]
            })
        ]
    };
    

* * *

_兼容性说明：_如果您使用的是旧版本的 webpack，例如`webpack@4.x.x`，请使用`copy-webpack-plugin@6.x.x`. 否则使用最新的。

你不需要复制东西，webpack 的工作方式与 gulp 不同。Webpack 是一个模块捆绑器，您在文件中引用的所有内容都将包含在内。您只需要为此指定一个加载程序。

所以如果你写：

    var myImage = require("./static/myImage.jpg");
    

Webpack 首先尝试将引用的文件解析为 JavaScript（因为这是默认的）。当然，那会失败。这就是为什么您需要为该文件类型指定一个加载器。[例如，文件](https://github.com/webpack/file-loader)或url [\-loader](https://github.com/webpack/url-loader)获取引用的文件，将其放入 webpack 的输出文件夹（应该`build`在您的情况下）并返回该文件的哈希 url。

    var myImage = require("./static/myImage.jpg");
    console.log(myImage); // '/build/12as7f9asfasgasg.jpg'
    

通常加载器是通过 webpack 配置应用的：

    // webpack.config.js
    
    module.exports = {
        ...
        module: {
            loaders: [
                { test: /\.(jpe?g|gif|png|svg|woff|ttf|wav|mp3)$/, loader: "file" }
            ]
        }
    };
    

当然，您需要先安装文件加载器才能使其工作。

如果您想复制静态文件，可以通过以下方式使用文件加载器：

对于 html 文件：

在 webpack.config.js 中：

    module.exports = {
        ...
        module: {
            loaders: [
                { test: /\.(html)$/,
                  loader: "file?name=[path][name].[ext]&context=./app/static"
                }
            ]
        }
    };
    

在你的 js 文件中：

      require.context("./static/", true, /^\.\/.*\.html/);
    

./static/ 是相对于你的js文件所在的位置。

您可以对图像或其他内容执行相同的操作。上下文是一种强有力的探索方法！

前面提到的**copy-webpack-plugin**带来的一个之前没有解释过的优点是，这里提到的所有其他方法仍然将资源捆绑到你的捆绑文件中（并要求你在某个地方“需要”或“导入”它们）。如果我只想移动一些图像或一些模板部分，我不想用对它们的无用引用来弄乱我的 javascript 捆绑文件，我只希望在正确的位置发出文件。我还没有找到任何其他方法可以在 webpack 中执行此操作。诚然，这不是 webpack 最初设计的目的，但它绝对是当前的用例。（@BreakDS 我希望这能回答你的问题 - 如果你想要的话，这只是一个好处）

Webpack 5 添加了[资产模块](https://webpack.js.org/guides/asset-modules/)，这些模块本质上是常见文件加载器的替代品。我复制了以下文档的相关部分：

> *   `asset/resource`发出一个单独的文件并导出 URL。以前可以通过使用`file-loader`.
> *   `asset/inline`导出资产的数据 URI。以前可以通过使用`url-loader`.
> *   `asset/source`导出资产的源代码。以前可以通过使用`raw-loader`.
> *   `asset`自动选择导出数据 URI 和发出单独的文件。以前可以通过使用`url-loader`资产规模限制来实现。

要添加一个，您可以使您的配置如下所示：

    // webpack.config.js
    
    module.exports = {
        ...
        module: {
            rules: [
                {
                    test: /\.(jpe?g|gif|png|svg|woff|ttf|wav|mp3)$/,
                    type: "asset/resource"
                }
            ]
        }
    };
    

要控制文件的输出方式，您可以使用[模板化路径](https://webpack.js.org/configuration/output/#template-strings)。

在配置中，您可以在此处设置全局模板：

    // webpack.config.js
    module.exports = {
        ...
        output: {
            ...
            assetModuleFilename: '[path][name].[hash][ext][query]'
        }
    }
    

要覆盖一组特定的资产，您可以执行以下操作：

    // webpack.config.js
    
    module.exports = {
        ...
        module: {
            rules: [
                {
                    test: /\.(jpe?g|gif|png|svg|woff|ttf|wav|mp3)$/,
                    type: "asset/resource"
                    generator: {
                        filename: '[path][name].[hash][ext][query]'
                    }
                }
            ]
        }
    };
    

提供的模板将生成类似于`build/images/img.151cfcfa1bd74779aadb.png`. 哈希对于缓存清除等很有用。您应该根据您的需要进行修改。

How to copy static files to build directory with webpack

在Mongoose中，验证电子邮件格式通常是通过在Schema定义中使用正则表达式来完成的。Mongoose提供了一个名为`validate`的功能，它可以接受一个验证函数或者正则表达式以及一个错误消息。

以下是一个如何在Mongoose中定义一个简单的用户模型，并对电子邮件字段进行格式验证的例子：

```js
const mongoose = require('mongoose');
const Schema = mongoose.Schema;

// 定义正则表达式来验证电子邮件格式
const emailRegex = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;

// 创建一个新的用户模式
const userSchema = new Schema({
  email: {
    type: String,
    required: true,
    unique: true,
    // 使用正则表达式进行验证
    validate: {
      validator: function(email) {
        return emailRegex.test(email);
      },
      // 如果验证失败，Mongoose将使用此消息
      message: props => `${props.value} is not a valid email address!`
    }
  },
  // 其他字段定义...
});

// 创建模型
const User = mongoose.model('User', userSchema);

// 使用模型创建一个新用户实例
const user = new User({
  email: 'example@domain.com',
  // 其他字段值...
});

// 保存用户并处理可能出现的验证错误
user.save(function(err) {
  if (err) {
    // 如果电子邮件格式不正确，将会有一个验证错误
    console.error('Error occurred:', err.message);
  } else {
    console.log('User saved successfully!');
  }
});
```

在这个例子中，`emailRegex` 定义了电子邮件的验证规则，通过 `userSchema` 中的 `validate` 选项应用。如果提供的电子邮件不符合正则表达式的规则，Mongoose 会在尝试保存用户时抛出一个错误，并附带我们定义的错误消息。

需要注意的是，这个正则表达式只是一个基本的电子邮件验证规则，电子邮件地址的实际规则更为复杂，这个正则表达式不能覆盖所有有效的电子邮件地址格式。在实际应用中，可能需要使用更复杂的正则表达式或第三方库来更准确地验证电子邮件地址。

您还可以使用**match**或**validate**属性在模式中进行验证

例子

    var validateEmail = function(email) {
        var re = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
        return re.test(email)
    };
    
    var EmailSchema = new Schema({
        email: {
            type: String,
            trim: true,
            lowercase: true,
            unique: true,
            required: 'Email address is required',
            validate: [validateEmail, 'Please fill a valid email address'],
            match: [/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/, 'Please fill a valid email address']
        }
    });

我使用[验证器](https://github.com/chriso/validator.js)来进行输入清理，它的使用方式非常酷。

安装它，然后像这样使用它：

    import { isEmail } from 'validator';
    // ... 
    
    const EmailSchema = new Schema({
        email: { 
            //... other setup
            validate: [ isEmail, 'invalid email' ]
        }
    });
    

工作起来很享受，而且读起来也很好。

您可以使用正则表达式。看看这个问题：[Validate email address in JavaScript?](https://stackoverflow.com/questions/46155/validate-email-address-in-javascript)

我过去用过这个。

    UserSchema.path('email').validate(function (email) {
       var emailRegex = /^([\w-\.]+@([\w-]+\.)+[\w-]{2,4})?$/;
       return emailRegex.test(email.text); // Assuming email has a text attribute
    }, 'The e-mail field cannot be empty.')

验证[器](https://www.npmjs.com/package/validator) 不能很好地与猫鼬一起摆脱警告设置 isAsync 为 false

    const validator = require('validator');
    
    email:{
    type:String,
    validate:{
          validator: validator.isEmail,
          message: '{VALUE} is not a valid email',
          isAsync: false
        }
    }

我知道这已经很旧了，但我没有看到这个解决方案，所以我想分享一下：

    const schema = new mongoose.Schema({
        email: {
            type: String,
            trim: true,
            lowercase: true,
            unique: true,
            validate: {
                validator: function(v) {
                    return /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(v);
                },
                message: "Please enter a valid email"
            },
            required: [true, "Email required"]
        }
    });
    

您可以对要验证的任何类型执行此操作，只需传递适当的正则表达式即可。如果您搜索要验证的类型及其相关的正则表达式，则很容易找到解决方案。这将使您的验证保持一致，并将所有代码放入架构中，而不是挂起函数。

How to validate email in mongoose

在Mongoose中，实现一对多关系通常涉及两个模型：父模型（例如“用户”）和子模型（例如“评论”），其中父模型会引用多个子模型的实例。以下是如何在Mongoose中实现这样的一对多关系：

首先，定义子模型的schema，例如评论模型：

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

const commentSchema = new Schema({
  text: String,
  createdAt: {
    type: Date,
    default: Date.now
  },
  // 其他字段...
});

const Comment = mongoose.model('Comment', commentSchema);
```

接着，定义父模型的schema，并使用数组字段来引用子模型的ObjectId。Mongoose中的`ref`关键字用来指定引用的模型名称：

```javascript
const userSchema = new Schema({
  username: String,
  email: String,
  comments: [
    {
      type: Schema.Types.ObjectId,
      ref: 'Comment'
    }
  ]
  // 其他字段...
});

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

在这个例子中，每个用户可以有多个评论，用户模型中的`comments`字段是一个数组，存储了指向`Comment`模型document的ObjectId。

当需要查询用户及其相关的评论时，可以使用`populate()`函数来自动替换这些ObjectId为对应的评论文档：

```javascript
User.findById(userId)
  .populate('comments')
  .exec((err, user) => {
    if (err) {
      // 处理错误...
    }
    console.log(user.comments); // 这里的comments将会是Comment的文档数组
  });
```

在实际应用中，还可以进一步为`populate()`函数指定需要的字段，或者对结果进行排序、过滤等操作。

这样的引用关系是灵活的，因为可以独立地添加或删除评论，而不需要修改用户文档。同时，也能够轻松地查询到与特定用户相关的所有评论。不过，需要注意的是，如果一对多的关系中“多”的一方数量非常大，那么可能需要考虑分页或限制引用的数量，以避免性能问题。

参考[population](http://mongoosejs.com/docs/populate.html)，这里摘取Mongoose的一个例子。

    var mongoose = require('mongoose')
    , Schema = mongoose.Schema
    
    var personSchema = Schema({
      _id     : Schema.Types.ObjectId,
      name    : String,
      age     : Number,
      stories : [{ type: Schema.Types.ObjectId, ref: 'Story' }]
    });
    
    var storySchema = Schema({
      _creator : { type: Schema.Types.ObjectId, ref: 'Person' },
      title    : String,
      fans     : [{ type: Schema.Types.ObjectId, ref: 'Person' }]
    });
    
    var Story  = mongoose.model('Story', storySchema);
    var Person = mongoose.model('Person', personSchema);
    

`Story`因此，有关模型商店的示例`Person._id`与`Story._creator`. 当找到 的文档时`Story`，可以使用`populate()`方法来定义要`Person`同时检索模型中的哪个属性，例如：

    Story.findOne({_id: 'xxxxxxx'}).populate('person', 'name age').exec(function(err, story) {
      console.log('Story title: ', story.title);
      console.log('Story creator', story.person.name);
    });
    

我相信这就是您所寻找的。或者，您可以改用[嵌套集合](https://docs.mongodb.org/manual/tutorial/model-tree-structures-with-nested-sets/)。

这个问题的先前答案很有帮助，但查看更详细的代码可能会很有用。以下代码来自我的应用程序的 Express.js 后端。我的应用程序允许用户撰写评论。当查询用户时，我返回用户所做的所有评论。

用户模型.js

    import mongoose, { Schema } from 'mongoose';
    
    
    const UserSchema = new Schema({
      firstname: String,
      lastname: String,
      username: { type: String, unique: true },
      reviews: [{ type: Schema.Types.ObjectId, ref: 'Review' }],
    }, {
      toJSON: {
        virtuals: true,
      },
    });
    
    const UserModel = mongoose.model('User', UserSchema);
    export default UserModel;
    

review\_model.js

    import mongoose, { Schema } from 'mongoose';
    
    const ReviewSchema = new Schema({
      body: String,
      username: String,
      rating: Number,
    }, {
      toJSON: {
        virtuals: true,
      },
    });
    
    const ReviewModel = mongoose.model('Review', ReviewSchema);
    export default ReviewModel;
    

review\_controller.js

    // . . .
    export const createReview = (req, res) => {
        const review = new Review();
        review.username = req.body.username;
        review.rating = req.body.rating;
        review.body = req.body.body;
        review.save()
          .then((result) => {
            User.findOne({ username: review.username }, (err, user) => {
                if (user) {
                    // The below two lines will add the newly saved review's 
                    // ObjectID to the the User's reviews array field
                    user.reviews.push(review);
                    user.save();
                    res.json({ message: 'Review created!' });
                }
            });
          })
          .catch((error) => {
            res.status(500).json({ error });
          });
    };
    

用户控制器.js

     export const createUser = (req, res) => {
       const user = new User();
       user.username = req.body.username;
       user.email = req.body.email;
       user.save()
           .then((result) => {
                res.json({ message: 'User created!', result });
            })
            .catch((error) => {
              res.status(500).json({ error });
            });
        };
    
    // . . .
    // returns the user object associated with the username if any
    // with the reviews field containing an array of review objects 
    // consisting of the reviews created by the user
    export const getUser = (req, res) => {
        User.findOne({ username: req.params.username })
          .populate('reviews')
          .then((result) => {
            res.json(result);
          })
          .catch((error) => {
            res.status(500).json({ error });
          });
      };

正如[人口文档](http://mongoosejs.com/docs/populate.html)中所说

    var aaron = new Person({ _id: 0, name: 'Aaron', age: 100 });
    
    aaron.save(function (err) {
      if (err) return handleError(err);
    
      var story1 = new Story({
        title: "Once upon a timex.",
        _creator: aaron._id    // assign the _id from the person
      });
    
      story1.save(function (err) {
        if (err) return handleError(err);
        // thats it!
      });
      //then add story to person
      aaron.stories.push(story1);
      aaron.save(callback);
    });

这是创建一对多关系的好方法。

1.  首先，我们在Comment.js中定义Comment模型。

    const mongoose = require("mongoose");
    
    const Comment = mongoose.model(
      "Comment",
      new mongoose.Schema({
        username: String,
        text: String,
        createdAt: Date
      })
    );
    
    module.exports = Comment;
    

2.  在Tutorial.js中，添加注释数组，如下所示：

    
    
    const mongoose = require("mongoose");
    
    const Tutorial = mongoose.model(
      "Tutorial",
      new mongoose.Schema({
        title: String,
        author: String,
        images: [],
        comments: [
          {
            type: mongoose.Schema.Types.ObjectId,
            ref: "Comment"
          }
        ]
      })
    );
    
    module.exports = Tutorial;
    

3.  在server.js中，添加createComment函数。

    
    const createComment = function(tutorialId, comment) {
      return db.Comment.create(comment).then(docComment => {
        console.log("\n>> Created Comment:\n", docComment);
    
        return db.Tutorial.findByIdAndUpdate(
          tutorialId,
          { $push: { comments: docComment._id } },
          { new: true, useFindAndModify: false }
        );
      });
    };

**单向或双向关系**

您可能会考虑另一种可能性：您_真的_需要双向关联吗？`_creator`或者只将其存储在每个中就足够了`Story`。并且不要_存储_for `list of stories`every `Person`。故事列表仍然可以在搜索中查询：

    let allStoriesOfOneCreator = Stories.find({_creator: person._id});
    

[https://docs.mongodb.com/manual/tutorial/model-referenced-one-to-many-relationships- Between-documents/](https://docs.mongodb.com/manual/tutorial/model-referenced-one-to-many-relationships-between-documents/)

最终这取决于您的应用程序的要求。您多久需要一次创作者的故事？

How to references with a one to many relationship in mongoose

在使用Mongoose操作MongoDB时，有时候需要执行一系列的数据库操作，比如检索一个文档然后更新它。在Mongoose中，可以使用多种方式来“合并”两次请求操作，使得它们能够顺利协作完成一项任务。

以下是一些常见的方式来合并两次请求操作：

### 1. Callbacks
最基础的方式是使用嵌套的回调函数。首先执行第一个操作，在其回调函数中执行第二个操作。

```javascript
Model.findOne({ name: 'John Doe' }, (err, user) => {
  if (err) throw err;
  if (user) {
    user.age = 30;
    user.save((err) => {
      if (err) throw err;
      // 这里处理额外的逻辑，因为两个操作已经合并完成
    });
  }
});
```

### 2. Promises
Promises 提供了一个更加优雅的方式来处理异步操作。你可以连续使用 `.then()` 来处理多个步骤。

```javascript
Model.findOne({ name: 'John Doe' })
  .then(user => {
    if (!user) throw new Error('User not found');
    user.age = 30;
    return user.save();
  })
  .then(() => {
    // 这里处理额外的逻辑
  })
  .catch(err => {
    // 处理出错的情况
  });
```

### 3. Async/Await
使用 ES7 的 async/await 可以写出更加直观和同步的风格代码，同时保持异步操作的优势。

```javascript
async function updateUserAge() {
  try {
    const user = await Model.findOne({ name: 'John Doe' });
    if (!user) throw new Error('User not found');

    user.age = 30;
    await user.save();

    // 这里处理额外的逻辑
  } catch (err) {
    // 处理出错的情况
  }
}

updateUserAge();
```

### 4. Mongoose Middleware (Pre/Post Hooks)
Mongoose 允许你定义 pre 和 post 钩子（hooks），它们可以在某些操作执行前后自动运行。这可以用于合并像验证或者自动填充等操作。

```javascript
schema.pre('save', function(next) {
  // 在文档保存之前执行一些操作
  next();
});

schema.post('save', function(doc) {
  // 在文档保存之后执行一些操作
});
```

### 5. 事务（Transactions）
MongoDB 4.0 以上版本支持多文档事务。如果需要合并的操作涉及到多个文档或集合的变更，可以使用事务来保证数据的一致性。

```javascript
const session = await mongoose.startSession();
session.startTransaction();

try {
  const opts = { session };
  const user = await Model.findOne({ name: 'John Doe' }, null, opts);
  user.age = 30;
  await user.save(opts);

  // 可以在此添加更多操作，它们都将成为这个事务的一部分

  await session.commitTransaction();
  session.endSession();
} catch (err) {
  await session.abortTransaction();
  session.endSession();
  throw err;
}
```

在实际的应用中，这些方法可以根据具体的业务逻辑和操作的复杂度来选择。代码的可维护性、错误处理方式、以及对并发操作的处理都是选择合适方法时需要考虑的因素。

It's probably easiest to create your query object directly as:

      Test.find({
          $and: [
              { $or: [{a: 1}, {b: 1}] },
              { $or: [{c: 1}, {d: 1}] }
          ]
      }, function (err, results) {
          ...
      }
    

But you can also use the [`Query#and`](http://mongoosejs.com/docs/api.html#query_Query-and) helper that's available in recent 3.x Mongoose releases:

      Test.find()
          .and([
              { $or: [{a: 1}, {b: 1}] },
              { $or: [{c: 1}, {d: 1}] }
          ])
          .exec(function (err, results) {
              ...
          });

在 Mongoose 中，要使用 AND 组合两个 OR 查询，可以使用查询构造器来添加复杂的查询条件。Mongoose 提供了 `.and()` 方法来指定 AND 条件，同时 `.or()` 方法用于指定 OR 条件。每个 `.or()` 方法调用可以包含一个条件数组，表示所有数组内的条件中至少有一个要为真。

下面我将通过一个例子来说明如何在 Mongoose 中组合两个 OR 查询。

设想我们有一个用户模型，包含字段 `name` 和 `status`，我们想找到以下两组用户的并集：

1. 名字是 "Alice" 或 "Bob" 的用户。
2. 状态为 "active" 或 "pending" 的用户。

此时我们需要组合两个 OR 查询，可以这么做：

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

// 假设有如下用户模型
const UserSchema = new Schema({
  name: String,
  status: String
});

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

User.find()
  .and([
    { $or: [{ name: 'Alice' }, { name: 'Bob' }] },
    { $or: [{ status: 'active' }, { status: 'pending' }] }
  ])
  .exec((err, users) => {
    if (err) throw err;
    // 处理查询到的用户
    console.log(users);
  });
```

在这个例子中，`.find()` 方法首先被调用，然后是 `.and()` 方法，它接受一个数组作为参数。这个数组包含了两个对象，每个对象都是一个 OR 查询。第一个 OR 查询 `{ $or: [{ name: 'Alice' }, { name: 'Bob' }] }` 表示查找名字为 "Alice" 或者 "Bob" 的用户，第二个 OR 查询 `{ $or: [{ status: 'active' }, { status: 'pending' }] }` 表示查找状态为 "active" 或者 "pending" 的用户。这两个 OR 查询通过 AND 条件组合，最终结果是同时满足这两个条件的用户集合。

请注意，每个 `.or()` 查询实际上是通过 `$or` 操作符实现的，这是 MongoDB 的查询语法。Mongoose 使得构建这种查询变得更为直观。

还有其他方式来实现相同的查询，例如直接在 `.find()` 方法中构造查询对象：

```javascript
User.find({
  $and: [
    { $or: [{ name: 'Alice' }, { name: 'Bob' }] },
    { $or: [{ status: 'active' }, { status: 'pending' }] }
  ]
})
.exec((err, users) => {
  if (err) throw err;
  // 处理查询到的用户
  console.log(users);
});
```

这种方法直接将 AND 和 OR 查询组合为一个查询对象，然后将其作为 `.find()` 方法的参数传递。两种方法在功能上是等价的，你可以根据自己的喜好和具体需求选择使用。

How to combine two or queries with and in mongoose

Mongoose 是一个 MongoDB 对象模型库，用于在 Node.js 环境中以对象映射文档（Object-Document Mapping，ODM）的方式操作 MongoDB 数据库。`.save()` 方法和 `update()` 方法都用于在数据库中持久化文档数据，但它们之间存在一些关键区别：

### `.save()` 方法

1. **创建或更新：** `.save()` 通常用于保存一个新的文档实例或更新现有的文档。如果保存的文档实例具有 `_id` 字段并且在数据库中能找到对应的记录，那么它会执行更新操作。如果没有 `_id` 字段或者 `_id` 在数据库中找不到匹配的记录，则会创建一个新记录。

2. **全文档操作：** 当你使用 `.save()` 时，你通常是在操作整个文档。无论是创建新文档还是更新现有文档，你都会发送整个文档的数据到数据库。

3. **中间件触发：** `.save()` 方法会触发 Mongoose 的中间件（如 `pre` 和 `post` 钩子）。这意味着在保存过程中，可以执行自定义逻辑（如密码加密、数据验证等）。

4. **返回值：** `.save()` 方法执行后，会返回被保存的文档对象。

5. **示例：**
    ```javascript
    const user = new UserModel({
      name: 'Alice',
      email: 'alice@example.com'
    });
    user.save(function(err, savedUser) {
      if (err) throw err;
      // savedUser 是保存后的文档对象
    });
    ```

### `update()` 方法

1. **只用于更新：** `.update()` 方法仅用于更新已存在的文档。它不能用于创建新文档。

2. **部分文档操作：** 当你使用 `.update()` 方法时，你可以只更新文档的某些部分，而不是发送整个文档。这通常用于性能优化，因为只传输需要更新的字段。

3. **没有中间件触发：** 使用 `.update()` 方法时，通常不会触发 Mongoose 中间件。如果需要在更新操作前后执行特定逻辑，可能需要手动处理。

4. **返回值：** `.update()` 方法执行后，返回的是一个包含操作结果的对象，如更新的文档数量，而不是更新后的文档对象。

5. **示例：**
    ```javascript
    UserModel.update({ _id: userId }, { $set: { name: 'Bob' } }, function(err, result) {
      if (err) throw err;
      // result 是操作结果对象，可以通过 result.nModified 获取被更新的文档数量
    });
    ```

总结一下，`.save()` 用于创建新文档或替换整个文档，而 `.update()` 用于修改现有文档的部分字段。`.save()` 方法会触发中间件，返回保存的文档；`.update()` 方法不触发中间件，返回操作的结果。根据具体的应用场景和性能考虑，开发者可以选择最合适的方法进行数据库操作。### 应用场景比较

#### `.save()` 方法的应用场景：

- **新建文档场景**：当你有一个全新的文档并打算将其添加到数据库中时，可以使用 `.save()` 来实现。例如，当一个新用户注册到你的应用时，你需要创建一个新的用户文档。

- **完整文档更新场景**：如果你需要更新文档，并且更新涉及许多字段，或者你已经在应用层加载并可能修改了整个文档，那么使用 `.save()` 方法更新整个文档可能更为方便。

- **需要中间件处理的场景**：当你的保存逻辑需要触发 Mongoose 中间件，比如数据验证、自动设置时间戳、散列密码等操作时，`.save()` 方法是更好的选择。

#### `.update()` 方法的应用场景：

- **部分更新场景**：当你需要更新文档中的一个或几个字段，并且不需要加载整个文档时，`.update()` 是一个更高效的选择。这常见于需要快速响应的Web应用中。

- **批量更新场景**：当你需要更新多个文档且每个文档的更新都是相同的操作时，`.update()` 方法可以通过一次操作来更新所有匹配的文档，这通常比逐一加载文档并调用 `.save()` 更有效率。

- **无需中间件场景**：如果你不需要触发保存过程中的中间件，比如在执行一些批量操作或后台任务时，`.update()` 可以避免中间件的性能开销。

### 直接修改和替换文档

- **`.save()` 替换文档**：当你使用 `.save()` 方法时，如果文档存在 `_id` 字段且该 `_id` 在数据库中找到了对应的记录，Mongoose 会替换掉原来的文档。这意味着，如果有些字段在新文档中没有指定，它们将从数据库中的文档里被移除。

- **`.update()` 修改字段**：与 `.save()` 不同，`.update()` 方法默认仅修改指定的字段，而不会影响未指定的字段。对于需要保留其他字段内容的场合，这通常是更加安全和预期的行为。

### 性能考量

- **性能优化**：在大型应用中，`.update()` 方法对性能的影响通常小于 `.save()` 方法。特别是在进行部分字段更新时，`.update()` 方法不需要发送整个文档数据，也不需要加载文档到应用层，从而减少了网络传输和内存使用。

- **原子操作**：`.update()` 方法允许使用 MongoDB 的原子更新操作符，如 `$set`, `$inc`, `$push` 等，这样可以确保更新操作的原子性，防止在并发场景下出现数据不一致的问题。

### 总结

根据你的需要，你可能会选择使用 `.save()` 或 `.update()`——或者是 Mongoose 提供的其他相关方法，如 `.updateOne()`, `.updateMany()`, `.findOneAndUpdate()` 等，这些方法提供了不同的功能和性能取舍。选择哪一种方法取决于你的具体需求，比如是否需要处理整个文档，是否需要触发中间件，是否关注性能优化，以及操作的原子性等因素。

先说两个概念。您的应用程序是**客户端**，Mongodb 是**服务器**。

主要区别在于，`.save()`您的客户端代码中已经有一个对象，或者在写回数据之前必须从服务器检索数据，并且您正在写回整个内容。

另一方面`.update()`不需要**将**数据从服务器加载到客户端。所有交互都发生在服务器端，而不检索到客户端。因此，`.update()`当您向现有文档添加内容时，这种方式可以非常有效。

此外，还有一个`multi`参数`.update()`允许对多个符合查询条件的文档执行操作。

当用作调用时，便利方法中的一些东西你会失去`.update()`，但某些操作的好处是你必须承担的“权衡”。有关此内容以及可用选项的更多信息，请参阅[文档](http://mongoosejs.com/docs/api.html#model_Model.update)。

简而言之`.save()`是客户端接口，`.update()`是服务器端。

一些差异：

*   正如其他地方所指出的，它比其次`update`更有效，因为它避免了加载整个文档。`find``save`
*   Mongoose`update`会转换为 MongoDB `update`，但 Mongoose`save`会转换为 MongoDB `insert`（用于新文档）或`update`.
*   需要注意的是`save`，[Mongoose 在内部比较文档](https://github.com/Automattic/mongoose/blob/168f516902bf142006581479d58d19867fb844e8/lib/model.js#L146)并仅发送实际更改的字段。这有利于原子性。
*   默认情况下，[验证不会运行](https://www.mongodb.com/blog/post/introducing-version-40-mongoose-nodejs-odm)，`update`但可以启用。
*   中间件 API（`pre`和`post`钩子）是不同的。

Mongoose 有一个有用的功能，称为中间件。有“前”和“后”中间件。中间件会在您执行“保存”时执行，但不会在“更新”期间执行。例如，如果您想在每次修改密码时对 User schema 中的密码进行哈希处理，则可以使用 pre 来执行此操作，如下所示。另一个有用的示例是为每个文档设置lastModified。[该文档可以在http://mongoosejs.com/docs/middleware.html](http://mongoosejs.com/docs/middleware.html)找到[](http://mongoosejs.com/docs/middleware.html)

    UserSchema.pre('save', function(next) {
    var user = this;
    // only hash the password if it has been modified (or is new)
    if (!user.isModified('password')) {
        console.log('password not modified');
        return next();
    }
    console.log('password modified');
    // generate a salt
    bcrypt.genSalt(10, function(err, salt) {
        if (err) {
            return next(err);
        }
    
        // hash the password along with our new salt
        bcrypt.hash(user.password, salt, function(err, hash) {
            if (err) {
                return next(err);
            }
            // override the cleartext password with the hashed one
            user.password = hash;
            next();
        });
    });
    });

一个不容忽视的细节：**并发性**

正如前面提到的，在执行操作时`doc.save()`，您必须先将文档加载到内存中，然后对其进行修改，最后将`doc.save()`更改发送到 MongoDB 服务器。

**当同时以**这种方式编辑文档时就会出现问题：

*   A 加载文档 (v1)
*   B 加载文档 (v1)
*   B 保存对文档的更改（现在是 v2）
*   A 保存对过时 (v1) 文档的更改
*   A 会看到 Mongoose 抛出 VersionError，因为文档自上次从集合加载以来已发生更改

在执行像这样的原子操作时，并发不是问题`Model.updateOne()`，因为操作完全在 MongoDB 服务器中完成，MongoDB 服务器执行一定程度的**[并发控制](https://docs.mongodb.com/manual/faq/concurrency/)**。

因此，要小心！

Mongoose 是一个 MongoDB 对象模型库，用于在 Node.js 环境中以对象映射文档（Object-Document Mapping，ODM）的方式操作 MongoDB 数据库。`.save()` 方法和 `update()` 方法都用于在数据库中持久化文档数据，但它们之间存在一些关键区别：

### `.save()` 方法

1. **创建或更新：** `.save()` 通常用于保存一个新的文档实例或更新现有的文档。如果保存的文档实例具有 `_id` 字段并且在数据库中能找到对应的记录，那么它会执行更新操作。如果没有 `_id` 字段或者 `_id` 在数据库中找不到匹配的记录，则会创建一个新记录。

2. **全文档操作：** 当你使用 `.save()` 时，你通常是在操作整个文档。无论是创建新文档还是更新现有文档，你都会发送整个文档的数据到数据库。

3. **中间件触发：** `.save()` 方法会触发 Mongoose 的中间件（如 `pre` 和 `post` 钩子）。这意味着在保存过程中，可以执行自定义逻辑（如密码加密、数据验证等）。

4. **返回值：** `.save()` 方法执行后，会返回被保存的文档对象。

5. **示例：**
    ```javascript
    const user = new UserModel({
      name: 'Alice',
      email: 'alice@example.com'
    });
    user.save(function(err, savedUser) {
      if (err) throw err;
      // savedUser 是保存后的文档对象
    });
    ```

### `update()` 方法

1. **只用于更新：** `.update()` 方法仅用于更新已存在的文档。它不能用于创建新文档。

2. **部分文档操作：** 当你使用 `.update()` 方法时，你可以只更新文档的某些部分，而不是发送整个文档。这通常用于性能优化，因为只传输需要更新的字段。

3. **没有中间件触发：** 使用 `.update()` 方法时，通常不会触发 Mongoose 中间件。如果需要在更新操作前后执行特定逻辑，可能需要手动处理。

4. **返回值：** `.update()` 方法执行后，返回的是一个包含操作结果的对象，如更新的文档数量，而不是更新后的文档对象。

5. **示例：**
    ```javascript
    UserModel.update({ _id: userId }, { $set: { name: 'Bob' } }, function(err, result) {
      if (err) throw err;
      // result 是操作结果对象，可以通过 result.nModified 获取被更新的文档数量
    });
    ```

总结一下，`.save()` 用于创建新文档或替换整个文档，而 `.update()` 用于修改现有文档的部分字段。`.save()` 方法会触发中间件，返回保存的文档；`.update()` 方法不触发中间件，返回操作的结果。根据具体的应用场景和性能考虑，开发者可以选择最合适的方法进行数据库操作。

Mongoose 是一个 MongoDB 对象模型库，用于在 Node.js 环境中以对象映射文档（Object-Document Mapping，ODM）的方式操作 MongoDB 数据库。`.save()` 方法和 `update()` 方法都用于在数据库中持久化文档数据，但它们之间存在一些关键区别：

### `.save()` 方法

1. **创建或更新：** `.save()` 通常用于保存一个新的文档实例或更新现有的文档。如果保存的文档实例具有 `_id` 字段并且在数据库中能找到对应的记录，那么它会执行更新操作。如果没有 `_id` 字段或者 `_id` 在数据库中找不到匹配的记录，则会创建一个新记录。

2. **全文档操作：** 当你使用 `.save()` 时，你通常是在操作整个文档。无论是创建新文档还是更新现有文档，你都会发送整个文档的数据到数据库。

3. **中间件触发：** `.save()` 方法会触发 Mongoose 的中间件（如 `pre` 和 `post` 钩子）。这意味着在保存过程中，可以执行自定义逻辑（如密码加密、数据验证等）。

4. **返回值：** `.save()` 方法执行后，会返回被保存的文档对象。

5. **示例：**
    ```javascript
    const user = new UserModel({
      name: 'Alice',
      email: 'alice@example.com'
    });
    user.save(function(err, savedUser) {
      if (err) throw err;
      // savedUser 是保存后的文档对象
    });
    ```

### `update()` 方法

1. **只用于更新：** `.update()` 方法仅用于更新已存在的文档。它不能用于创建新文档。

2. **部分文档操作：** 当你使用 `.update()` 方法时，你可以只更新文档的某些部分，而不是发送整个文档。这通常用于性能优化，因为只传输需要更新的字段。

3. **没有中间件触发：** 使用 `.update()` 方法时，通常不会触发 Mongoose 中间件。如果需要在更新操作前后执行特定逻辑，可能需要手动处理。

4. **返回值：** `.update()` 方法执行后，返回的是一个包含操作结果的对象，如更新的文档数量，而不是更新后的文档对象。

5. **示例：**
    ```javascript
    UserModel.update({ _id: userId }, { $set: { name: 'Bob' } }, function(err, result) {
      if (err) throw err;
      // result 是操作结果对象，可以通过 result.nModified 获取被更新的文档数量
    });
    ```

总结一下，`.save()` 用于创建新文档或替换整个文档，而 `.update()` 用于修改现有文档的部分字段。`.save()` 方法会触发中间件，返回保存的文档；`.update()` 方法不触发中间件，返回操作的结果。根据具体的应用场景和性能考虑，开发者可以选择最合适的方法进行数据库操作。
### 应用场景比较

#### `.save()` 方法的应用场景：

- **新建文档场景**：当你有一个全新的文档并打算将其添加到数据库中时，可以使用 `.save()` 来实现。例如，当一个新用户注册到你的应用时，你需要创建一个新的用户文档。

- **完整文档更新场景**：如果你需要更新文档，并且更新涉及许多字段，或者你已经在应用层加载并可能修改了整个文档，那么使用 `.save()` 方法更新整个文档可能更为方便。

- **需要中间件处理的场景**：当你的保存逻辑需要触发 Mongoose 中间件，比如数据验证、自动设置时间戳、散列密码等操作时，`.save()` 方法是更好的选择。

#### `.update()` 方法的应用场景：

- **部分更新场景**：当你需要更新文档中的一个或几个字段，并且不需要加载整个文档时，`.update()` 是一个更高效的选择。这常见于需要快速响应的Web应用中。

- **批量更新场景**：当你需要更新多个文档且每个文档的更新都是相同的操作时，`.update()` 方法可以通过一次操作来更新所有匹配的文档，这通常比逐一加载文档并调用 `.save()` 更有效率。

- **无需中间件场景**：如果你不需要触发保存过程中的中间件，比如在执行一些批量操作或后台任务时，`.update()` 可以避免中间件的性能开销。

### 直接修改和替换文档

- **`.save()` 替换文档**：当你使用 `.save()` 方法时，如果文档存在 `_id` 字段且该 `_id` 在数据库中找到了对应的记录，Mongoose 会替换掉原来的文档。这意味着，如果有些字段在新文档中没有指定，它们将从数据库中的文档里被移除。

- **`.update()` 修改字段**：与 `.save()` 不同，`.update()` 方法默认仅修改指定的字段，而不会影响未指定的字段。对于需要保留其他字段内容的场合，这通常是更加安全和预期的行为。

### 性能考量

- **性能优化**：在大型应用中，`.update()` 方法对性能的影响通常小于 `.save()` 方法。特别是在进行部分字段更新时，`.update()` 方法不需要发送整个文档数据，也不需要加载文档到应用层，从而减少了网络传输和内存使用。

- **原子操作**：`.update()` 方法允许使用 MongoDB 的原子更新操作符，如 `$set`, `$inc`, `$push` 等，这样可以确保更新操作的原子性，防止在并发场景下出现数据不一致的问题。

### 总结

根据你的需要，你可能会选择使用 `.save()` 或 `.update()`——或者是 Mongoose 提供的其他相关方法，如 `.updateOne()`, `.updateMany()`, `.findOneAndUpdate()` 等，这些方法提供了不同的功能和性能取舍。选择哪一种方法取决于你的具体需求，比如是否需要处理整个文档，是否需要触发中间件，是否关注性能优化，以及操作的原子性等因素。

What is the difference between save and using update in mongodb

在使用Mongoose操作MongoDB时，您可以通过不同的方式删除数据库中的数据。以下是几种删除操作的方法：

### 删除文档

1. **使用`remove`方法**：这是删除匹配条件的所有文档的传统方法。但请注意，从Mongoose v5.0开始，`remove`方法已被弃用，建议使用`deleteOne`或`deleteMany`。

    ```javascript
    // 假设我们有一个名为Model的模型
    Model.remove({ _id: '某个特定的ID' }, function(err) {
        if(err) {
            console.error("发生错误！", err);
        } else {
            console.log("文档删除成功");
        }
    });
    ```

2. **使用`deleteOne`方法**：这是用来删除第一个匹配条件的单个文档的方法。

    ```javascript
    Model.deleteOne({ name: '待删除的名称' }, function(err) {
        if(err) {
            console.error("发生错误！", err);
        } else {
            console.log("单个文档删除成功");
        }
    });
    ```

3. **使用`deleteMany`方法**：这是用来删除所有匹配条件的文档的方法。

    ```javascript
    Model.deleteMany({ age: { $gte: 18 } }, function(err) {
        if(err) {
            console.error("发生错误！", err);
        } else {
            console.log("多个文档删除成功");
        }
    });
    ```

### 删除集合

如果您想要删除整个集合，您可以调用集合的`drop`方法。请谨慎使用，因为这会删除整个集合及其所有文档。

```javascript
mongoose.connection.db.dropCollection('collectionName', function(err, result) {
    if(err) {
        console.error("删除集合失败！", err);
    } else {
        console.log("集合删除成功", result);
    }
});
```

### 删除数据库

如果您需要删除整个数据库，可以使用MongoDB原生驱动的`dropDatabase`方法。这将删除当前连接的数据库，包括所有的集合和文档。

```javascript
mongoose.connection.db.dropDatabase(function(err, result) {
    if(err) {
        console.error("删除数据库失败！", err);
    } else {
        console.log("数据库删除成功", result);
    }
});
```

在执行这些删除操作时，一定要小心谨慎，因为它们会永久移除数据。在删除操作之前，确保您有相关数据的备份，或已经确认这些数据不再需要了。在开发阶段，可以在测试数据库上操作，以避免对生产数据库造成不必要的风险。### 确认删除操作

删除数据是一个危险的操作，尤其是在生产环境下。因此，在执行删除之前，您应该确保实施一些确认步骤，比如：

- **备份数据**：在删除任何数据之前，确保您已经备份了数据库或相应的数据集。
- **双重确认**：在执行删除操作之前，最好有一个提示让用户确认他们确实想要删除数据。
- **权限检查**：确保只有拥有适当权限的用户才能删除数据。

### 使用事务处理（在支持的情况下）

如果您的MongoDB版本支持事务（如MongoDB 4.0及以上的副本集），您可能想要在事务中执行删除操作。这样，如果事务中的某个部分失败，所有更改都可以回滚，从而避免了数据不一致的风险。

```javascript
const session = await mongoose.startSession();
session.startTransaction();
try {
    await Model.deleteMany({}, { session });
    // ... 可能还有其他数据库操作 ...
    await session.commitTransaction();
} catch (error) {
    await session.abortTransaction();
    throw error;
} finally {
    session.endSession();
}
```

### 软删除

有时候，您可能并不想从数据库中完全删除数据，而是想进行所谓的"软删除"。软删除通常意味着将文档标记为已删除，而实际上并不从数据库中移除它们。这可以通过在文档上添加一个`isDeleted`字段来实现，并在查询时过滤掉这些被标记为`isDeleted`的文档。

```javascript
// 软删除示例
Model.updateMany({}, { $set: { isDeleted: true } }, function(err) {
    if(err) {
        console.error("软删除失败！", err);
    } else {
        console.log("文档已被软删除");
    }
});

// 查询时跳过软删除的文档
Model.find({ isDeleted: { $ne: true } }).exec(function(err, docs) {
    // 返回未被软删除的文档
});
```

软删除通常用于需要保留数据完整性或历史记录的场景。

### 总结

删除操作应该谨慎进行，以防止意外数据丢失。在进行删除之前，确认操作的必要性，备份数据库，并只允许具有相应权限的用户执行这些操作。在某些场景下，您可能会考虑软删除而不是硬删除数据，以便未来的恢复或审计。

There is no method for dropping a collection from mongoose, the best you can do is remove the content of one :

    Model.remove({}, function(err) { 
       console.log('collection removed') 
    });
    

But there is a way to access the mongodb native javascript driver, which can be used for this

    mongoose.connection.collections['collectionName'].drop( function(err) {
        console.log('collection dropped');
    });
    

### Warning

Make a backup before trying this in case anything goes wrong!

Mongoose will create a database if one does not already exist on connection, so once you make the connection, you can just query it to see if there is anything in it.

You can drop any database you are connected to:

    var mongoose = require('mongoose');
    /* Connect to the DB */
    mongoose.connect('mongodb://localhost/mydatabase',function(){
        /* Drop the DB */
        mongoose.connection.db.dropDatabase();
    });

If you modify @hellslam's solution like this then it will work

I use this technique to drop the Database after my integration tests

    //CoffeeScript
    mongoose = require "mongoose"
    conn = mongoose.connect("mongodb://localhost/mydb")
    
    conn.connection.db.dropDatabase()
    
    //JavaScript
    var conn, mongoose;
    mongoose = require("mongoose");
    conn = mongoose.connect("mongodb://localhost/mydb");
    
    conn.connection.db.dropDatabase();
    

HTH at least it did for me, so I decided to share =)

在使用Mongoose操作MongoDB时，您可以通过不同的方式删除数据库中的数据。以下是几种删除操作的方法：

### 删除文档

1. **使用`remove`方法**：这是删除匹配条件的所有文档的传统方法。但请注意，从Mongoose v5.0开始，`remove`方法已被弃用，建议使用`deleteOne`或`deleteMany`。

    ```javascript
    // 假设我们有一个名为Model的模型
    Model.remove({ _id: '某个特定的ID' }, function(err) {
        if(err) {
            console.error("发生错误！", err);
        } else {
            console.log("文档删除成功");
        }
    });
    ```

2. **使用`deleteOne`方法**：这是用来删除第一个匹配条件的单个文档的方法。

    ```javascript
    Model.deleteOne({ name: '待删除的名称' }, function(err) {
        if(err) {
            console.error("发生错误！", err);
        } else {
            console.log("单个文档删除成功");
        }
    });
    ```

3. **使用`deleteMany`方法**：这是用来删除所有匹配条件的文档的方法。

    ```javascript
    Model.deleteMany({ age: { $gte: 18 } }, function(err) {
        if(err) {
            console.error("发生错误！", err);
        } else {
            console.log("多个文档删除成功");
        }
    });
    ```

### 删除集合

如果您想要删除整个集合，您可以调用集合的`drop`方法。请谨慎使用，因为这会删除整个集合及其所有文档。

```javascript
mongoose.connection.db.dropCollection('collectionName', function(err, result) {
    if(err) {
        console.error("删除集合失败！", err);
    } else {
        console.log("集合删除成功", result);
    }
});
```

### 删除数据库

如果您需要删除整个数据库，可以使用MongoDB原生驱动的`dropDatabase`方法。这将删除当前连接的数据库，包括所有的集合和文档。

```javascript
mongoose.connection.db.dropDatabase(function(err, result) {
    if(err) {
        console.error("删除数据库失败！", err);
    } else {
        console.log("数据库删除成功", result);
    }
});
```

在执行这些删除操作时，一定要小心谨慎，因为它们会永久移除数据。在删除操作之前，确保您有相关数据的备份，或已经确认这些数据不再需要了。在开发阶段，可以在测试数据库上操作，以避免对生产数据库造成不必要的风险。

在使用Mongoose操作MongoDB时，您可以通过不同的方式删除数据库中的数据。以下是几种删除操作的方法：

### 删除文档

1. **使用`remove`方法**：这是删除匹配条件的所有文档的传统方法。但请注意，从Mongoose v5.0开始，`remove`方法已被弃用，建议使用`deleteOne`或`deleteMany`。

    ```javascript
    // 假设我们有一个名为Model的模型
    Model.remove({ _id: '某个特定的ID' }, function(err) {
        if(err) {
            console.error("发生错误！", err);
        } else {
            console.log("文档删除成功");
        }
    });
    ```

2. **使用`deleteOne`方法**：这是用来删除第一个匹配条件的单个文档的方法。

    ```javascript
    Model.deleteOne({ name: '待删除的名称' }, function(err) {
        if(err) {
            console.error("发生错误！", err);
        } else {
            console.log("单个文档删除成功");
        }
    });
    ```

3. **使用`deleteMany`方法**：这是用来删除所有匹配条件的文档的方法。

    ```javascript
    Model.deleteMany({ age: { $gte: 18 } }, function(err) {
        if(err) {
            console.error("发生错误！", err);
        } else {
            console.log("多个文档删除成功");
        }
    });
    ```

### 删除集合

如果您想要删除整个集合，您可以调用集合的`drop`方法。请谨慎使用，因为这会删除整个集合及其所有文档。

```javascript
mongoose.connection.db.dropCollection('collectionName', function(err, result) {
    if(err) {
        console.error("删除集合失败！", err);
    } else {
        console.log("集合删除成功", result);
    }
});
```

### 删除数据库

如果您需要删除整个数据库，可以使用MongoDB原生驱动的`dropDatabase`方法。这将删除当前连接的数据库，包括所有的集合和文档。

```javascript
mongoose.connection.db.dropDatabase(function(err, result) {
    if(err) {
        console.error("删除数据库失败！", err);
    } else {
        console.log("数据库删除成功", result);
    }
});
```

在执行这些删除操作时，一定要小心谨慎，因为它们会永久移除数据。在删除操作之前，确保您有相关数据的备份，或已经确认这些数据不再需要了。在开发阶段，可以在测试数据库上操作，以避免对生产数据库造成不必要的风险。
### 确认删除操作

删除数据是一个危险的操作，尤其是在生产环境下。因此，在执行删除之前，您应该确保实施一些确认步骤，比如：

- **备份数据**：在删除任何数据之前，确保您已经备份了数据库或相应的数据集。
- **双重确认**：在执行删除操作之前，最好有一个提示让用户确认他们确实想要删除数据。
- **权限检查**：确保只有拥有适当权限的用户才能删除数据。

### 使用事务处理（在支持的情况下）

如果您的MongoDB版本支持事务（如MongoDB 4.0及以上的副本集），您可能想要在事务中执行删除操作。这样，如果事务中的某个部分失败，所有更改都可以回滚，从而避免了数据不一致的风险。

```javascript
const session = await mongoose.startSession();
session.startTransaction();
try {
    await Model.deleteMany({}, { session });
    // ... 可能还有其他数据库操作 ...
    await session.commitTransaction();
} catch (error) {
    await session.abortTransaction();
    throw error;
} finally {
    session.endSession();
}
```

### 软删除

有时候，您可能并不想从数据库中完全删除数据，而是想进行所谓的"软删除"。软删除通常意味着将文档标记为已删除，而实际上并不从数据库中移除它们。这可以通过在文档上添加一个`isDeleted`字段来实现，并在查询时过滤掉这些被标记为`isDeleted`的文档。

```javascript
// 软删除示例
Model.updateMany({}, { $set: { isDeleted: true } }, function(err) {
    if(err) {
        console.error("软删除失败！", err);
    } else {
        console.log("文档已被软删除");
    }
});

// 查询时跳过软删除的文档
Model.find({ isDeleted: { $ne: true } }).exec(function(err, docs) {
    // 返回未被软删除的文档
});
```

软删除通常用于需要保留数据完整性或历史记录的场景。

### 总结

删除操作应该谨慎进行，以防止意外数据丢失。在进行删除之前，确认操作的必要性，备份数据库，并只允许具有相应权限的用户执行这些操作。在某些场景下，您可能会考虑软删除而不是硬删除数据，以便未来的恢复或审计。

How to drop a database with mongoose

`exec` 函数在 Mongoose 中用于执行一个查询并返回一个 promise。当你使用 Mongoose 构建查询时，直到你调用 `exec`，`then`，`catch`，或者使用 `await` 时，查询才会被发送到 MongoDB 数据库执行。

在 Mongoose 中，查询构建器允许链式调用各种方法来构建一个复杂的查询。例如，你可能会使用 `find`，`sort`，`limit`，`select` 等方法。调用 `exec` 是在链式构建完成之后触发实际数据库操作的一种方式。

这里有一个例子：

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

// 假设我们有一个名为 User 的模型
const UserSchema = new Schema({
  name: String,
  age: Number,
  email: String
});

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

// 构建一个查询来查找所有年龄在30岁以上的用户，并按照名称进行排序
User.find({ age: { $gt: 30 } })
  .sort('name')
  .select('name email')
  .exec() // 在这里，exec() 会执行上面构建的查询
  .then(users => {
    // 处理查询结果
    console.log(users);
  })
  .catch(err => {
    // 处理可能发生的错误
    console.error(err);
  });
```

在这个例子中，`exec` 返回一个 promise，该 promise 在查询成功执行后解析查询结果，在出现错误时拒绝。

使用 `exec` 的优势是可以让你更灵活地处理结果和错误，例如可以使用 `async/await` 语法，这样代码更加简洁和现代：

```javascript
async function findUsers() {
  try {
    const users = await User.find({ age: { $gt: 30 } })
      .sort('name')
      .select('name email')
      .exec(); // 使用 async/await 等待查询结果
    console.log(users);
  } catch (err) {
    console.error(err);
  }
}

findUsers();
```

在这个例子中，我们通过 `await` 关键字等待 `exec()` 的结果，这样就可以用同步代码的方式写异步操作，提高代码的可读性和维护性。

Basically when using mongoose, documents can be retrieved using helpers. Every model method that accepts query conditions can be executed by means of a `callback` or the `exec` method.

`callback`:

    User.findOne({ name: 'daniel' }, function (err, user) {
      //
    });
    

`exec`:

    User
      .findOne({ name: 'daniel' })
      .exec(function (err, user) {
          //
      });
    

Therefore when you don't pass a callback you can build a query and eventually execute it.

You can find additional info in the [mongoose docs](http://mongoosejs.com/docs/queries.html "mongoose docs").

**UPDATE**

Something to note when using [Promises](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Promise) in combination with Mongoose async operations is that Mongoose queries are **not** Promises. Queries do return a _thenable_, but if you need a _real_ Promise you should use the `exec` method. More information can be found [here](http://mongoosejs.com/docs/promises.html).

During the update I noticed I didn't explicitly answer the question:

> Ive never seen that method in Javascript before? What does it do exactly?

Well it's **not** a native JavaScript method, but part of the Mongoose API.

I never use `exec()` function to complete a CRUD(Create, Read, Update, Delete) on a model. When I want CRUD on a model, I use it like this:

    const user = await UserModel.findOne(userCondition);
    

And it always does the job. So I wondered "what does `exec()` use for"? As I searched in mongoose document, I found the answer [here](https://mongoosejs.com/docs/promises.html).  

> Should You Use exec() With await?  

And here is the story.  
You have two ways to execute a query on a model. Using `callback` or using `exec()` function. "But" you can use `await` too. `exec()` function returns a promise, that you can use it with `then()` or `async/await` to execute a query on a model "asynchronous". So the question is "If I can just use `user = await UserModel.find()` and it works currectly, so why should I use `exec()` function?". The answer that you can find in the [document](https://mongoosejs.com/docs/promises.html) is:  
  
There are two difference between using `await` with `exec()` or without it.  

*   As a functionality point of view, there is no difference between using `await` with `exec()` or without it. Just when you call a query without `exec()` or `callback`, it returns a `thenable` which is something like promise but it's not a promise.(You can find the difference [here](https://mongoosejs.com/docs/queries.html#queries-are-not-promises)). But when you use `exec()` to run a query, you get exactly a promise as response.

    // returns a thenable as response that is not a promise, but you can use await and then() with it.
    const user = await UserModel.findOne(userCondition);
    
    // returns exactly a promise.
    const user = await UserModel.findOne(userCondition).exec(); 
    

*   Another difference is, if you use `await` with `exec()` you get a better "stack trace" if you catch any error in executing queries. So:  
      
    These two line, do the same thing:

    const user = await UserModel.findOne(userCondition);
    
    // does exactly as the before line does, but you get a better stack trace if any error happened
    const user = await UserModel.findOne(userCondition).exec();

Daniel has answered this quite beautifully. To elaborate on an exhaustive list of ways to build and execute queries, look at the following use cases:

**Query Building**

Mongoose will not execute a query until `then` or `exec` has been called upon it. This is very useful when building complex queries. Some examples can include using the `populate` and `aggregate` functions.

    User.find({name: 'John'}) // Will not execute
    

**Execution via callback**

Although disliked by many due to its nesting nature, queries can be executed by providing the optional callback.

    User.find({name: 'John'}, (err, res) => {}) // Will execute
    

**Then API as a Promises/A+**

Mongoose queries do provide a `then` function. This is not to be confused with regular promises. Simply put, the Promises/A+ specification requires a `then` function to work much like how we're used to with promises.

    User.find({name: 'John'}).then(); // Will execute
    Promise.all([User.find({name: 'John'}), User.find({name: 'Bob'})]) // Will execute all queries in parallel
    

**The exec function**

From Mongoose docs `If you need a fully-fledged promise, use the .exec() function.`

    User.find({name: 'John'}).exec(); // Will execute returning a promise

`exec()` will return a promise if no callback is provided. So the following pattern is very convenient and generic - it can handle callbacks or promises nicely:

    function findAll(query, populate, cb) {
    
      let q = Response.find(query);
    
      if (populate && populate.length > 0) {
        q = q.populate(populate);
      }
    
      // cb is optional, will return promise if cb == null
      return q.lean().exec(cb);
    
    }
    

I recommend using Bluebird promises with Mongoose, to do that, use this call:

    const mongoose = require('mongoose');
    mongoose.Promise = require('bluebird');

all answers are correct but the easiest way is to use modern async await approach..

    async ()=> {
    const requiresUser = await User.findByIdAndUpdate(userId,{name:'noname'},{ new:true}).exec()

What does the exec function do in mongoose

在 Node.js 中，如果您使用的是 Mongoose.js 来与 MongoDB 数据库交互，将字符串转换为ObjectId对象是一项常见的任务，特别是当您需要用字符串形式的 ID 对数据库中的文档进行引用或查询时。Mongoose.js 中内置了一个 `ObjectId` 类型，它是 MongoDB 官方的 `bson` 库的一部分。

假设您得到了一个字符串形式的 ID，如 `'5f8d0d55b54764421b7156d9'`，并希望将其转换为 `ObjectId` 对象，您可以按照以下步骤操作：

1. 首先，确保您已经安装了 mongoose：
   
   ```bash
   npm install mongoose
   ```

2. 在您的 Node.js 代码中，引入 `mongoose` 包，并使用 `mongoose.Types.ObjectId` 来创建一个新的 `ObjectId` 实例：

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

   // 假设我们有一个字符串形式的 ID
   const idString = '5f8d0d55b54764421b7156d9';

   // 使用 mongoose 的 Types.ObjectId 方法来转换
   const objectId = mongoose.Types.ObjectId(idString);

   console.log(objectId); // 这将输出一个有效的 ObjectId 对象
   ```

3. 确保传入的字符串是有效的 ObjectId 字符串。它应该是一个24个字符长的字符串，包含 12 字节的数据（通常是16进制表示的）。

如果您传入的字符串不是有效的 ObjectId，Mongoose 会抛出一个错误提示。在实际应用中，您可能需要对这种情况进行处理，例如：

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

const idString = 'invalid-object-id';

try {
  const objectId = mongoose.Types.ObjectId(idString);
  console.log(objectId);
} catch (error) {
  console.error('Error converting string to ObjectId:', error.message);
}
```

确保您捕获并妥善处理任何可能因无效的字符串输入而抛出的错误，以避免在您的应用程序中引入 bug。

你可以这样做：

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

你也可以用这个

    const { ObjectId } = require('mongodb');
    const _id = ObjectId("4eb6e7e7e9b7f4194e000001");
    

这是最简单的方法

你可以这样做：

    var mongoose = require('mongoose');
    var _id = mongoose.mongo.BSONPure.ObjectID.fromHexString("4eb6e7e7e9b7f4194e000001");
    

编辑：新标准有 fromHexString 而不是 fromString

从评论来看，您正在寻找：

    mongoose.mongo.BSONPure.ObjectID.isValid
    

或者

    mongoose.Types.ObjectId.isValid

var mongoose = require('mongoose');
    var _id = mongoose.mongo.ObjectId("4eb6e7e7e9b7f4194e000001");

How to transform the string to objectid function in mongoose

当您在Mongoose中定义模式时，`created_at`和`updated_at`字段通常用于跟踪记录的创建和最后更新时间。要在Mongoose中添加这两个字段，您可以使用内置的`timestamps`选项，它会自动为您的模式添加这两个字段。以下是一个如何在Mongoose模式中实现它的示例：

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

const Schema = mongoose.Schema;

// 定义模式
const exampleSchema = new Schema({
  // 模式的其他字段
  name: {
    type: String,
    required: true
  },
  description: {
    type: String
  }
  // 您不需要显式添加created_at和updated_at字段
}, {
  timestamps: true // 这将会自动添加created_at和updated_at字段
});

// 创建模型
const ExampleModel = mongoose.model('Example', exampleSchema);

module.exports = ExampleModel;
```

在这个例子中，`timestamps`选项被设置为`true`，这告诉Mongoose自动为每个模式实例添加`createdAt`和`updatedAt`字段。当您创建一个新的文档时，Mongoose会自动设置`createdAt`和`updatedAt`字段的值为当前时间戳。当您更新文档时，只有`updatedAt`字段会被更新为最新的时间戳。

默认情况下，这些字段被命名为`createdAt`和`updatedAt`。如果您想要自定义这些字段的名称，可以通过传递一个包含`createdAt`和`updatedAt`属性的对象来实现：

```javascript
const exampleSchema = new Schema({
  // 模式的其他字段
  name: {
    type: String,
    required: true
  },
  description: {
    type: String
  }
}, {
  timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' } // 自定义字段名称
});
```

通过使用`timestamps`选项，您可以确保每次创建或更新文档时，这些字段都会自动得到处理，这样可以在不增加额外代码的情况下轻松跟踪文档的历史。

**更新：**（5年后）

> **注意：**如果您决定使用[Kappa 架构](http://milinda.pathirage.org/kappa-architecture.com/)（_事件溯源 + CQRS_），那么您根本不需要更新日期。由于您的数据是不可变的、仅附加的事件日志，因此您只需要事件创建日期。类似于_Lambda 架构_，如下所述。那么您的应用程序状态是事件日志（派生数据）的投影。如果您收到有关现有实体的后续事件，则您将使用该事件的创建日期作为实体的更新日期。这是微服务系统中常用（且常被误解）的做法。

**更新：**（4年后）

如果您使用`ObjectId`作为您的`_id`字段（通常是这种情况），那么您需要做的就是：

    let document = {
      updatedAt: new Date(),
    }
    

检查下面我的原始答案，了解如何从`_id`字段获取创建的时间戳。如果您需要使用外部系统的 ID，请查看 Roman Rhrn Nesterov 的答案。

**更新：**（2.5年后）

现在，您可以将[#timestamps](http://mongoosejs.com/docs/guide.html#timestamps)选项与 mongoose 版本 >= 4.0 一起使用。

    let ItemSchema = new Schema({
      name: { type: String, required: true, trim: true }
    },
    {
      timestamps: true
    });
    

如果设置时间戳、猫鼬分配`createdAt`和`updatedAt`字段到您的模式，分配的类型是`Date`。

您还可以指定时间戳字段的名称：

    timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' }
    

> **注意：**如果您正在开发包含关键数据的大型应用程序，您应该重新考虑更新文档。我建议您使用不可变的、仅附加的数据（[lambda 架构](https://en.wikipedia.org/wiki/Lambda_architecture)）。这意味着您只允许插入。**不允许更新和删除！**如果您想“删除”一条记录，您可以轻松插入带有某些`timestamp`/的文档的新版本`version` ，然后将`deleted`字段设置为`true`。类似地，如果您想更新文档 - 您创建一个新文档，更新相应的字段并复制其余字段。然后，为了查询该文档，您将获得具有最新时间戳或最高版本的文档，即未“删除”（该`deleted`字段未定义或 false\`）。
> 
> 数据不变性确保您的数据是可调试的——您可以跟踪每个文档的历史记录。如果出现问题，您还可以回滚到文档的先前版本。如果您采用这样的架构`ObjectId.getTimestamp()`就足够了，并且它不依赖于 Mongoose。

* * *

**原答案：**

如果您使用 ObjectId 作为身份字段，则不需要`created_at`字段。ObjectIds 有一个名为 的方法`getTimestamp()`。

ObjectId("507c7f79bcf86cd7994f6c0e").getTimestamp()

这将返回以下输出：

ISODate("2012-10-15T21:26:17Z")

更多信息请点击这里[如何从 Mongo ObjectID 中提取创建日期](https://stackoverflow.com/questions/7327296/how-do-i-extract-the-created-date-out-of-a-mongo-objecti)

为了添加`updated_at`字段，您需要使用以下命令：

    var ArticleSchema = new Schema({
      updated_at: { type: Date }
      // rest of the fields go here
    });
    
    ArticleSchema.pre('save', function(next) {
      this.updated_at = Date.now();
      next();
    });

从 Mongoose 4.0 开始，您现在可以在 Schema 上设置时间戳选项，让 Mongoose 为您处理此问题：

    var thingSchema = new Schema({..}, { timestamps: true });
    

您可以更改所使用字段的名称，如下所示：

    var thingSchema = new Schema({..}, { timestamps: { createdAt: 'created_at' } });
    

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

这就是我最终所做的：

    var ItemSchema = new Schema({
        name    : { type: String, required: true, trim: true }
      , created_at    : { type: Date }
      , updated_at    : { type: Date }
    });
    
    
    ItemSchema.pre('save', function(next){
      now = new Date();
      this.updated_at = now;
      if ( !this.created_at ) {
        this.created_at = now;
      }
      next();
    });

使用您的架构的内置`timestamps`选项。

    var ItemSchema = new Schema({
        name: { type: String, required: true, trim: true }
    },
    {
        timestamps: true
    });
    

这会自动将`createdAt`和`updatedAt`字段添加到您的架构中。

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

像这样添加`timestamps`到你的然后会自动为你生成`Schema``createdAt``updatedAt`

    var UserSchema = new Schema({
        email: String,
        views: { type: Number, default: 0 },
        status: Boolean
    }, { timestamps: {} });
    

[![在此输入图像描述](https://i.stack.imgur.com/pLmsj.png)](https://i.stack.imgur.com/pLmsj.png)  
您也可以`createdAt -> created_at`通过以下方式更改

    timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' }

How to add created at and updated at fields to mongoose schemas?

Mongoose 中的 `__v` 字段是一个隐藏字段，它代表了文档的版本号。这个字段由 Mongoose 在内部使用，主要目的是为了支持文档的版本控制，使用乐观锁定机制来避免并发修改时的冲突。

每当在 Mongoose 中创建或保存文档时，如果该文档包含数组字段，并且执行了会修改数组的操作（例如，添加或删除元素），Mongoose 会自动更新这个 `__v` 字段的值。这样，当多个用户或进程同时尝试修改同一文档时，Mongoose 可以通过检查 `__v` 字段的值来确定文档是否已经被其他方修改过，从而决定是否允许当前的修改操作继续执行。

这个版本号是自动维护的，开发者通常不需要手动修改它。当然，如果不需要这个字段，也可以在定义 Mongoose Schema 时通过选项 `{ versionKey: false }` 禁用它。

例如，如果我们定义一个简单的用户模型，并希望禁用 `__v` 字段，我们可以这样做：

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

const userSchema = new Schema({
  name: String,
  email: String,
  password: String
}, { versionKey: false }); // 禁用 __v 字段

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

但在大多数情况下，开发者都保留这个字段，以便可以利用其提供的并发修改控制的功能。

从[这里](http://mongoosejs.com/docs/guide.html#versionKey)：

> 这`versionKey`是 Mongoose 首次创建每个文档时设置的属性。该键值包含文档的内部修订。该文档属性的名称是可配置的。默认为`__v`.
> 
> 如果这与您的应用程序冲突，您可以这样配置：

    new Schema({..}, { versionKey: '_somethingElse' })

好吧，我看不到托尼的解决方案……所以我必须自己处理……

* * *

如果您不需要 version\_key，您可以：

    var UserSchema = new mongoose.Schema({
        nickname: String,
        reg_time: {type: Date, default: Date.now}
    }, {
        versionKey: false // You should be aware of the outcome after set to false
    });
    

将 versionKey 设置为 false 意味着文档不再受版本控制。

如果文档包含子文档数组，则会出现问题。可以删除其中一个子文档，从而减小数组的大小。稍后，另一个操作可以访问数组中原始位置的子文档。

由于数组现在较小，因此可能会意外访问数组中的错误子文档。

versionKey 通过将文档与 versionKey 相关联来解决这个问题，mongoose 在内部使用 versionKey 来确保它访问正确的集合版本。

更多信息请访问：[http://aaronheckmann.blogspot.com/2012/06/mongoose-v3-part-1-versioning.html](http://aaronheckmann.blogspot.com/2012/06/mongoose-v3-part-1-versioning.html)

要在 NestJS 中删除，需要向`Schema()`装饰器添加选项

    @Schema({ versionKey: false })

如果不需要，可以禁用版本密钥。

看这个例子：

    var User = new mongoose.Schema({
       FullName:{
           type :String,
          
       },
       BirthDay:{
           type :String,
           
       },
       Address:{
           type :String,
       },
       Gender:{
           type:String,
       },
       PhoneNumber:{
           type:Number,
           ref:'Account'
       },
       AccountID:{
            type: Schema.Types.ObjectId,
            ref: 'Account'
       },
       UserName:{
           type:String,
           ref:'Account'
       }
    },{collection:'User',
       versionKey: false //here
    });

我们“文档”中的“\_\_v”字段服务于“ **optimisticConcurrency”**问题。

这个术语在 mongoose 中基本上意味着：让您通过“findOne, findById”抓取文档，但**尚未**使用 mongoose 的 save() 方法。如果在此时间间隔内，任何其他代码获取相同的文档并在第一个文档实例之前使用 .save() 方法，该怎么办？在这个用例中，如果我们想（特定于猫鼬）抛出版本错误之类的事情，我们`optimisticConcurrency: true`在模式中使用选项。

**然后 mongoose 将使用 '\_\_v1' 来比较这两个文档。**

没有`optimisticConcurrency: true`选择。'\_\_v' 没有效果。并且 mongoose 不会将其增加 1。

注意：在“findOneAndUpdate”类似操作中，不会更新“\_\_v”。（仅 save() 更新）

What is the " __v " field in Mongoose

MongoDB 是一个非关系型数据库管理系统，也被称为NoSQL数据库，它使用文档存储和JSON样式的查询语言，非常适合处理大量数据和高并发的场景。MongoDB 存储数据的基本单元是文档（Document），这些文档被组织在集合（Collection）中，一个集合相当于关系数据库中的表（Table）。MongoDB 的主要特点包括横向可扩展性、灵活的文档模型以及支持复杂的查询操作。

Mongoose 则是一个运行在Node.js环境下的对象数据模型（ODM）库，用于连接Node.js应用与MongoDB数据库。它的主要功能是提供了一套简洁的Schema定义接口、中间件处理逻辑和数据验证功能，使得开发者可以用类似于传统ORM框架的方式来处理MongoDB文档数据。Mongoose通过定义Schema来管理数据结构，并提供了一系列的方法和属性，使得在Node.js中操作MongoDB变得更加直观和方便。

举例来说，假设我们需要在一个博客系统中存储用户信息，使用MongoDB，我们直接操作数据库来插入、查询、更新或删除文档。而使用Mongoose，我们会先定义一个用户的Schema，指定字段及其类型，然后基于这个Schema创建一个模型（Model），通过这个模型来进行数据的CRUD操作。这样的好处是，我们的操作是类型安全的，并且可以很方便地进行数据验证和中间件处理。简而言之，Mongoose作为一个抽象层存在，为MongoDB的操作提供了更多的结构和简便性。

例如，使用Mongoose时，定义用户模型代码可能如下：

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

const userSchema = new Schema({
  username: {
    type: String,
    required: true,
    unique: true
  },
  password: {
    type: String,
    required: true
  },
  email: {
    type: String,
    required: true,
    unique: true
  }
});

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

module.exports = User;
```

然后，我们可以用这个模型来创建新用户，如下：

```javascript
const User = require('./path/to/user.model');

const newUser = new User({
  username: 'johndoe',
  password: '123456',
  email: 'johndoe@example.com'
});

newUser.save()
  .then(() => console.log('User created!'))
  .catch(error => console.error('Error creating user:', error));
```

在这个例子中，Mongoose会处理数据的验证，保证存入数据库的数据符合我们预先定义的Schema。而如果直接使用MongoDB，我们需要手动编写这些验证逻辑。

我假设您已经知道 MongoDB 是一个 NoSQL 数据库系统，它以 BSON 文档的形式存储数据。然而，您的问题是关于 Node.js 的包。

就 Node.js 而言，[mongodb](https://www.npmjs.com/package/mongodb)是与 mongodb 实例交互的**本机驱动程序，** [mongoose](https://www.npmjs.com/package/mongoose)是 MongoDB 的**对象建模工具。**

`mongoose`构建在`mongodb`驱动程序之上，为程序员提供一种对其数据进行建模的方法。

**编辑：** 我不想评论哪个更好，因为这会使这个答案变得固执己见。不过，我将列出使用这两种方法的一些优点和缺点。

使用`mongoose`，用户可以定义特定集合中文档的架构。它为MongoDB中数据的创建和管理提供了很多便利。不利的一面是，学习猫鼬可能需要一些时间，并且在处理非常复杂的模式方面有一些限制。

但是，如果您的集合模式不可预测，或者您希望在 Node.js 中获得类似 Mongo-shell 的体验，那么请继续使用该`mongodb`驱动程序。这是最简单的拾取方式。这样做的缺点是您必须编写大量代码来验证数据，并且出错的风险更高。

Mongo 是 NoSQL 数据库。

如果您不想对数据模型使用任何[ORM ，那么您还可以使用本机驱动程序 mongo.js：https:](https://en.wikipedia.org/wiki/Object-relational_mapping) [//github.com/mongodb/node-mongodb-native](https://github.com/mongodb/node-mongodb-native)。

Mongoose 是 Orm 之一，它为我们提供了通过易于理解的查询来访问 mongo 数据的功能。

Mongoose 充当数据库模型的抽象角色。

我发现两者的另一个区别是，它相当容易使用，`connect to multiple databases`但`mongodb native driver`您必须使用`mongoose`仍然存在一些缺点的解决方法。

因此，如果您想要多租户应用程序，请选择 mongodb 本机驱动程序。

从第一个答案来看，

“使用 Mongoose，用户可以为特定集合中的文档定义模式。它为 MongoDB 中的数据创建和管理提供了很多便利。”

您现在还可以使用 mongoDB 本机驱动程序定义架构

##新系列

    db.createCollection("recipes",
        validator: { $jsonSchema: {
             <<Validation Rules>>
            }
        }
    )
    

##对于现有集合

    db.runCommand({
        collMod: "recipes",
        validator: { $jsonSchema: {
             <<Validation Rules>>
            }
        }
    })
        
    

##完整示例

    db.createCollection("recipes", {
      validator: {
        $jsonSchema: {
          bsonType: "object",
          required: ["name", "servings", "ingredients"],
          additionalProperties: false,
          properties: {
            _id: {},
            name: {
              bsonType: "string",
              description: "'name' is required and is a string"
            },
            servings: {
              bsonType: ["int", "double"],
              minimum: 0,
              description:
                "'servings' is required and must be an integer with a minimum of zero."
            },
            cooking_method: {
              enum: [
                "broil",
                "grill",
                "roast",
                "bake",
                "saute",
                "pan-fry",
                "deep-fry",
                "poach",
                "simmer",
                "boil",
                "steam",
                "braise",
                "stew"
              ],
              description:
                "'cooking_method' is optional but, if used, must be one of the listed options."
            },
            ingredients: {
              bsonType: ["array"],
              minItems: 1,
              maxItems: 50,
              items: {
                bsonType: ["object"],
                required: ["quantity", "measure", "ingredient"],
                additionalProperties: false,
                description: "'ingredients' must contain the stated fields.",
                properties: {
                  quantity: {
                    bsonType: ["int", "double", "decimal"],
                    description:
                      "'quantity' is required and is of double or decimal type"
                  },
                  measure: {
                    enum: ["tsp", "Tbsp", "cup", "ounce", "pound", "each"],
                    description:
                      "'measure' is required and can only be one of the given enum values"
                  },
                  ingredient: {
                    bsonType: "string",
                    description: "'ingredient' is required and is a string"
                  },
                  format: {
                    bsonType: "string",
                    description:
                      "'format' is an optional field of type string, e.g. chopped or diced"
                  }
                }
              }
            }
          }
        }
      }
    });
    

插入集合示例

    db.recipes.insertOne({
      name: "Chocolate Sponge Cake Filling",
      servings: 4,
      ingredients: [
        {
          quantity: 7,
          measure: "ounce",
          ingredient: "bittersweet chocolate",
          format: "chopped"
        },
        { quantity: 2, measure: "cup", ingredient: "heavy cream" }
      ]
    });

Mongodb 和 Mongoose 是与 MongoDB 数据库交互的两个不同的驱动程序。

**Mongoose**：对象数据建模（ODM）库，为您的数据提供严格的建模环境。用于与 MongoDB 交互，通过提供管理数据的便利使生活变得更轻松。

**Mongodb**：Node.js 中用于与 MongoDB 交互的本机驱动程序。

What is the difference between mongodb and mongoose

Elasticsearch 在默认情况下并没有设置用户权限认证机制。但从5.x版本开始，Elastic Stack 引入了 X-Pack 插件，随后在7.x版本中，Elasticsearch 和Kibana 的基本安全特性被默认启用在了基本版中，这一特性包括了密码保护。

当你首次安装 Elasticsearch 时，你需要初始化内置用户的密码。Elasticsearch拥有几个内置用户，例如 `elastic`、`kibana` 和 `logstash_system` 等。其中，`elastic` 用户是超级用户，可以用来登录 Kibana 和操作 Elasticsearch 集群。

在启用了基本安全特性的 Elasticsearch 版本中，没有默认密码。相反，你需要在设置过程中使用 `elasticsearch-setup-passwords` 命令来为内置用户设置密码。例如，通过以下命令可以为所有内置用户设置密码：

```bash
bin/elasticsearch-setup-passwords auto
```

该命令会为每个内置用户生成随机密码，并在命令行中显示。另外，也可以使用交互式命令 `interactive` 来为每个用户设置你想要的密码。

如果是Elasticsearch集群的Docker容器实例，也可以通过设置环境变量 `ELASTIC_PASSWORD` 来指定 `elastic` 用户的密码。

请注意，出于安全原因，应该避免使用默认密码或弱密码，并且在部署的时候应该为所有的内置用户设置强密码。此外，对于生产环境，最好遵循最小权限原则配置用户角色，以降低安全风险。

[默认值是](https://www.elastic.co/guide/en/x-pack/current/security-getting-started.html)：

    user: elastic
    password: changeme
    

所以：

    $ curl -u elastic:changeme localhost:9200
    {
      "name" : "5aEHJ-Y",
      "cluster_name" : "docker-cluster",
      "cluster_uuid" : "3FmaYN7rS56oBTqWOyxmKA",
      "version" : {
        "number" : "5.6.2",
        "build_hash" : "57e20f3",
        "build_date" : "2017-09-23T13:16:45.703Z",
        "build_snapshot" : false,
        "lucene_version" : "6.6.1"
      },
      "tagline" : "You Know, for Search"
    }
    

了解有关[更改默认值的](https://www.elastic.co/guide/en/x-pack/current/security-getting-started.html)更多信息。

设置Elastic Search的用户名和密码：（ES版本：7.5.2）（Ubuntu 18.04）
--------------------------------------------------

步骤1：首先在elasticsearch.yml文件中启用xpackmonitoring

    root@flax:/etc/elasticsearch# vim elasticsearch.yml
    
    Add the following line to the end of file:
        xpack.security.enabled: true
    
    File Contents:
    # ======================== Elasticsearch Configuration =========================
    #
    # NOTE: Elasticsearch comes with reasonable defaults for most settings.
    #       Before you set out to tweak and tune the configuration, make sure you
    #       understand what are you trying to accomplish and the consequences.
    #
    # The primary way of configuring a node is via this file. This template lists
    # the most important settings you may want to configure for a production cluster.
    #
    # Please consult the documentation for further information on configuration options:
    # https://www.elastic.co/guide/en/elasticsearch/reference/index.html
    #
    # ---------------------------------- Cluster -----------------------------------
    #
    # Use a descriptive name for your cluster:
    #
    #cluster.name: my-application
    #
    # ------------------------------------ Node ------------------------------------
    #
    # Use a descriptive name for the node:
    #
    #node.name: node-1
    #
    # Add custom attributes to the node:
    #
    #node.attr.rack: r1
    #
    # ----------------------------------- Paths ------------------------------------
    #
    # Path to directory where to store the data (separate multiple locations by comma):
    #
    path.data: /var/lib/elasticsearch
    #
    # Path to log files:
    #
    path.logs: /var/log/elasticsearch
    #
    # ----------------------------------- Memory -----------------------------------
    #
    # Lock the memory on startup:
    #
    #bootstrap.memory_lock: true
    #
    # Make sure that the heap size is set to about half the memory available
    # on the system and that the owner of the process is allowed to use this
    # limit.
    #
    # Elasticsearch performs poorly when the system is swapping the memory.
    #
    # ---------------------------------- Network -----------------------------------
    #
    # Set the bind address to a specific IP (IPv4 or IPv6):
    #
    #network.host: 192.168.0.1
    network.host: 127.0.0.1
    http.host: 0.0.0.0
    #
    # Set a custom port for HTTP:
    #
    http.port: 9200
    #
    # For more information, consult the network module documentation.
    #
    # --------------------------------- Discovery ----------------------------------
    #
    # Pass an initial list of hosts to perform discovery when this node is started:
    # The default list of hosts is ["127.0.0.1", "[::1]"]
    #
    #discovery.seed_hosts: ["host1", "host2"]
    #
    # Bootstrap the cluster using an initial set of master-eligible nodes:
    #
    #cluster.initial_master_nodes: ["node-1", "node-2"]
    #
    # For more information, consult the discovery and cluster formation module documentation.
    #
    # ---------------------------------- Gateway -----------------------------------
    #
    # Block initial recovery after a full cluster restart until N nodes are started:
    #
    #gateway.recover_after_nodes: 3
    #
    # For more information, consult the gateway module documentation.
    #
    # ---------------------------------- Various -----------------------------------
    #
    # Require explicit names when deleting indices:
    #
    #action.destructive_requires_name: true
    xpack.security.enabled: true
    

步骤 2：转到 /usr/share/elasticsearch 文件夹：

    root@flax:/usr/share/elasticsearch# systemctl start elasticsearch
    
    root@flax:/usr/share/elasticsearch# ./bin/elasticsearch-setup-passwords interactive
    
    Initiating the setup of passwords for reserved users elastic,apm_system,kibana,logstash_system,beats_system,remote_monitoring_user.
    You will be prompted to enter passwords as the process progresses.
    Please confirm that you would like to continue [y/N]y
    
    
    Enter password for [elastic]: 
    Reenter password for [elastic]: 
    Enter password for [apm_system]: 
    Reenter password for [apm_system]: 
    Enter password for [kibana]: 
    Reenter password for [kibana]: 
    Enter password for [logstash_system]: 
    Reenter password for [logstash_system]: 
    Enter password for [beats_system]: 
    Reenter password for [beats_system]: 
    Passwords do not match.
    Try again.
    Enter password for [beats_system]: 
    Reenter password for [beats_system]: 
    Enter password for [remote_monitoring_user]: 
    Reenter password for [remote_monitoring_user]: 
    Changed password for user [apm_system]
    Changed password for user [kibana]
    Changed password for user [logstash_system]
    Changed password for user [beats_system]
    Changed password for user [remote_monitoring_user]
    Changed password for user [elastic]
    
    root@flax:/usr/share/elasticsearch# systemctl restart elasticsearch
    
    root@flax:/usr/share/elasticsearch# systemctl restart elasticsearch.service

请注意ElasticSearch的版本。在**7.2**参数 ELASTIC\_PASSWORD 中起作用。

    docker run -p 9200:9200 \
               -p 9300:9300 \
               -e "discovery.type=single-node" \ 
               -e "ELASTIC_PASSWORD=my_own_password" \
    

但也应该在 elasticsearch.yml 中添加这一行：

    xpack.security.enabled: true
    

默认情况下，它不存在。

[安全设置列表](https://www.elastic.co/guide/en/elasticsearch/reference/current/security-settings.html#general-security-settings)

如果您在elasticsearch 7.7版本中启用了基本的x-pack安全性`xpack.security.enabled: true`（在撰写本答案时），它将不会`changeme`像旧版本的x-pack中那样具有默认密码（）。

正如[安全入门官方文档中提到的](https://www.elastic.co/guide/en/x-pack/6.2/security-getting-started.html)

> X-Pack 安全性提供了一个内置的弹性超级用户，您可以使用它来开始设置。该elastic用户拥有集群的完全访问权限，包括所有索引和数据，**因此elastic用户默认没有设置密码。**

所以您需要更改密码`elastic`，如果您想在安装后更改密码，请按照[交互模式指南中的内置用户设置密码进行操作](https://www.elastic.co/guide/en/elasticsearch/reference/current/built-in-users.html#set-built-in-user-passwords)

这需要您从 elasticsearch bin 文件夹运行以下命令。

    bin/elasticsearch-setup-passwords interactive

**设置用户名和密码**

ssh到系统，停止elasticsearch和kibana服务，然后运行以下命令

    sudo nano /etc/elasticsearch/elasticsearch.yml
    

更新此文件，通过添加以下行来启用安全性

    xpack.security.enabled: true 
    

**更改密码**

执行以下步骤更改密码

步骤1：

     cd /usr/share/elasticsearch/
    

第2步：

    sudo bin/elasticsearch-setup-passwords auto
    

> 自动 - 使用随机生成的密码 交互式 - 使用用户输入的密码

或者

    sudo bin/elasticsearch-setup-passwords interactive
    

> 您可以在“交互”模式下运行该命令，该模式会提示您输入elastic、kibana\_system、logstash\_system、beats\_system、apm\_system和remote\_monitoring\_user用户的新密码：

以上命令可以帮助您设置密码

**启动弹性搜索**

1.  通过运行 systemctl 命令启动 Elasticsearch 服务：
    
    sudo systemctl启动elasticsearch.service
    

系统启动该服务可能需要一些时间。如果成功的话不会有任何输出。

2.  启用 Elasticsearch 在启动时启动：
    
    sudo systemctl 启用elasticsearch.service
    

**启动并启用 Kibana**

1.  启动 Kibana 服务：
    
    sudo systemctl 启动 kibana
    

如果服务启动成功，则没有任何输出。

2.  接下来，将 Kibana 配置为在启动时启动：
    
    sudo systemctl 启用 kibana

What is the default user and password for elasticsearch

在 Elasticsearch 中，插入数据通常是通过 HTTP PUT 或 POST 请求向所选索引提交 JSON 格式的文档来实现的。以下是插入数据的几种常见方法：

### 使用 HTTP PUT 插入单个文档

如果你已经知道你想要插入的文档的ID，可以使用PUT方法直接插入。例如：

```http
PUT /index_name/_doc/document_id
{
  "field1": "value1",
  "field2": "value2",
  ...
}
```

在这个例子中，`index_name` 是你想要插入文档的索引名称，`_doc` 是文档类型（在Elasticsearch 7.x之后已经废弃），`document_id` 是这个文档的唯一标识符，紧随其后的是要插入的JSON格式的文档内容。

### 使用 HTTP POST 插入单个文档

如果你不关心文档的ID，Elasticsearch可以为你自动生成一个。你可以使用POST方法来完成：

```http
POST /index_name/_doc
{
  "field1": "value1",
  "field2": "value2",
  ...
}
```

在这个例子中，Elasticsearch将自动生成文档ID，并且插入提供的数据。

### 批量插入文档

当需要插入多个文档时，可以使用Elasticsearch的批量API（_bulk API）来提高效率。这样可以在一个请求中插入多个文档，示例如下：

```http
POST /_bulk
{ "index" : { "_index" : "index_name", "_id" : "1" } }
{ "field1" : "value1" }
{ "index" : { "_index" : "index_name", "_id" : "2" } }
{ "field1" : "value2" }
...
```

批量API接受一系列操作，每个操作由两行组成：第一行指定操作和元数据（如`_index`和`_id`），第二行包含实际的文档数据。

### 使用客户端库

除了直接使用HTTP请求，许多开发人员更喜欢使用客户端库来与Elasticsearch交互。这种方式提供了更方便的API和错误处理。以JavaScript为例，使用官方的`elasticsearch`客户端库可以这样插入数据：

```javascript
const { Client } = require('@elastic/elasticsearch');
const client = new Client({ node: 'http://localhost:9200' });

client.index({
  index: 'index_name',
  id: 'document_id',
  body: {
    field1: 'value1',
    field2: 'value2',
    ...
  }
}, (err, result) => {
  if (err) console.log(err);
  console.log(result);
});
```

在这个例子中，我们创建了一个Elasticsearch客户端实例，然后使用其`index`方法插入一个文档。可以指定文档ID，也可以让Elasticsearch自动生成。

总结来说，插入数据到Elasticsearch通常涉及发送含有JSON文档的HTTP请求到适当的索引上，无论是单个文档还是批量文档。客户端库可用于简化这个过程，并提供更加方便和健壮的编程接口。

您必须`curl`首先在 PC 上安装二进制文件。[你可以在这里](http://curl.haxx.se/gknw.net/7.29.0/dist-w32/curl-7.29.0-rtmp-ssh2-ssl-sspi-zlib-idn-static-bin-w32.zip)下载。

之后将其解压缩到一个文件夹中。可以说`C:\curl`。在该文件夹中，您会发现`curl.exe`包含多个`.dll`文件的文件。

`cmd`现在，通过从 .txt 文件中键入内容来打开命令提示符`start menu`。然后`cd c:\curl`在那里输入，它会带你到curl文件夹。现在执行`curl`您拥有的命令。

一件事是，Windows 不支持字段周围的单引号。所以你必须使用双引号。例如，我已将您的curl 命令转换为适当的命令。

    curl -H "Content-Type: application/json" -XPOST "http://localhost:9200/indexname/typename/optionalUniqueId" -d "{ \"field\" : \"value\"}"

如果您将 Kibana 与 Elasticsearch 一起使用，那么您可以使用下面的 REST 请求来创建并放入索引。

创建索引
----

    http://localhost:9200/company
    PUT company
    {
      "settings": {
        "index": {
          "number_of_shards": 1,
          "number_of_replicas": 1
        },
        "analysis": {
          "analyzer": {
            "analyzer-name": {
              "type": "custom",
              "tokenizer": "keyword",
              "filter": "lowercase"
            }
          }
        }
      },
      "mappings": {
        "employee": {
          "properties": {
            "age": {
              "type": "long"
            },
            "experience": {
              "type": "long"
            },
            "name": {
              "type": "text",
              "analyzer": "analyzer-name"
            }
          }
        }
      }
    }
    

创建文档
----

    POST http://localhost:9200/company/employee/2/_create
    {
    "name": "Hemani",
    "age" : 23,
    "experienceInYears" : 2
    }

让我清楚地解释一下..如果您熟悉rdbms..索引是数据库..索引类型是表..这意味着索引是索引类型的集合.，就像数据库（DB）中的表集合一样。

在NOSQL中..索引是数据库，索引类型是集合。作为数据库的集合组..

要执行这些查询...您需要安装适用于 Windows 的 CURL。

Curl只不过是一个命令行休息工具..如果你想要一个图形工具..尝试

Chrome 的 Sense 插件...

希望能帮助到你..

要测试和尝试来自 Windows 的curl 请求，您可以使用 Postman 客户端 Chrome 扩展。它使用起来非常简单，而且功能非常强大。

或者按照建议您可以安装 cURL 实用程序。

示例卷曲请求如下。

    curl -X POST -H "Content-Type: application/json" -H "Cache-Control: no-cache" -d '{
    "user" : "Arun Thundyill Saseendran",
    "post_date" : "2009-03-23T12:30:00",
    "message" : "trying out Elasticsearch"
    }' "http://10.103.102.56:9200/sampleindex/sampletype/"
    

我也在广泛地开始和探索 ES。因此，如果您还有任何其他疑问，请告诉我。

编辑：将索引名称和类型名称更新为完全小写以避免错误并遵循约定。

我开始使用`curl`，但后来迁移到使用`kibana`。以下是来自elastic.co（E elastic search、K kibana）的有关 ELK 堆栈的更多信息： https: [//www.elastic.co/elk-stack](https://www.elastic.co/elk-stack)

使用 kibana，您的`POST`请求会更简单一些：

    POST /<INDEX_NAME>/<TYPE_NAME>
    {
        "field": "value",
        "id": 1,
        "account_id": 213,
        "name": "kimchy"
    }

How to insert data into elasticsearch

在Elasticsearch中，索引的名称一旦创建之后是不能直接修改的，但是您可以通过创建索引的别名（alias）或重新索引（reindexing）的方法来间接"重命名"索引。

### 方法一：使用别名（Alias）

虽然不能直接重命名索引，但是您可以给索引创建一个或多个别名，这样可以通过新的别名来访问原有的索引。

创建别名的步骤如下：

1. 使用`POST`或者`PUT`请求为现有索引创建别名：

```json
POST /_aliases
{
  "actions": [
    {
      "add": {
        "index": "原始索引名",
        "alias": "新的别名"
      }
    }
  ]
}
```

2. 确认别名已被创建，并可以通过它访问数据。

3. 可选的，您可以删除旧的索引名，但这样做前要确保所有写入和读取操作都已经切换到了新的别名。

### 方法二：重新索引（Reindexing）

如果您需要更彻底地改名，可以使用重新索引的方法。这涉及到将旧索引中的数据复制到一个新的索引中，然后您可以根据需要删除旧的索引。

重新索引的步骤如下：

1. 创建新的索引，并指定所需的设置和映射。

2. 使用 `_reindex` API 将旧索引的数据复制到新索引：

```json
POST /_reindex
{
  "source": {
    "index": "旧索引名"
  },
  "dest": {
    "index": "新索引名"
  }
}
```

3. 在重新索引完成后，确保新索引已正确地包含了所有的数据。

4. 更新所有应用程序和服务，以使用新的索引名称。

5. 删除旧的索引（如果确定不再需要）：

```json
DELETE /旧索引名
```

**注意：** 重命名索引（特别是重新索引）是一个可能会消耗时间和资源的过程，对于大型索引或生产环境，需要谨慎进行，并考虑到可能的停机时间、数据一致性问题以及对正在进行的查询和索引操作的影响。在生产环境中，可能需要在低流量时段进行此操作，并确保有完整的备份以防万一出错。

您可以使用[REINDEX](https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-reindex.html)来做到这一点。

> 重新索引不会尝试设置目标索引。它不会复制源索引的设置。您应该在运行 \_reindex 操作之前[设置目标索引](https://www.elastic.co/guide/en/elasticsearch/reference/5.2/indices-create-index.html)，包括设置映射、分片计数、副本等。

1.  首先将索引复制到一个新名称

    POST /_reindex
    {
      "source": {
        "index": "twitter"
      },
      "dest": {
        "index": "new_twitter"
      }
    }
    

2.  现在删除索引

    DELETE /twitter

[从 ElasticSearch 7.4 开始，重命名索引的最佳方法是使用新引入的克隆索引 API](https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-clone-index.html)复制索引，然后使用[删除索引 API](https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-delete-index.html)删除原始索引。

与出于相同目的使用快照 API 或重新索引 API 相比，克隆索引 API 的主要优点是速度，因为克隆索引 API 将段从源索引硬链接到目标索引，而无需重新处理其任何内容（在显然，支持硬链接的文件系统；否则，文件在文件系统级别复制，这仍然比替代方案更有效）。克隆索引还保证目标索引在每个点上都与源索引相同（即不需要手动复制设置和映射，这与重新索引方法相反），并且不需要配置本地快照目录。

**_旁注：_**_尽管此过程比以前的解决方案快得多，但它仍然意味着停机时间。有一些实际用例证明重命名索引是合理的（例如，作为拆分、收缩或备份工作流程中的一个步骤），但重命名索引不应该成为日常操作的一部分。如果您的工作流程需要频繁的索引重命名，那么您应该考虑使用[索引别名](https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-aliases.html)。_

`source_index`以下是将索引重命名为 的完整操作序列的示例`target_index`。它可以使用一些 ElasticSearch 特定的控制台来执行，例如集成[在 Kibana 中的](https://www.elastic.co/guide/en/kibana/current/console-kibana.html)控制台。请参阅[此要点](https://gist.github.com/mjameswh/59c1f59497c03a5cf3697eeb6ca2445d)以获取此示例的替代版本，使用`curl`而不是 Elastic Search 控制台。

    # Make sure the source index is actually open
    POST /source_index/_open
    
    # Put the source index in read-only mode
    PUT /source_index/_settings
    {
      "settings": {
        "index.blocks.write": "true"
      }
    }
    
    # Clone the source index to the target name, and set the target to read-write mode
    POST /source_index/_clone/target_index
    {
      "settings": {
        "index.blocks.write": null 
      }
    }
    
    # Wait until the target index is green;
    # it should usually be fast (assuming your filesystem supports hard links).
    GET /_cluster/health/target_index?wait_for_status=green&timeout=30s
    
    # If it appears to be taking too much time for the cluster to get back to green,
    # the following requests might help you identify eventual outstanding issues (if any)
    GET /_cat/indices/target_index
    GET /_cat/recovery/target_index
    GET /_cluster/allocation/explain
    
    # Delete the source index
    DELETE /source_index

要重命名索引，您可以使用 Elasticsearch 快照模块。

首先，您必须拍摄索引的快照。在恢复索引时，您可以重命名索引。

        POST /_snapshot/my_backup/snapshot_1/_restore
        {
         "indices": "jal",
         "ignore_unavailable": "true",
         "include_global_state": false,
         "rename_pattern": "jal",
         "rename_replacement": "jal1"
         }
    

rename\_replacement ：-您要在其中备份数据的新索引名称。

如果无法 REINDEX，**解决方法**是使用_aliases_。来自[官方](https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-aliases.html)文档：

_当针对特定索引工作时，elasticsearch 中的 API 接受索引名称，并在适用时接受多个索引。索引别名 API 允许使用名称为索引添加别名，所有 API 都会自动将别名转换为实际索引名称。一个别名也可以映射到多个索引，指定别名时，别名会自动扩展到别名索引。别名还可以与搜索和路由值时自动应用的过滤器关联。别名不能与索引同名。_

请注意，如果您使用“更多类似此”功能，则此解决方案不起作用。[https://github.com/elastic/elasticsearch/issues/16560](https://github.com/elastic/elasticsearch/issues/16560)

实现重命名或更改索引映射的另一种不同方法是使用 Logstash 重新索引。以下是 Logstash 2.1 配置示例：

    input {
      elasticsearch {
       hosts => ["es01.example.com", "es02.example.com"]
       index => "old-index-name"
       size => 500
       scroll => "5m"
      }
    }
    filter {
    
     mutate {
      remove_field => [ "@version" ]
     }
    
     date {
       "match" => [ "custom_timestamp", "MM/dd/YYYY HH:mm:ss" ]
       target => "@timestamp"
     }
    
    }
    output {
     elasticsearch {
       hosts => ["es01.example.com", "es02.example.com" ]
       manage_template => false
       index => "new-index-name"
     }
    }

How to rename an index in a cluster in elasticsearch

Lucene 和 Elasticsearch 最主要的区别在于它们分别定位于搜索技术的不同层次。Lucene 是一个开源的全文搜索库，可以用来创建搜索引擎，而 Elasticsearch 是基于 Lucene 构建的，它是一个开源的搜索和分析引擎，提供了分布式多用户能力的全文搜索引擎，附带了 HTTP web 接口和无模式 JSON 文档的处理。

下面是 Lucene 和 Elasticsearch 之间的一些主要区别：

### Lucene：

1. **核心搜索库**：Lucene 是一个Java库，它提供了全文搜索功能的底层API。它不是一个完整的搜索引擎，而是帮助开发者构建搜索引擎的工具。

2. **基础技术**：它处理索引创建、查询解析、搜索等核心功能。

3. **开发复杂性**：使用 Lucene 需要对索引结构和搜索算法有深刻理解，它需要开发者写更多的代码来处理数据的索引、查询和搜索结果的排名等。

4. **分布式能力**：Lucene 本身不支持分布式搜索，如果需要实现分布式搜索，开发者需要自行实现。

5. **接口**：Lucene 主要通过 Java API 提供服务，对于非Java环境需要额外的封装或者桥接技术。

### Elasticsearch：

1. **完整的搜索引擎**：Elasticsearch 是一个实时的分布式搜索和分析引擎，直接可以用于生产环境。

2. **基于 Lucene**：Elasticsearch 底层利用 Lucene 进行索引和搜索，但提供了简单易用的 RESTful API，开发者可以使用 JSON进行数据索引和查询。

3. **简化操作**：Elasticsearch 简化了复杂的搜索引擎构建过程，提供了现成的解决方案，包括集群管理、数据分析、监控等。

4. **分布式架构**：Elasticsearch 天然支持分布式和扩展，可以轻松处理PB级别的数据。

5. **多语言客户端**：Elasticsearch 提供了多种语言的客户端，方便不同开发环境下的接入和使用。

### 实例应用：

假设我们要为网站开发一个文章搜索功能：

- 如果使用 **Lucene**，我们需要自定义数据模型，建立索引，处理搜索查询，实现排名算法，处理高亮显示等，还需要考虑如何将这些搜索功能集成到网站中。这对开发者的要求很高，因为必须对 Lucene 有深入了解并且能够处理底层的细节。

- 如果使用 **Elasticsearch**，我们可以直接通过 HTTP 请求对文章内容进行索引。当用户在搜索框中输入查询时，我们可以发送一个 HTTP 请求到 Elasticsearch，它会处理查询，并返回格式良好的 JSON 结果，其中包括排名高的文档和高亮的搜索词。这大大简化了搜索系统的开发和维护工作。

_Lucene 是一个**Java 库**_。您可以将其包含在您的项目中并使用函数调用引用其函数。

Elasticsearch 是一个基于_JSON的__分布式__Web 服务器_，基于 Lucene 构建。虽然底层的实际工作是由 Lucene 完成的，但 Elasticsearch 为我们提供了一个基于 Lucene 的便捷层。在 Elasticsearch 中创建的每个分片都是一个单独的 Lucene 实例。所以总结一下

1.  Elasticsearch 基于 Lucene 构建，并提供**_基于 JSON 的 REST API_**来引用 Lucene 功能。
2.  Elasticsearch 提供了一个**_基于 Lucene 的分布式系统_**。Lucene 不知道或构建分布式系统。Elasticsearch 提供了这种分布式结构的抽象。
3.  Elasticsearch 提供其他支持功能，如线程池、队列、节点/集群监控 API、数据监控 API、集群管理等。

除了**@Vineeth Mohan 的**话：

**高可用性：** Elasticsearch 是分布式的，因此它可以管理数据复制，这意味着集群中拥有多个数据副本。这可实现高可用性。

**强大的查询 DSL**：Elasticsearch 为我们提供了 JSON 接口，用于在 Lucene 之上读取和写入查询。借助 Elasticsearch，您可以在不了解 Lucene 语法的情况下编写复杂的查询。

**Schemaless (Schema-Free)：**字段（名称，值对）不必`schema`事先定义。当你索引数据时，elasticsearch 可以在运行时自动创建 schema，就像魔术一样。

我将添加另一个角度来进行讨论。

### Elasticsearch 索引 VS Lucene 索引。

Elasticsearch**索引**是一大块文档，就像关系世界中的数据库由表组成一样。  
为了实现扩展，我们将 Elasticsearch 索引分散到多个物理节点/服务器中。

为此，我们将 Elasticsearch 索引分成更小的单元，称为**分片**。

**问：它和Lucene索引有什么关系？**  
如果我们想要搜索特定术语（例如：“ _Cake_ ”或“ _Cookie_ ”），我们将必须检查每个分片并查找它（让我们先不考虑分片在每个节点上的定位和复制方式）。

这个操作会花费很多时间——所以我们需要使用一个**高效的数据结构来进行这个搜索**——这就是**Lucene的索引**发挥作用的地方。

每个**Elasticsearch分片都基于Lucene索引结构**，并存储有关术语的统计信息，以使基于术语的搜索更加高效。

(!) 这非常令人困惑，因为“索引”一词以及 Elasticsearch 分片是 Elasticsearch 索引的一部分但基于 Lucene 索引的数据结构这一事实。

* * *

### Bonus - Lucene 的索引作为倒排索引

从下面的例子可以看出，Lucene的索引存储了原始文档的内容以及附加信息，例如术语词典和术语频率，这提高了搜索效率：

    Term           Document                 Frequency
    Cake           doc_id_1, doc_id_8       4 (2 in doc_id_1, 2 in doc_id_8)
    Cookie         doc_id_1, doc_id_6       3 (2 in doc_id_1, 1 in doc_id_6)
    Spaghetti      doc_id_12                1 (1 in doc_id_12)
    

Lucene 的索引属于称为倒排索引的索引系列。这是因为它可以针对某个术语列出包含该术语的文档。  
这是自然关系的反面，其中文档列出了术语。

* * *

### （提醒）我们是如何从分片变成术语的？

(1) Shard是包含文档的文件目录。  
(2) 文档是字段的序列。  
(3) 字段是术语的命名序列。

我从使用的角度来回答。

Lucene 是一个搜索引擎**库**。您希望使用它来构建自己的搜索引擎：要么是新的 Elasticsearch 或 Solr 竞争对手，要么是适合您的用例的搜索引擎（例如文本分析）。

Elasticsearch 是一个**搜索引擎**。大多数人将其用于日志聚合、产品搜索或这两者的变体（例如社交媒体分析或根据某些搜索条件查找相关人员）。它构建在 Lucene 之上，因此**公开了其大部分（尽管不是全部）功能**。它还增加了很多东西，最重要的是：

*   休息API
*   查询DSL
*   分布式系统（分片、复制、集群管理）
*   方面/[聚合](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations.html)
*   常见用途（例如[摄取](https://www.elastic.co/guide/en/elasticsearch/reference/current/ingest.html)处理）和管理（用于监控其[相关指标](https://sematext.com/blog/top-10-elasticsearch-metrics-to-watch/)、备份和恢复等的 API）的附加功能

What is the difference between lucene and elasticsearch

在使用Axios进行API请求时，你可能希望对所有请求进行记录，以便进行调试、监控或审计。Axios提供了拦截器（interceptors），这是一种实现统一记录请求调用的非常有效的方式。拦截器允许我们在请求发送到服务器之前和从服务器收到响应之后，但在我们的代码处理响应之前，对它们进行处理。

以下是一个使用Axios拦截器来记录所有请求调用的示例：

```javascript
import axios from 'axios';

// 创建一个记录函数，用于输出请求和响应信息
const logRequestResponse = (url, method, data, response) => {
  console.log(`[Request] ${method.toUpperCase()} ${url}`, data);
  console.log(`[Response]`, response);
};

// 创建Axios实例
const api = axios.create({
  baseURL: 'https://your.api/baseurl' // 假设的API基础URL
});

// 添加请求拦截器
api.interceptors.request.use(
  config => {
    // 在请求发送之前做一些处理
    // 比如可以在这里添加认证Token到headers
    return config;
  },
  error => {
    // 处理请求错误
    return Promise.reject(error);
  }
);

// 添加响应拦截器
api.interceptors.response.use(
  response => {
    // 任何位于2xx范围内的状态码都会触发该函数
    // 对响应数据做些事情
    logRequestResponse(response.config.url, response.config.method, response.config.data, response.data);
    return response;
  },
  error => {
    // 任何超出2xx范围的状态码都会触发该函数
    // 对响应错误做些事情
    if (error.response) {
      // 服务器返回了不在2xx的响应
      logRequestResponse(error.response.config.url, error.response.config.method, error.response.config.data, error.response.data);
    } else if (error.request) {
      // 请求已发出，但没有收到响应
      console.error(`[Axios Error] No response:`, error.request);
    } else {
      // 发送请求时出了点问题
      console.error(`[Axios Error] General error:`, error.message);
    }
    return Promise.reject(error);
  }
);

// 使用api实例进行请求
api.get('/some-endpoint')
  .then(response => {
    // 处理响应
  })
  .catch(error => {
    // 处理错误
  });
```

在上面的代码示例中，我们首先定义了一个`logRequestResponse`函数，它会将请求的URL、方法、数据和响应记录到控制台。然后，我们创建了一个Axios实例并对其添加了请求和响应拦截器。在请求拦截器中，我们暂时没有做太多处理，只是将配置返回，实际情况下可以在这里添加身份验证token或者日志记录等。在响应拦截器中，我们调用`logRequestResponse`函数来记录请求和响应的详细信息。如果请求成功，我们记录响应数据；如果请求失败，我们根据错误的类型来记录不同的信息。

通过上述方法，所有通过这个Axios实例发出的请求都会被记录，这为我们提供了一个强大的工具来跟踪API的调用情况。

做到这一点的最好方法是拦截器。每个拦截器在请求/响应之前被调用。在这种情况下，日志拦截器就是。

    axios.interceptors.request.use(request => {
      console.log('Starting Request', JSON.stringify(request, null, 2))
      return request
    })
    
    axios.interceptors.response.use(response => {
      console.log('Response:', JSON.stringify(response, null, 2))
      return response
    })
    

或类似的东西。

很高兴您使用 axios 的新实例：

    const api = axios.create({
      timeout: 1000
    })
    

这样你就可以打电话

    api.interceptors[...]

使用[`axios-debug-log`](https://www.npmjs.com/package/axios-debug-log)
--------------------------------------------------------------------

1.  `npm install --save axios-debug-log`
2.  `require('axios-debug-log')`在任何 axios 调用之前
3.  设置环境变量`DEBUG=axios`

默认情况下，您将看到如下日志：

      axios POST /api/auth/login +0ms
      axios 200  (POST http://localhost:8080/api/auth/login) +125ms
      axios POST /api/foo +0ms
      axios 200  (POST http://localhost:8080/api/foo) +15ms
    

请参阅[文档](https://www.npmjs.com/package/axios-debug-log)了解配置和自定义选项。

看起来您可以使用“拦截器”拦截所有请求，并登录其中： https: [//github.com/mzabriskie/axios#interceptors](https://github.com/mzabriskie/axios#interceptors)

**使用[axios-logger](https://www.npmjs.com/package/axios-logger)**

当你在nodejs中发送请求时，需要将日志显示到控制台。

您可以尝试将`axios.request`函数包装在 Promise 中。

    function loggedRequest(config) {
      return new Promise((resolve, reject) => {
        axios.request(config)
        .then((res) => {
          // log success, config, res here
          resolve(res);      
        })
        .catch(err => {
          // same, log whatever you want here
          reject(err);
        })
      })
    }

How to log all axios calls from one place in code

当我们谈论跨域资源共享（CORS）问题时，我们指的是一种安全机制，该机制允许或限制在一个域中运行的Web应用程序获取另一个域上托管的资源。默认情况下，浏览器禁止从脚本内发起的跨源HTTP请求，这是一项称为同源策略的安全措施。

在使用Axios时，如果遇到CORS问题，通常意味着尝试从客户端（例如在浏览器中运行的JavaScript代码）访问不同域的服务时遇到了跨域请求限制。处理这一问题的方法有以下几种：

### 1. 服务器端设置CORS头

最常见和推荐的方法是在服务器端配置CORS。服务器必须在响应中包含适当的CORS头，如`Access-Control-Allow-Origin`。这样，服务器就可以明确允许特定的域进行跨域请求。

#### 示例：

假设你的客户端代码运行在`http://client.example.com`，而你试图通过Axios向`http://api.example.com/data`发送请求。服务器端需要在响应中包含以下头信息：

```http
Access-Control-Allow-Origin: http://client.example.com
```

或者，如果你想允许任何域对服务器资源的访问，可以设置：

```http
Access-Control-Allow-Origin: *
```

### 2. JSONP

对于旧的服务器或当你没有权限更改服务器配置时，可以使用JSONP（JSON with Padding）来绕过CORS限制。不过，请注意，JSONP只支持`GET`请求，并且不是一种安全的解决方案，因为它容易受到XSS攻击。Axios本身不支持JSONP，因此，你可能需要使用其他库。

### 3. 代理服务器

另一个解决方式是使用代理服务器。你可以设置一个代理服务器，所有的客户端请求先发到这个代理服务器，由代理服务器转发请求到目标服务器，并将响应返回给客户端。这样，因为所有请求都是通过同一个域发起的，CORS问题就不存在了。

在开发环境中，像webpack-dev-server等工具通常提供了代理功能。

#### 示例：

```javascript
// webpack.config.js
module.exports = {
  // ...
  devServer: {
    proxy: {
      '/api': {
        target: 'http://api.example.com',
        changeOrigin: true,
      },
    },
  },
};
```

通过以上任一方式，都可以在使用Axios时解决CORS问题。然而，在生产环境中推荐的做法仍然是通过服务器端设置CORS头，因为这是最为直接和安全的方式。

您的服务器应该启用跨源请求，而不是客户端。为此，您可以检查[这个漂亮的页面](https://enable-cors.org/server.html)，其中包含多个平台的实现和配置

只是为那些可能通过谷歌搜索到达这里的人指出我的解决方案。我通过在调用中`withCredentials`设置为解决了 CORS 问题（当从浏览器中的 UI 调用外部 api 时）：`false``axios`

    axios({
        method: 'get',
        url: `https://api.someurl.com/subject/v2/resource/somevalue`,
        withCredentials: false,
        params: {
          access_token: SECRET_TOKEN,
        },
      });
    

在这种情况下，外部 api 端点的安全性基于`access_token`.

**可能对某人有帮助：**

我正在将数据从`react`应用程序发送到`golang`服务器。

一旦我改变了这个，`w.Header().Set("Access-Control-Allow-Origin", "*")`错误就被修复了。

**反应表单提交功能：**

    async handleSubmit(e) {
        e.preventDefault();
        
        const headers = {
            'Content-Type': 'text/plain'
        };
    
        await axios.post(
            'http://localhost:3001/login',
            {
                user_name: this.state.user_name,
                password: this.state.password,
            },
            {headers}
            ).then(response => {
                console.log("Success ========>", response);
            })
            .catch(error => {
                console.log("Error ========>", error);
            }
        )
    }
    

**Go 服务器有 Router，**

    func main()  {
        router := mux.NewRouter()
    
        router.HandleFunc("/login", Login.Login).Methods("POST")
    
        log.Fatal(http.ListenAndServe(":3001", router))
    }
    

**登录.go,**

    func Login(w http.ResponseWriter, r *http.Request)  {
    
        var user = Models.User{}
        data, err := ioutil.ReadAll(r.Body)
    
        if err == nil {
            err := json.Unmarshal(data, &user)
            if err == nil {
                user = Postgres.GetUser(user.UserName, user.Password)
                w.Header().Set("Access-Control-Allow-Origin", "*")
                json.NewEncoder(w).Encode(user)
            }
        }
    }

我遇到了同样的问题。当我更改内容类型时，它已经解决了。我不确定这个解决方案对您有帮助，但也许是。如果您不介意内容类型，它对我有用。

    axios.defaults.headers.post['Content-Type'] ='application/x-www-form-urlencoded';

我在处理 Vue.js 项目时遇到了相同的 CORS 错误。您可以通过构建代理服务器来解决此问题，或者另一种方法是禁用浏览器（例如 CHROME）的安全设置来访问跨源 api（这是临时解决方案，不是解决问题的最佳方法）。这两种解决方案都对我有用。后面的解决方案不需要构建任何模拟服务器或代理服务器。这两种方案都可以在前端解决。

您可以通过在终端上键入以下命令来禁用从源访问 api 的 chrome 安全设置：

    /Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --user-data-dir="/tmp/chrome_dev_session" --disable-web-security
    

在终端上运行上述命令后，将打开一个禁用安全设置的新 chrome 窗口。现在，再次运行您的程序 (npm runserve / npm run dev)，这次您将不会收到任何 CORS 错误，并且能够使用 axios 获取请求。

希望这可以帮助！

How to having cors issue in axios

Axios 拦截器允许我们在请求或响应被 `then` 或者 `catch` 处理之前对它们进行拦截和修改。拦截器通常用于以下几个目的：

1. 在请求发送到服务器之前对请求数据进行修改。
2. 发送请求前，在请求头中附加认证信息（如JWT令牌）。
3. 在请求到达服务器之前取消请求。
4. 统一处理所有的响应错误。
5. 在响应数据到达应用逻辑之前对数据进行转换。

使用 Axios 拦截器主要有两种类型：请求拦截器和响应拦截器。

### 添加请求拦截器

请求拦截器会在请求真正发送出去之前执行。以下是添加请求拦截器的一般方法：

```javascript
// 添加请求拦截器
axios.interceptors.request.use(function (config) {
    // 在发送请求之前做些什么，例如设置token
    config.headers.Authorization = `Bearer ${YOUR_AUTH_TOKEN}`;

    return config;
}, function (error) {
    // 对请求错误做些什么
    return Promise.reject(error);
});
```

在这里，我们首先使用 `axios.interceptors.request.use` 添加了一个请求拦截器。这个拦截器接收两个函数作为参数，第一个函数会在请求发出前被调用，并接收请求的配置对象 `config` 作为参数，允许我们修改这个配置对象。在上面的例子中，我们添加了一个 `Authorization` 头，其值是一个假设的认证令牌 `YOUR_AUTH_TOKEN`。第二个函数是当请求出现错误时执行，这里我们简单地将错误返回。

### 添加响应拦截器

响应拦截器会在服务器的响应数据到达 `then` 或 `catch` 之前被调用。以下是添加响应拦截器的一般方法：

```javascript
// 添加响应拦截器
axios.interceptors.response.use(function (response) {
    // 对响应数据做点什么
    // 可以根据你的需求来对响应数据做处理，这里只是一个示例
    if (response.data && response.data.success) {
        return response.data.data;
    } else {
        // 你可以在这里处理不成功的情况，或者抛出一个错误
        return Promise.reject('Error with request');
    }
}, function (error) {
    // 对响应错误做点什么
    if (error.response.status === 401) {
        // 如果状态码是 401，可以进行重新登录等处理
    }
    return Promise.reject(error);
});
```

在这个例子中，我们使用 `axios.interceptors.response.use` 添加了一个响应拦截器。它也接收两个函数，第一个函数在响应正确返回时被调用，接收响应对象 `response` 作为参数。在这个函数中，我们做了一些简单的判断，并只返回了实际需要的数据部分。第二个函数在响应出现错误时被调用，例如可以在这里处理 `401 Unauthorized` 状态码，实现自动重新登录或者跳转到登录页面等操作。

### 移除拦截器

如果你想在某个时刻移除拦截器，你可以这样做：

```javascript
// 添加拦截器时会返回一个拦截器的ID
const myInterceptor = axios.interceptors.request.use(function () {/*...*/});
// 通过这个ID可以移除拦截器
axios.interceptors.request.eject(myInterceptor);
```

在上面的代码中，我们首先添加了一个请求拦截器，并将返回的拦截器 ID 保存在 `myInterceptor` 变量中。然后，我们调用 `axios.interceptors.request.eject` 方法并传入这个 ID 来移除拦

简单来说，它更像是每个 HTTP 操作的检查点。已进行的每个 API 调用都会通过此拦截器传递。

**那么，为什么要两个拦截器呢？**

API 调用由两部分组成：请求和响应。由于它的行为类似于检查点，因此请求和响应具有单独的拦截器。

**一些请求拦截器用例 -**

假设您想在发出请求之前检查您的凭据是否有效。因此，您可以在拦截器级别检查您的凭据是否有效，而不是实际进行 API 调用。

假设您需要为每个发出的请求附加一个令牌，而不是在每次 Axios 调用时重复令牌添加逻辑，您可以创建一个拦截器，在发出的每个请求上附加一个令牌。

**一些响应拦截器用例 -**

假设您收到了响应，并根据您想要推断用户已登录的 API 响应进行判断。因此，在响应拦截器中，您可以初始化一个处理用户登录状态的类，并在响应对象上相应地更新它你收到。

假设您已使用有效的 API 凭据请求了某些 API，但您没有访问数据的有效角色。因此，您可以从响应拦截器触发警报，表示不允许该用户。这样，您就可以避免必须对您发出的每个 Axios 请求执行未经授权的 API 错误处理。

这是一些代码示例

**请求拦截器**

*   可以通过执行以下操作（在本例中，通过检查环境变量）打印 axios 的配置对象（如果需要）：
    
        const DEBUG = process.env.NODE_ENV === "development";
        
        axios.interceptors.request.use((config) => {
            /** In dev, intercepts request and logs it into console for dev */
            if (DEBUG) { console.info("✉️ ", config); }
            return config;
        }, (error) => {
            if (DEBUG) { console.error("✉️ ", error); }
            return Promise.reject(error);
        });
        
    
*   如果想要检查正在传递哪些标头/添加任何更多通用标头，则可以在`config.headers`对象中使用。例如：
    
        axios.interceptors.request.use((config) => {
            config.headers.genericKey = "someGenericValue";
            return config;
        }, (error) => {
            return Promise.reject(error);
        });
        
    
*   如果是请求`GET`，则可以在对象中找到发送的查询参数`config.params`。
    

**响应拦截器**

*   您甚至可以**选择**在拦截器级别解析 API 响应，并将解析后的响应而不是原始响应向下传递。如果在多个地方以相同的方式使用 API，它可能会节省您一次又一次编写解析逻辑的时间。一种方法是在响应拦截器中传递一个额外的参数，`api-request`并在响应拦截器中使用相同的参数来执行您的操作。例如：
    
        //Assume we pass an extra parameter "parse: true" 
        axios.get("/city-list", { parse: true });
        
    
    一旦，在响应拦截器中，我们可以像这样使用它：
    
        axios.interceptors.response.use((response) => {
            if (response.config.parse) {
                //perform the manipulation here and change the response object
            }
            return response;
        }, (error) => {
            return Promise.reject(error.message);
        });
        
    
    因此，在这种情况下，只要`parse`中有一个对象`response.config`，操作就完成，对于其余情况，它将按原样工作。
    
*   您甚至可以查看到达的`HTTP`代码，然后做出决定。例如：
    
        axios.interceptors.response.use((response) => {
            if(response.status === 401) {
                 alert("You are not authorized");
            }
            return response;
        }, (error) => {
            if (error.response && error.response.data) {
                return Promise.reject(error.response.data);
            }
            return Promise.reject(error.message);
        });

例如，如果您想捕获从发送请求到收到响应所花费的时间，您可以使用此代码：

    const axios = require("axios");
    
    (async () => {
      axios.interceptors.request.use(
        function (req) {
          req.time = { startTime: new Date() };
          return req;
        },
        (err) => {
          return Promise.reject(err);
        }
      );
    
      axios.interceptors.response.use(
        function (res) {
          res.config.time.endTime = new Date();
          res.duration =
            res.config.time.endTime - res.config.time.startTime;
          return res;
        },
        (err) => {
          return Promise.reject(err);
        }
      );
    
      axios
        .get("http://localhost:3000")
        .then((res) => {
          console.log(res.duration)
        })
        .catch((err) => {
          console.log(err);
        });
    })();

它就像一个中间件，基本上它被添加到任何请求（GET、POST、PUT、DELETE）或任何响应（从服务器获得的响应）上。常用于涉及授权的情况。

看看这个：[axios拦截器和异步登录](https://stackoverflow.com/questions/35900230/axios-interceptors-and-asynchronous-login)

这是关于此的另一篇文章，有一个不同的示例：[https://medium.com/@danielalvidrez/handling-error-responses-with-grace-b6fd3c5886f0](https://medium.com/@danielalvidrez/handling-error-responses-with-grace-b6fd3c5886f0)

因此，其中一个示例的要点是，您可以使用拦截器来检测您的授权令牌是否已过期（例如，如果您收到 403）并重定向页面。

我将为您提供我在现实项目中使用的更多实际用例。我通常使用，`request interceptor`对于与令牌相关的人员（`accessToken`，`refreshToken`），例如，令牌是否未过期，如果是，则使用refreshToken更新它并保留所有其他调用直到它解决。但我最喜欢的是 axios，`response interceptors`您可以在其中放置应用程序的全局错误处理逻辑，如下所示：

    httpClient.interceptors.response.use(
      (response: AxiosResponse) => {
        // Any status code that lie within the range of 2xx cause this function to trigger
        return response.data;
      },
      (err: AxiosError) => {
        // Any status codes that falls outside the range of 2xx cause this function to trigger
        const status = err.response?.status || 500;
        // we can handle global errors here
        switch (status) {
          // authentication (token related issues)
          case 401: {
            return Promise.reject(new APIError(err.message, 409));
          }
    
          // forbidden (permission related issues)
          case 403: {
            return Promise.reject(new APIError(err.message, 409));
          }
    
          // bad request
          case 400: {
            return Promise.reject(new APIError(err.message, 400));
          }
    
          // not found
          case 404: {
            return Promise.reject(new APIError(err.message, 404));
          }
    
          // conflict
          case 409: {
            return Promise.reject(new APIError(err.message, 409));
          }
    
          // unprocessable
          case 422: {
            return Promise.reject(new APIError(err.message, 422));
          }
    
          // generic api error (server related) unexpected
          default: {
            return Promise.reject(new APIError(err.message, 500));
          }
        }
      }
    );

我已经通过以下方式实现了

_**httpConfig.js**_

    import axios from 'axios'
    import { baseURL } from '../utils/config'
    import { SetupInterceptors } from './SetupInterceptors'
    
    
    const http = axios.create({
        baseURL: baseURL
    })
    
    SetupInterceptors(http)
    
    export default http
    

_**安装拦截器.js**_

    import { baseURL } from '../utils/config'
    
    
    export const SetupInterceptors = http => {
    
        http.interceptors.request.use(
            config => {
                config.headers['token'] = `${localStorage.getItem('token')}`
                config.headers['content-type'] = 'application/json'
                return config
            },
            error => {
                return Promise.reject(error)
            }
        )
    
        http.interceptors.response.use(function(response) {
            return response
        }, function (error) {
            const status = error?.response?.status || 0
            const resBaseURL = error?.response?.config?.baseURL
            if (resBaseURL === baseURL && status === 401) {
                if (localStorage.getItem('token')) {
                    localStorage.clear()
                    window.location.assign('/')
                    return Promise.reject(error)
                } else {
                    return Promise.reject(error)
                }
            }
            return Promise.reject(error)
        })
    }
    
    export default SetupInterceptors
    

参考：[链接](https://javascript.plainenglish.io/http-interceptors-in-react-4dd7a35ba297)

How can you use axios interceptors

Nginx 配置文件（通常具有 `.conf` 扩展名）是使用特定于 Nginx 的配置语言编写的，它是一种声明式的配置语言，用于指定 Nginx 服务器的行为。这种语言是专门为配置 Nginx 的各种方面而设计的，包括服务器的监听端口、位置块（location blocks）的使用以处理特定的 URI、负载均衡配置、缓存行为、重定向规则等等。

配置文件中的语句主要基于简单的键值对，并且有其自身的结构和语法规则。例如，一个基本的Nginx配置文件可能包含以下内容：

```nginx
events {
    worker_connections 1024;
}

http {
    server {
        listen 80;
        server_name example.com www.example.com;

        location / {
            root /var/www/html;
            index index.html index.htm;
        }
        
        location /images/ {
            root /var/www/images;
        }
    }
}
```

上面的例子展示了一个简单的 Nginx 配置，其中指定了事件模块（`events`）的工作连接数、HTTP服务器监听端口（80端口）、服务器名称，以及两个位置块来处理网站根目录和图片目录的请求。

这种配置语言虽然简洁，但功能强大，能够支持复杂的网络服务器设置。通过组合不同的指令和模块，用户可以为Nginx创建高效、灵活且安全的配置。

所以我是 nginx 的新手，也有同样的问题。事实证明，上述语言的语法既是自定义的，而且实际上非常简单。该语法在 NGINX 文档的[一个部分中被捕获，为了方便起见，在此处重复：](https://nginx.org/en/docs/beginners_guide.html#conf_structure)

> nginx 由由配置文件中指定的指令控制的模块组成。指令分为简单指令和块指令。一个简单的指令由名称和参数组成，名称和参数之间用空格分隔，并以分号 (;) 结尾。块指令具有与简单指令相同的结构，但它不是以分号结尾，而是以一组用大括号（{ 和 }）括起来的附加指令结尾。如果块指令可以在大括号内包含其他指令，则称为上下文（例如：事件、http、服务器和位置）。
> 
> 放置在任何上下文之外的配置文件中的指令都被视为位于主上下文中。事件和http指令驻留在主上下文中，服务器驻留在http中，位置驻留在server中。
> 
> \# 符号之后的其余行被视为注释。

**总之：** NGINX 配置文件中的所有内容都是可能引用_变量的__指令_。所有指令均按[字母顺序列出](https://nginx.org/en/docs/dirindex.html)，所有变量均按[字母顺序列出](https://nginx.org/en/docs/varindex.html)。_NGINX 配置由模块_驱动，每个模块都实现特定的功能，并且每个模块_都提供_可在配置中使用的指令和变量。就是这样。[](https://nginx.org/en/docs/dirindex.html)[](https://nginx.org/en/docs/varindex.html)

这就是为什么 Even `if`（看起来像传统编程语言中的关键字）实际上只是[模块](https://nginx.org/en/docs/http/ngx_http_rewrite_module.html)提供的_指令_。`ngx_http_rewrite_module`[](https://nginx.org/en/docs/http/ngx_http_rewrite_module.html)

希望这可以帮助！

PS - 另请查看[https://devdocs.io/](https://devdocs.io/)，特别是[https://devdocs.io/nginx](https://devdocs.io/nginx)，以获得搜索/使用 NGINX 文档的改进方法_。_

Nginx conf 文件是用它们自己的语言或语法编写的。我在下面列出了一些基础知识。[这些是我在掌握 Nginx](http://www.amazon.co.uk/Mastering-Nginx-Dimitri-Aivaliotis/dp/1849517444)中的个人笔记[](http://www.amazon.co.uk/Mastering-Nginx-Dimitri-Aivaliotis/dp/1849517444)

**基本格式**

基本文件被分成几个部分

    :
    
    <section> {
    
      <directive> <parameters>; 
    
    }
    

**全局参数**

未按上述标准格式定义，它没有围绕全局部分的 {}。它位于配置文件的顶部

重要的全局参数

user - 工作进程运行的用户和组。如果组省略，则等于用户使用的组

worker\_processes - 启动的工作进程数。他们处理来自客户端的连接。作为 CPU 限制负载的规则，该值应等于处理器数量，而对于 I/O 限制负载，则应乘以 1.5 或 2

error\_log - 错误日志的位置。可以在指令内被覆盖。第二个参数指示日志调试的级别（仅在编译时配置调试模式时可用）、info、notice、warn、error、crit、alert 和 emerg。

pid - 写入主进程的进程 ID 的文件，覆盖编译时的默认值。

worker\_connections - 配置工作进程可以打开的最大并发连接数。对于反向代理服务器尤其重要 - 可能需要在操作系统级别进行一些额外的调整才能达到这个并发连接数。

**使用包含文件** 可以在配置文件中的任何位置使用

包括/opt/local/etc/nginx/mime.types；

路径中可能会出现通配符来匹配多个文件：include /opt/local/etc/nginx/vhost/\*.conf；

通过调用 NGINX 可以轻松测试配置文件，如下所示： nginx -t -c

Http 部分将是最常用的部分。

Nginx 配置文件是用一种为 Nginx 配置文件设计和实现的语言（如果你想称之为一种语言）编写的。文档很可能是除源本身之外的唯一可用参考。我首先会在[Nginx 论坛](http://forum.nginx.org/)上发布消息，或者加入[Nginx 邮件列表](http://nginx.org/mailman/listinfo/nginx)并在那里提问。当然，您也可以获取源代码并从那里开始。


所有问题