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() 更新）

Mongoose 中的 __v 字段的作用是什么？

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 交互的本机驱动程序。

Mongodb 和 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

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"
    }

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"
     }
    }

如何在 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）的附加功能

Lucene 和 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);
        })
      })
    }

Axios 如何统一记录所有的请求调用？

当我们谈论跨域资源共享（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 获取请求。

希望这可以帮助！

Axios 如何处理 cros 问题？

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)

Axios 如何使用拦截器？

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)并在那里提问。当然，您也可以获取源代码并从那里开始。


Nginx conf 文件支持的是什么语言？

在使用 Axios 进行 POST 请求时，通常情况下，查询参数（query parameters）会附加在 URL 中，而请求体（request body）通常包含 POST 数据。如果你需要在 POST 请求中设置查询参数，你可以直接在 URL 中加入它们，或者使用 `params` 配置选项来指定这些参数。

下面是一个如何在 Axios POST 请求中设置查询参数的具体例子：

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

// 设置 POST 请求的数据
const postData = {
    key1: 'value1',
    key2: 'value2'
};

// 设置查询参数
const queryParams = {
    param1: 'value1',
    param2: 'value2'
};

// 发起 POST 请求
axios.post('https://example.com/api/resource', postData, {
    params: queryParams
})
.then(response => {
    console.log('Response:', response.data);
})
.catch(error => {
    console.error('Error:', error);
});
```

在这个例子中，`postData` 是要发送到服务器的数据，而 `queryParams` 是我们想要附加在 URL 上的查询参数。通过 `params` 配置，Axios 会自动将查询参数拼接到请求的 URL 上。

生成的请求 URL 将类似于这样：

```
https://example.com/api/resource?param1=value1&param2=value2
```

同时，`postData` 中的内容会作为 POST 请求体发送。这种方式使得你可以同时在一个 POST 请求中发送请求体数据和查询参数。

帖子的 axios 签名是`axios.post(url[, data[, config]])`. 所以你想在第三个参数中发送 params 对象：

    .post(`/mails/users/sendVerificationMail`, null, { params: {
      mail,
      firstname
    }})
    .then(response => response.status)
    .catch(err => console.warn(err));
    

这将发布一个带有两个查询参数的空正文：

> POST [http://localhost:8000/api/mails/users/sendVerificationMail?mail=lol%40lol.com&firstname=myFirstName](http://localhost:8000/api/mails/users/sendVerificationMail?mail=lol%40lol.com&firstname=myFirstName)

截至 2021 年，安装了 null 我必须添加 {} 才能使其正常工作！

    axios.post(
            url,
            {},
            {
              params: {
                key,
                checksum
              }
            }
          )
          .then(response => {
            return success(response);
          })
          .catch(error => {
            return fail(error);
          });

就我而言，API 响应了 CORS 错误。相反，我将查询参数格式化为查询字符串。它成功地发布了数据，并且还避免了 CORS 问题。

            var data = {};
    
            const params = new URLSearchParams({
              contact: this.ContactPerson,
              phoneNumber: this.PhoneNumber,
              email: this.Email
            }).toString();
    
            const url =
              "https://test.com/api/UpdateProfile?" +
              params;
    
            axios
              .post(url, data, {
                headers: {
                  aaid: this.ID,
                  token: this.Token
                }
              })
              .then(res => {
                this.Info = JSON.parse(res.data);
              })
              .catch(err => {
                console.log(err);
              });

您可以在 axios 请求中同时使用 params 和 body

      sendAllData (data) {
       return axios
            .post(API_URL + "receiveData", JSON.stringify(data), {
              headers: { "Content-Type": "application/json; charset=UTF-8" },
              params: { mail: xyx@example.col }, //Add mail as a param
            })
            .then((response) => console.log("repsonse", response.status)); 
      }

How to post query parameters with Axios?

当您使用 Nginx 作为代理服务器时，将查询字符串参数从客户端传递到上游服务器（例如应用服务器）是一个很常见的需求。Nginx 默认情况下就会将请求中的查询字符串参数传递到上游服务器。这是因为当请求被代理时，整个请求行（包括 URI 和查询字符串）都会被转发。

以下是一个基本的 Nginx 配置示例，展示了如何为一个应用服务器配置代理，并自动包含查询字符串：

```nginx
server {
    listen 80;

    server_name example.com;

    location / {
        # 代理设置，将请求传递到后端应用服务器
        proxy_pass http://backend_server;

        # 下面这些是一些通用的代理设置，以确保请求和响应头被合适地处理
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}
```

在这个配置中，`proxy_pass` 指令用来定义上游服务器的地址。当客户端发送请求到 Nginx 时，如果请求包含查询字符串，Nginx 将自动将整个请求 URI（包括查询字符串）转发到 `http://backend_server`。

例如，如果客户端请求 `http://example.com/search?q=openai&lang=en`，Nginx 会将这个请求代理到 `http://backend_server/search?q=openai&lang=en`，包括查询字符串 `?q=openai&lang=en`。

如果您需要修改查询字符串或者根据查询字符串做一些特殊处理，可以使用 `rewrite` 指令或者 `$args` 变量来实现。这里是一个使用 `rewrite` 指令修改查询字符串的示例：

```nginx
server {
    listen 80;

    server_name example.com;

    location / {
        # 检查请求的查询字符串，如果没有 lang 参数则添加 lang=en
        if ($args !~ "lang=") {
            set $args "${args}&lang=en";
        }

        # 将修改后的请求传递到后端服务器
        proxy_pass http://backend_server;

        # 其余代理设置...
    }
}
```

在这个例子中，如果原始请求缺少 `lang` 参数，Nginx 将会添加 `lang=en` 到查询字符串，并将修改后的请求传递到上游服务器。

来自[proxy\_pass](https://web.archive.org/web/20111119030118/http://wiki.nginx.org/HttpProxyModule#proxy_pass)文档：

> 一种特殊情况是在 proxy\_pass 语句中使用变量：不使用请求的 URL，您完全负责自己构建目标 URL。

由于您在目标中使用 $1，因此 nginx 依赖于您准确地告诉它要传递的内容。您可以通过两种方式解决此问题。首先，使用 proxy\_pass 剥离 uri 的开头很简单：

    location /service/ {
      # Note the trailing slash on the proxy_pass.
      # It tells nginx to replace /service/ with / when passing the request.
      proxy_pass http://apache/;
    }
    

或者，如果您想使用正则表达式位置，只需包含参数：

    location ~* ^/service/(.*) {
      proxy_pass http://apache/$1$is_args$args;
    }

我使用 kolbyjack 的第二种方法的稍微修改版本，而`~`不是`~*`.

    location ~ ^/service/ {
      proxy_pass http://apache/$uri$is_args$args;
    }

你必须使用 rewrite 来使用 proxy\_pass 传递参数，这是我为 angularjs 应用程序部署到 s3 所做的示例

[S3 静态网站托管将所有路径路由到 Index.html](https://stackoverflow.com/questions/16267339/s3-static-website-hosting-route-all-paths-to-index-html/37371897#37371897)

适应你的需求会是这样的

    location /service/ {
        rewrite ^\/service\/(.*) /$1 break;
        proxy_pass http://apache;
    }
    

如果你想结束在[http://127.0.0.1:8080/query/params/](http://127.0.0.1:8080/query/params/)

如果你想最终进入[http://127.0.0.1:8080/service/query/params/](http://127.0.0.1:8080/service/query/params/) 你需要类似的东西

    location /service/ {
        rewrite ^\/(.*) /$1 break;
        proxy_pass http://apache;
    }

我修改了 @kolbyjack 代码以使其适用

    http://website1/service
    http://website1/service/
    

带参数

    location ~ ^/service/?(.*) {
        return 301 http://service_url/$1$is_args$args;
    }

处理添加 $request\_uri:  
proxy\_pass http://apache/$request\_uri;

如何使用nginx通过代理传递查询字符串参数

在 Nginx 中，当我们作为代理向后端服务器转发请求时，有时候我们需要在响应头中添加一些自定义的头信息。这可以通过使用 `add_header` 指令来完成，该指令通常在 `server` 或 `location` 块中指定。

以下是 Nginx 配置文件中添加自定义响应头的一个例子：

```nginx
server {
    listen 80;
    server_name example.com;

    location / {
        proxy_pass http://backend_server; # 此处是你的后端服务器地址
        add_header X-Proxy-Cache $upstream_cache_status;

        # 其他代理设置，例如设置代理头信息等
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}
```

在上面的配置中，我们为所有通过 `/` location 块代理的请求添加了一个名为 `X-Proxy-Cache` 的自定义响应头。该头的值设置为 `$upstream_cache_status` 变量的值，这个变量通常用来表示后端服务器的缓存状态。

需要注意的是，`add_header` 指令不仅可以添加常量值的头，还可以添加由 Nginx 变量动态生成的值。然而，如果使用了 `add_header` 指令，你需要确保复制所有默认的头信息，因为 `add_header` 指令会覆盖 Nginx 的默认行为，只输出你在配置中明确指定的头。

上述配置仅是一个简单的例子，你可以根据实际需要添加其他的响应头或者进行更复杂的配置。

`add_header`无论有没有，效果都一样好`proxy_pass`。我今天刚刚设置了一个配置，我在其中使用了该指令。但我必须承认，我在设置这个过程时也遇到了困难，但没有确切地回忆起原因。

现在我有一个工作配置，它包含以下内容（除其他外）：

    server {
        server_name  .myserver.com
        location / {
            proxy_pass  http://mybackend;
            add_header  X-Upstream  $upstream_addr;
        }
    }
    

[与Sebastian Goodman 在他的回答中](http://stackoverflow.com/a/14508087/177710)提到的[HttpHeadersMoreModule](http://wiki.nginx.org/NginxHttpHeadersMoreModule)相比，在 nginx `1.7.5` [add\_header](http://wiki.nginx.org/NginxHttpHeadersModule#add_header)之前仅对成功响应起作用。[](http://wiki.nginx.org/NginxHttpHeadersMoreModule)[](http://stackoverflow.com/a/14508087/177710)

由于 nginx，即使在错误响应中`1.7.5`，您也可以使用关键字`always`来包含自定义标头。例如：

    add_header X-Upstream $upstream_addr always;
    

* * *

_限制：_`server`您无法使用覆盖标头值`add_header`。

隐藏响应标头，然后添加新的自定义标头值
-------------------

添加标头`add_header`可以很好地使用代理传递，但如果响应中存在现有标头值，它将堆叠这些值。

如果您想设置或替换标头值（例如替换`Access-Control-Allow-Origin`标头以匹配您的客户端以允许跨源资源共享），那么您可以执行以下操作：

    # 1. hide the Access-Control-Allow-Origin from the server response
    proxy_hide_header Access-Control-Allow-Origin;
    # 2. add a new custom header that allows all * origins instead
    add_header Access-Control-Allow-Origin *;
    

因此`proxy_hide_header`，与 结合`add_header`使您能够设置/替换响应标头值。

[类似的答案可以在 ServerFault 上](https://serverfault.com/a/927668/191235)找到[](https://serverfault.com/a/927668/191235)

更新：
---

**注意：** `proxy_set_header`用于在进一步发送请求之前设置请求标头，而不是用于设置响应标头（标头的这些配置属性可能有点令人困惑）。

正如奥利弗所写：

> `add_header`无论有没有，效果都一样好`proxy_pass`。

然而，正如 Shane 所写，从 Nginx 1.7.5 开始，您必须通过`always`才能开始`add_header`处理错误响应，如下所示：

    add_header  X-Upstream  $upstream_addr always;

有一个名为[HttpHeadersMoreModule 的](http://wiki.nginx.org/NginxHttpHeadersMoreModule)模块，可以让您更好地控制标头。它不附带 Nginx，需要额外安装。有了它，你可以做这样的事情：

    location ... {
      more_set_headers "Server: my_server";
    }
    

这将“将服务器输出标头设置为任何状态代码和任何内容类型的自定义值”。它将替换已设置的标头或添加它们（如果未设置）。

你可以尝试这个解决方案：

在您的`location`块中，当您使用时，`proxy_pass`请执行以下操作：

    location ... {
    
      add_header yourHeaderName yourValue;
      proxy_pass xxxx://xxx_my_proxy_addr_xxx;
    
      # Now use this solution:
      proxy_ignore_headers yourHeaderName // but set by proxy
    
      # Or if above didn't work maybe this:
      proxy_hide_header yourHeaderName // but set by proxy
    
    }
    

我不确定这是否正是您所需要的，但尝试对此方法进行一些操作，也许结果会适合您的问题。

您也可以使用此组合：

    proxy_hide_header headerSetByProxy;
    set $sent_http_header_set_by_proxy yourValue;

Nginx 如何在代理请求时添加响应头？

在Nginx中，我们可以通过配置文件来设置重定向规则，将请求从一个域重定向到另一个域。主要有两种方式可以实现重定向：使用 `return` 指令和使用 `rewrite` 指令。以下是这两种方式的例子：

### 使用 `return` 指令

`return` 指令是一个相对简单并且推荐使用的方式来进行重定向。您可以在 `server` 块中定义一个 `return` 指令来指示Nginx对特定请求返回一个重定向。以下是一个将所有请求从`old-domain.com`重定向到`new-domain.com`的示例：

```nginx
server {
    listen 80;
    server_name old-domain.com;
    
    return 301 http://new-domain.com$request_uri;
}
```

在这个配置中，当用户访问 `old-domain.com` 时，Nginx将发送一个状态码为301（永久重定向）的响应，告诉用户资源已经永久移动到 `new-domain.com`。`$request_uri` 变量保证了完整的请求URI被包括在重定向中，这意味着任何额外的路径或查询字符串也将保留在新的URL中。

### 使用 `rewrite` 指令

`rewrite` 指令更加灵活，可以根据正则表达式匹配并修改请求的URI。当匹配成功时，可以指定一个新的URI并选择是进行内部跳转还是发送重定向响应。以下是一个将特定路径重定向到另一个域的示例：

```nginx
server {
    listen 80;
    server_name old-domain.com;

    location /somepath/ {
        rewrite ^/somepath/(.*)$ http://new-domain.com/otherpath/$1 permanent;
    }
}
```

在这个例子中，只有当请求的路径以 `/somepath/` 开头时，Nginx才会将请求重定向到 `new-domain.com` 下的 `/otherpath/` 路径。`$1` 是一个正则表达式捕获组，它会捕获原始请求中 `/somepath/` 后面的部分，并将其插入到新URL中。`permanent` 关键字表示这是一个301永久重定向。

### 注意事项

1. 当你使用301重定向时，这表示永久性的重定向，搜索引擎会更新他们的索引以反映新的位置。对于临时性的重定向，你应该使用302状态码。
2. 请确保在修改Nginx配置后重新加载或重启Nginx服务使配置生效，你可以使用 `nginx -s reload` 命令来安全地重载配置文件。
3. 在实施重定向时应确保考虑SEO影响，永久重定向（301）通常对SEO更为友好，因为它们将链接权重传递给新URL。

以上就是通过Nginx将请求重定向到不同域的基本方法和一些注意事项。

[server\_name](http://nginx.org/r/server_name)支持使用语法进行后缀匹配`.mydomain.example`：

    server {
      server_name .mydomain.example;
      rewrite ^ http://www.adifferentdomain.example$request_uri? permanent;
    }
    

或者在任何 0.9.1 或更高版本上：

    server {
      server_name .mydomain.example;
      return 301 http://www.adifferentdomain.example$request_uri;
    }

server {
        server_name .mydomain.example;
        return 301 http://www.adifferentdomain.example$request_uri;
    }
    

[http://wiki.nginx.org/HttpRewriteModule#return](http://wiki.nginx.org/HttpRewriteModule#return)

和

[http://wiki.nginx.org/Pitfalls#Taxing\_Rewrites](http://wiki.nginx.org/Pitfalls#Taxing_Rewrites)

我正在为我的网站使用此代码

    server {
            listen 80;
            listen 443;
            server_name  .domain.example;
    
            return 301 $scheme://newdomain.example$request_uri;
    }

如果可以的话为什么要使用重写模块呢`return`？从技术上讲，`return`它是重写模块的一部分，[您可以在此处阅读](http://wiki.nginx.org/HttpRewriteModule#return)，但恕我直言，此代码段更容易阅读。

    server {
        server_name  .domain.com;
    
        return 302 $scheme://forwarded-domain.com;
    }
    

您还可以给它一个 301 重定向。

Nginx 如何将请求重定向到不同的域？

在Nginx中，定位实际正在使用的配置文件（`nginx.conf`）可以通过几种方式完成。

1. **查看默认配置文件位置**
    默认情况下，Nginx的配置文件通常位于以下几个地方之一：
    - `/etc/nginx/nginx.conf`
    - `/usr/local/nginx/conf/nginx.conf`
    - `/usr/local/etc/nginx/nginx.conf`

    这取决于Nginx是如何安装的。大多数基于包管理的安装（例如，使用APT或YUM）会将配置文件放在`/etc/nginx/`目录下。

2. **使用Nginx命令**
    可以使用Nginx的命令行参数`-t`查看它认为的配置文件路径，这将输出完整的配置文件路径，以及配置文件中的任何错误。

    ```shell
    nginx -t
    ```
    
    这个命令不仅会显示你配置文件的位置，还会进行语法检查。

3. **查看Nginx进程**
    通过查看Nginx的进程信息，可以找到它使用的配置文件。可以用`ps`命令配合`grep`来做这件事：

    ```shell
    ps -aux | grep nginx
    ```
    
    在Nginx启动命令的输出中，可能会包含`-c`参数后面跟随的配置文件路径。

4. **查看启动脚本**
    对于使用系统服务管理器（如systemd）启动Nginx的系统，可以检查服务的单位文件，找到Nginx的启动命令及其使用的配置文件。

    ```shell
    systemctl cat nginx
    ```
    
    或者，对于较旧的系统，可能需要查看启动脚本：

    ```shell
    cat /etc/init.d/nginx
    ```

5. **Nginx编译参数**
    如果你想知道在编译Nginx时指定的默认配置文件路径，可以使用以下命令查看：

    ```shell
    nginx -V
    ```
    
    该命令会输出Nginx编译时的所有参数，包括`--conf-path`，这里面指定了默认的配置文件路径。

综上所述，通常可以快速通过`nginx -t`命令来确认Nginx使用的配置文件路径，并且额外检查配置文件的语法正确性。如果需要了解更多详细信息，如编译时的配置路径或服务启动脚本，那么其他方法也非常有用。

通过命令行运行`nginx -t`将发出测试并将输出与文件路径附加到配置文件（带有错误或成功消息）。

和`nginx -t`都会`nginx -V`打印出默认的 nginx 配置文件路径。

    $ nginx -t
    nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
    nginx: configuration file /etc/nginx/nginx.conf test is successful
    
    $ nginx -V
    nginx version: nginx/1.11.1
    built by gcc 4.9.2 (Debian 4.9.2-10)
    built with OpenSSL 1.0.1k 8 Jan 2015
    TLS SNI support enabled
    configure arguments: --prefix=/etc/nginx --sbin-path=/usr/sbin/nginx --modules-path=/usr/lib/nginx/modules --conf-path=/etc/nginx/nginx.conf ...
    

如果需要，您可以通过以下方式获取配置文件：

    $ nginx -V 2>&1 | grep -o '\-\-conf-path=$.*conf$' | cut -d '=' -f2
    /etc/nginx/nginx.conf
    

即使您加载了其他一些配置文件，它们仍然会打印出默认值。

* * *

`ps aux`会显示当前加载的 nginx 配置文件。

    $ ps aux
    USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
    root        11  0.0  0.2  31720  2212 ?        Ss   Jul23   0:00 nginx: master process nginx -c /app/nginx.conf
    

这样您实际上就可以通过以下方式获取配置文件：

    $ ps aux | grep "[c]onf" | awk '{print $(NF)}'
    /app/nginx.conf

% ps -o args -C nginx
    COMMAND
    build/sbin/nginx -c ../test.conf
    

如果 nginx 在没有该选项的情况下运行`-c`，那么您可以使用该`-V`选项找出设置为非标准值的配置参数。其中您最感兴趣的是：

    --prefix=PATH                      set installation prefix
    --sbin-path=PATH                   set nginx binary pathname
    --conf-path=PATH                   set nginx.conf pathname

which nginx
    

将为您提供正在使用的 nginx 的路径

* * *

**编辑（2017 年 1 月 18 日）**

感谢威尔·帕尔默对此答案的评论，我添加了以下内容......

如果您通过 HomeBrew 等软件包管理器安装了 nginx...

    which nginx
    

可能无法为您提供正在使用的 nginx 的**确切路径。**但是您可以使用找到它

    realpath $(which nginx)
    

* * *

正如@Daniel Li 提到的

你可以通过他的方法获取nginx的配置

或者你可以使用这个：

    nginx -V

所有其他答案都很有用，但如果**`nginx`没有打开，它们可能无法帮助您，因此您在尝试运行时`PATH`会得到`command not found``nginx`**：

我在 Debian 7 Wheezy 上有 nginx 1.2.1，`nginx`可执行文件不在 上`PATH`，所以我需要先找到它。它已经在运行，所以使用`ps aux | grep nginx`我发现它位于`/usr/sbin/nginx`，因此我需要**运行`/usr/sbin/nginx -t`**。

如果您想使用非默认配置文件（即不是`/etc/nginx/nginx.conf`），请使用`-c`参数运行它：`/usr/sbin/nginx -c <path-to-configuration> -t`。

您可能还需要将**其运行为`root`**，否则 nginx 可能没有权限打开例如日志，因此该命令将失败。

Nginx 如何定位实际使用的 conf 文件位置？

在Go语言中，为随机数生成器设置种子通常涉及到`math/rand`包。这个包提供了伪随机数生成器的功能。`rand.Seed`函数用来初始化默认的随机数生成器的种子。如果不设置种子，随机数生成器将默认使用种子1，这会导致每次程序运行时生成的随机数序列是相同的。

为了生成不同的随机数序列，我们应该在使用随机数之前提供一个变化的种子。通常，我们会使用当前时间作为种子，因为它总是在变化的。下面是一个如何设置随机数种子的例子：

```go
package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    // 使用当前时间的纳秒时间戳初始化种子
    rand.Seed(time.Now().UnixNano())

    // 生成一个随机数
    randomNumber := rand.Intn(100) // 生成一个[0, 100)的随机数
    fmt.Println(randomNumber)
}
```

在这段代码中，我们使用了`time.Now().UnixNano()`来得到当前时间的纳秒时间戳，并将其作为参数传递给`rand.Seed`函数。这样，每次程序运行时，由于时间的不同，种子也会不同，从而使得随机数生成器产生不同的随机数序列。

需要注意的是，`math/rand`包生成的是伪随机数，它们是由确定性算法生成的，因此它们并不适合于所有的场景，尤其是安全性要求较高的场景。对于需要加密安全等级的随机数，应当使用`crypto/rand`包。

每次设置相同的种子时，您都会得到相同的序列。因此，当然，如果您在快速循环中将种子设置为时间，则可能会使用相同的种子多次调用它。

在您的情况下，当您调用`randInt`函数直到获得不同的值时，您正在等待时间（由 Nano 返回）更改。

[对于所有伪随机库](http://en.wikipedia.org/wiki/Pseudorandom_number_generator)，您只需设置种子一次，例如在初始化程序时，除非您特别需要重现给定的序列（通常仅用于调试和单元测试）。

之后，您只需调用即可`Intn`获取下一个随机整数。

将`rand.Seed(time.Now().UTC().UnixNano())`代码行从 randInt 函数移至 main 函数的开头，一切都会变得更快。并且`.UTC()`由于以下原因失去了通话：

> UnixNano 返回 t 作为 Unix 时间，即自 UTC 1970 年 1 月 1 日以来经过的纳秒数。

另请注意，我认为您可以简化字符串构建：

    package main
    
    import (
        "fmt"
        "math/rand"
        "time"
    )
    
    func main() {
        rand.Seed(time.Now().UnixNano())
        fmt.Println(randomString(10))
    }
    
    func randomString(l int) string {
        bytes := make([]byte, l)
        for i := 0; i < l; i++ {
            bytes[i] = byte(randInt(65, 90))
        }
        return string(bytes)
    }
    
    func randInt(min int, max int) int {
        return min + rand.Intn(max-min)
    }

_**编辑：这个问题已在 Go 版本 1.20 中得到解决，不再需要自己播种随机源。**_

我不明白为什么人们要以时间价值播种。根据我的经验，这从来都不是一个好主意。例如，虽然系统时钟可能以纳秒表示，但系统的时钟精度不是纳秒。

[该程序](https://play.golang.org/p/yXff-pLwtwC)不应该在 Go Playground 上运行，但如果您在自己的机器上运行它，您可以粗略估计您可以期望的精度类型。我看到增量约为 1000000 ns，因此增量为 1 毫秒。这是未使用的 20 位熵。_一直以来，高位大多是恒定的！？_一天大约有 24 位熵，这是非常暴力的（可能会产生漏洞）。

这对您来说重要的程度会有所不同，但您可以通过简单地使用作为`crypto/rand.Read`种子源来避免基于时钟的种子值的陷阱。它将为您提供您可能在随机数中寻找的非确定性质量（即使实际实现本身仅限于一组不同且确定性的随机序列）。

    import (
        crypto_rand "crypto/rand"
        "encoding/binary"
        math_rand "math/rand"
    )
    
    func init() {
        var b [8]byte
        _, err := crypto_rand.Read(b[:])
        if err != nil {
            panic("cannot seed math/rand package with cryptographically secure random number generator")
        }
        math_rand.Seed(int64(binary.LittleEndian.Uint64(b[:])))
    }
    

作为旁注，但与您的问题有关。您可以使用此方法创建自己的`rand.Source`方法，以避免使用锁保护源的成本。包`rand`实用函数很方便，但它们也在幕后使用锁来防止源被同时使用。如果您不需要，您可以通过创建自己的`Source`并以非并发方式使用它来避免它。无论如何，您不应该在迭代之间重新播种随机数生成器，它从来没有被设计为以这种方式使用。

* * *

编辑：我曾经在 ITAM/SAM 工作，我们构建的客户端（然后）使用了基于时钟的种子。Windows 更新后，公司中的许多机器几乎同时重新启动。这导致了对上游服务器基础设施的 Involtery DoS 攻击，因为客户端使用系统运行时间来播种随机性，而这些机器最终或多或少地随机选择相同的时间段进行报告。它们的目的是在一段时间内涂抹负载。一个小时左右，但那没有发生。种子负责任！

只是为了把它扔给后代：有时最好使用初始字符集字符串生成随机字符串。如果字符串应该由人手动输入，那么这很有用；排除 0、O、1 和 l 有助于减少用户错误。

    var alpha = "abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789"
    
    // generates a random string of fixed size
    func srand(size int) string {
        buf := make([]byte, size)
        for i := 0; i < size; i++ {
            buf[i] = alpha[rand.Intn(len(alpha))]
        }
        return string(buf)
    }
    

我通常将种子设置在一个`init()`块内。它们记录在这里：[http://golang.org/doc/ effective\_go.html #init](http://golang.org/doc/effective_go.html#init)

在 Go 1.20（2022 年第 4 季度）中，播种随机数生成器的正确方法也可能是……不执行任何操作。

如果`Seed`未调用，生成器将在程序启动时随机播种。

提案“ [`math/rand`：随机生成全局种子](https://github.com/golang/go/issues/54880)”被接受（2022 年 10 月），并且已经开始实施：

*   [CL 443058](https://go-review.googlesource.com/c/go/+/443058) : `math/rand`: 自动种子全局源

> 实施提案[#54880](https://github.com/golang/go/issues/54880)，自动播种全局源。

> 这不是重大更改的理由是，在包的`init`函数或导出的 API 中对全局源的任何使用显然都必须有效 - 也就是说，如果包改变了它在某个时间或在导出的 API 中消耗的随机性`init`，那么显然不是那种需要发布该软件包 v2 的重大更改。  
> 这种按包改变全局源位置与以不同方式播种全局源没有什么区别。因此，如果每个包的更改有效，那么自动播种也是有效的。
> 
> 当然，自动播种意味着包将不太可能依赖于全局源的特定结果，因此当将来发生此类每个包的更改时也不会中断。
> 
> `Seed(1)`可以在需要全局源旧序列并想要恢复旧行为的程序中调用。  
> 当然，这些程序仍然会被刚才描述的每个包的更改所破坏，并且它们最好分配本地源而不是继续使用全局源。

* * *

从[问题 20661](https://github.com/golang/go/issues/20661)和[CL 436955](https://go-review.googlesource.com/c/go/+/436955)中，还请注意`math/rand.Read`已弃用：对于几乎所有用例，`crypto/rand.Read`更合适。

正如[这里所指出的](https://github.com/golang/go/issues/20661#issuecomment-1318871140)：

> 可以像这样使用`gosec`linter`golanglint-ci`并观察`G404`代码：
> 
>     golangci-lint run --disable-all --enable gosec
>

好吧为什么这么复杂！

    package main
    
    import (
        "fmt"
        "math/rand"
        "time"
    )
    
    func main() {
        rand.Seed( time.Now().UnixNano())
        var bytes int
    
        for i:= 0 ; i < 10 ; i++{ 
            bytes = rand.Intn(6)+1
            fmt.Println(bytes)
            }
        //fmt.Println(time.Now().UnixNano())
    }
    

这是基于dystroy 的代码，但适合我的需要。

这是骰子六（rands ints `1 =< i =< 6`）

    func randomInt (min int , max int  ) int {
        var bytes int
        bytes = min + rand.Intn(max)
        return int(bytes)
    }
    

上面的函数是完全相同的。

我希望这些信息有用。

Golang 如何地为随机数生成器设置正确的种子？

在 Go 语言中，数组（Array）是一种固定长度的数据结构，因此你不能直接从数组中删除元素。然而，你可以使用切片（Slice）来模拟这个行为。切片是一种可变长度的数组抽象。

要从切片中删除特定位置的元素，你有几个选择：

1. **使用 append 和切片操作符**：你可以使用两次切片和 `append` 函数将要删除的元素之前和之后的元素连接起来。这个操作不会影响原始的数组，但原始的切片会因为 `append` 而改变。

    ```go
    package main
    
    import "fmt"
    
    func main() {
        // 初始切片
        a := []int{1, 2, 3, 4, 5}
        // 删除索引为 2 的元素（即元素 3）
        a = append(a[:2], a[3:]...)
        
        fmt.Println(a) // 输出：[1 2 4 5]
    }
    ```

    在这个例子中，`a[:2]` 创建了一个包含元素 `1` 和 `2` 的新切片，`a[3:]` 创建了一个包含元素 `4` 和 `5` 的新切片。`append` 函数将这两个切片连接起来，形成一个新的切片，其中不包含元素 `3`。

2. **使用 copy**：如果你想保持原始切片不变，可以使用 `copy` 函数。这种方法会将删除元素之后的元素向前复制一位。

    ```go
    package main
    
    import "fmt"
    
    func main() {
        a := []int{1, 2, 3, 4, 5}
        // 删除索引为 2 的元素
        copy(a[2:], a[3:])
        a = a[:len(a)-1] // 缩减切片的长度
        
        fmt.Println(a) // 输出：[1 2 4 5]
    }
    ```

    在这个例子中，`copy(a[2:], a[3:])` 将切片中索引为 `3` 和 `4` 的元素复制到索引为 `2` 和 `3` 的位置，然后通过缩减切片的长度来丢弃最后一个元素。

需要注意的是，这些操作对基础数组的影响取决于切片的容量和长度。在一些情况下，为避免修改原始数组，可能需要先复制切片。而且，对于大型数据集，这些操作可能会引起性能问题，因为它们涉及到复制许多元素。

在进行删除操作时，通常还需要考虑内存泄漏的问题，尤其是当切片中包含指针或者其他需要垃圾收集的数据结构时。在这种情况下，在进行删除操作后可能需要清除无用的引用：

```go
a := []int{1, 2, 3, 4, 5}
index := 2
copy(a[index:], a[index+1:])
a[len(a)-1] = 0 // 先清零或者设置为nil
a = a[:len(a)-1]

fmt.Println(a) // 输出：[1 2 4 5]
```

这个操作将 `a[index]` 之后的所有元素向前移动一位，并在移动后将最后一个元素设置为默认值（对于整数是 `0`，对于指针是 `nil`），以防止潜在的内存泄漏。然后，它会缩减切片的长度，从而移除了最后一个元素。

**订单事宜**

如果要保持数组有序，则必须将删除索引右侧的所有元素向左移动一位。希望这可以在 Golang 中轻松完成：

    func remove(slice []int, s int) []int {
        return append(slice[:s], slice[s+1:]...)
    }
    

然而，这是低效的，因为您最终可能会移动所有元素，而成本高昂。

**顺序并不重要**

如果您不关心顺序，则可以更快地将要删除的元素替换为切片末尾的元素，然后返回 n-1 个第一个元素：

    func remove(s []int, i int) []int {
        s[i] = s[len(s)-1]
        return s[:len(s)-1]
    }
    

使用重新切片方法，清空 1 000 000 个元素的数组需要 224 秒，而使用此方法只需 0.06 纳秒。

此答案不执行**边界检查**。它需要一个有效的索引作为输入。这意味着大于或等于初始值的负值或索引`len(s)`将导致 Go 恐慌。

切片和数组的索引为 0，删除数组的第 n 个元素意味着提供输入**n-1**。要删除第一个元素，请调用**remove(s, 0)**，要删除第二个元素，请调用**remove(s, 1)**，依此类推。

这看起来有点奇怪，但这里的大多数答案都是危险的，并且掩盖了他们实际在做什么。查看关于从切片中删除项目的原始问题，正在制作切片的副本，然后将其填充。这可以确保当切片在程序中传递时不会引入细微的错误。

下面是一些代码，比较用户在此线程中的答案和原始帖子。这是一个可以在其中乱搞此代码的[go 游乐场。](https://play.golang.org/p/mYaU_Oobzs2)

基于附加的删除
-------

    package main
    
    import (
        "fmt"
    )
    
    func RemoveIndex(s []int, index int) []int {
        return append(s[:index], s[index+1:]...)
    }
    
    func main() {
        all := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
        fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
        removeIndex := RemoveIndex(all, 5)
    
        fmt.Println("all: ", all) //[0 1 2 3 4 6 7 8 9 9]
        fmt.Println("removeIndex: ", removeIndex) //[0 1 2 3 4 6 7 8 9]
    
        removeIndex[0] = 999
        fmt.Println("all: ", all) //[999 1 2 3 4 6 7 9 9]
        fmt.Println("removeIndex: ", removeIndex) //[999 1 2 3 4 6 7 8 9]
    }
    

在上面的示例中，您可以看到我创建了一个切片并手动用数字 0 到 9 填充它。然后我们从所有切片中删除索引 5 并将其指定为删除索引。然而，当我们现在打印出所有内容时，我们发现它也已被修改。这是因为切片是指向底层数组的指针。将其写出也会`removeIndex`导致`all`被修改，区别在于，`all`有一个元素不再可以从 访问`removeIndex`。接下来我们更改一个值`removeIndex`，我们可以看到`all`它也被修改了。[《Effective go》](https://golang.org/doc/effective_go.html#slices)对此进行了更详细的介绍。

我不会详细介绍下面的示例，但它对我们的目的做了同样的事情。这只是说明使用副本没有什么不同。

    package main
    
    import (
        "fmt"
    )
    
    func RemoveCopy(slice []int, i int) []int {
        copy(slice[i:], slice[i+1:])
        return slice[:len(slice)-1]
    }
    
    func main() {
        all := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
        fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
        removeCopy := RemoveCopy(all, 5)
    
        fmt.Println("all: ", all) //[0 1 2 3 4 6 7 8 9 9]
        fmt.Println("removeCopy: ", removeCopy) //[0 1 2 3 4 6 7 8 9]
    
        removeCopy[0] = 999
        fmt.Println("all: ", all) //[99 1 2 3 4 6 7 9 9]
        fmt.Println("removeCopy: ", removeCopy) //[999 1 2 3 4 6 7 8 9]
    }
    

问题原答案
-----

查看原始问题，它不会修改从中删除项目的切片。对于大多数访问此页面的人来说，使该线程中的原始答案成为迄今为止最好的答案。

    package main
    
    import (
        "fmt"
    )
    
    func OriginalRemoveIndex(arr []int, pos int) []int {
        new_arr := make([]int, (len(arr) - 1))
        k := 0
        for i := 0; i < (len(arr) - 1); {
            if i != pos {
                new_arr[i] = arr[k]
                k++
            } else {
                k++
            }
            i++
        }
    
        return new_arr
    }
    
    func main() {
        all := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
        fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
        originalRemove := OriginalRemoveIndex(all, 5)
    
        fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
        fmt.Println("originalRemove: ", originalRemove) //[0 1 2 3 4 6 7 8 9]
    
        originalRemove[0] = 999
        fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
        fmt.Println("originalRemove: ", originalRemove) //[999 1 2 3 4 6 7 8 9]
    }
    

正如您所看到的，此输出符合大多数人的预期，也可能是大多数人想要的。的修改`originalRemove`不会引起变化，`all`删除索引并分配索引的操作也不会引起变化！极好的！

这段代码有点长，所以上面的内容可以改为这样。

正确答案
----

    package main
    
    import (
        "fmt"
    )
    
    func RemoveIndex(s []int, index int) []int {
        ret := make([]int, 0)
        ret = append(ret, s[:index]...)
        return append(ret, s[index+1:]...)
    }
    
    func main() {
        all := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
        fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
        removeIndex := RemoveIndex(all, 5)
    
        fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
        fmt.Println("removeIndex: ", removeIndex) //[0 1 2 3 4 6 7 8 9]
    
        removeIndex[0] = 999
        fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
        fmt.Println("removeIndex: ", removeIndex) //[999 1 2 3 4 6 7 8 9]
    }
    

与原始的删除索引解决方案几乎相同，但是我们在返回之前创建了一个新切片来附加。

从切片中删除一个元素（这称为“重新切片”）：

    package main
    
    import (
        "fmt"
    )
    
    func RemoveIndex(s []int, index int) []int {
        return append(s[:index], s[index+1:]...)
    }
    
    func main() {
        all := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
        fmt.Println(all) //[0 1 2 3 4 5 6 7 8 9]
        all = RemoveIndex(all, 5)
        fmt.Println(all) //[0 1 2 3 4 6 7 8 9]
    }

[`Delete`](https://pkg.go.dev/golang.org/x/exp/slices#Delete)从包中使用`slices`（从 Go 1.21 开始稳定，在较旧的 Go 版本上您必须导入`golang.org/x/exp/slices`）：

    slice := []int{1, 2, 3, 4}
    slice = slices.Delete(slice, 1, 2)
    fmt.Println(slice) // [1 3 4]
    

[去游乐场示例](https://go.dev/play/p/Va9aqo2Qblo)

`slices.Delete(s, i, j)`从 s 中删除元素 s\[i:j\]

*   即从索引 i（包括索引 i）到索引 j（不包括索引 j）的元素
*   或者如果您还记得间隔的数学符号：**\[i,j)**

注意两件事：

*   `Delete`修改原始切片的内容
*   需要重新分配`slice`，否则长度会错误

小一点（代码高尔夫），但在顺序不重要的情况下，您不需要交换值。只需用最后一个位置的副本覆盖要删除的数组位置，然后返回截断的数组。

    func remove(s []int, i int) []int {
        s[i] = s[len(s)-1]
        return s[:len(s)-1]
    }
    

相同的结果。

Golang 如何从数组中删除元素？

Golang（通常称为Go）的编译速度之所以快，主要是归功于以下几个设计决策和特性：

1. **简化的依赖模型**：Go具有明确的依赖模型，每个文件都声明了它的直接依赖项。这种模型简化了依赖关系的管理，并且使得编译器能够快速确定哪些文件需要重新编译，哪些不需要。

2. **包模型**：Go的包模型也有助于加快编译速度。每个包被编译成一个单独的二进制文件，只有当包的源文件发生变化时才需要重新编译，而不是像一些其他语言那样需要重新编译整个项目。

3. **并发编译**：Go编译器被设计成能够利用现代多核处理器。它可以并发地编译不同的文件和包，最大化利用CPU资源，从而减少编译时间。

4. **简化的语言特性**：Go的设计哲学是简洁和清晰，避免了复杂的语言特性，例如类继承。这些简化的特性意味着编译器有更少的工作要做，因此编译过程可以更快完成。

5. **快速解析的语法**：Go的语法设计使得代码可以快速且一次性解析，减少了编译过程中的回溯。这使得语法分析阶段非常高效。

6. **直接生成机器代码**：Go编译器直接生成目标平台的机器代码，而不是像其他语言（如Java或C#）那样生成中间字节码。这样可以避免运行时解释或即时编译，提高编译效率。

7. **编译器优化**：Go编译器经过了优化，以便快速处理代码。这包括对语言特性进行了优化，使得编译器能够有效地生成代码。

举个例子，如果你在一个大型Go项目中只修改了一个小的包，Go编译器会识别出只有这个包及其依赖需要重新编译。由于它可以并发编译独立的包，并且每个包编译后都是独立的二进制文件，这意味着整个编译过程只需要很短的时间就可以完成。

因此，Go的快速编译是多种因素综合作用的结果，这些因素共同构成了Go语言快速且高效编译过程的基础。

依赖性分析。

Go [FAQ](http://golang.org/doc/go_faq.html)曾经包含以下句子：

> Go 提供了一个软件构建模型，使依赖性分析变得容易，并避免了 C 风格包含文件和库的大部分开销。

虽然该短语不再出现在常见问题解答中，但该主题在[Google 的 Go](https://talks.golang.org/2012/splash.article#TOC_5.)演讲中进行了详细阐述，该演讲比较了 C/C++ 和 Go 的依赖分析方法。

这是编译速度快的主要原因。这是设计使然。

我认为并不是Go编译器_快_，而是其他编译器_慢_。

C 和 C++ 编译器必须解析大量的标头 - 例如，编译 C++“hello world”需要编译 18k 行代码，这几乎是半兆字节的源代码！

    $ cpp hello.cpp | wc
      18364   40513  433334
    

Java 和 C# 编译器在 VM 中运行，这意味着在编译任何内容之前，操作系统必须加载整个 VM，然后必须将它们从字节码 JIT 编译为本机代码，所有这些都需要一些时间。

编译速度取决于几个因素。

有些语言被设计为可以快速编译。例如，Pascal 被设计为使用单遍编译器进行编译。

编译器本身也可以优化。例如，Turbo Pascal 编译器是用手工优化的汇编程序编写的，与语言设计相结合，产生了在 286 级硬件上运行的非常快的编译器。我认为即使是现在，现代 Pascal 编译器（例如 FreePascal）也比 Go 编译器更快。

Go 编译器比大多数 C/C++ 编译器快得多的原因有多种：

*   **主要原因**：大多数 C/C++ 编译器的设计都非常糟糕（从编译速度的角度来看）。此外，从编译速度的角度来看，C/C++ 生态系统的某些部分（例如程序员编写代码的编辑器）在设计时并未考虑编译速度。
    
*   **首要原因**：快速编译速度是 Go 编译器和 Go 语言的一个有意识的选择
    
*   Go 编译器比 C/C++ 编译器有更简单的优化器
    
*   与 C++ 不同，Go 没有模板，也没有内联函数。这意味着 Go 不需要执行任何模板或函数实例化。
    
*   Go 编译器会更快地生成低级汇编代码，优化器会处理汇编代码，而在典型的 C/C++ 编译器中，优化过程会处理原始源代码的内部表示。C/C++ 编译器中的额外开销来自需要生成内部表示的事实。
    
*   Go 程序的最终链接 (5l/6l/8l) 可能比链接 C/C++ 程序慢，因为 Go 编译器会遍历所有使用的汇编代码，并且可能还会执行 C/C++ 所不具备的其他额外操作链接器没有做
    
*   一些 C/C++ 编译器 (GCC) 以文本形式生成指令（将传递给汇编器），而 Go 编译器以二进制形式生成指令。需要完成额外的工作（但不多）才能将文本转换为二进制。
    
*   Go编译器仅针对少量CPU架构，而GCC编译器针对大量CPU
    
*   以高编译速度为目标的编译器（例如 Jikes）速度很快。在 2GHz CPU 上，Jikes 每秒可以编译 20000+ 行 Java 代码（增量编译模式效率更高）。

编译效率是一个主要设计目标：

> 最后，它的目的是要快速：在一台计算机上构建一个大型可执行文件最多需要几秒钟。为了实现这些目标，需要解决许多语言问题：富有表现力但轻量级的类型系统；并发和垃圾收集；严格的依赖规范；等等。[常问问题](http://golang.org/doc/faq)

关于与解析相关的特定语言功能，语言常见问题解答非常有趣：

> 其次，该语言被设计为易于分析，无需符号表即可解析。

虽然上面的大部分内容都是正确的，但有一个非常重要的点没有真正提到：依赖管理。

_Go 只需要包含您直接_导入的包（因为那些已经导入了_它们_需要的包）。这与 C/C++ 形成鲜明对比，C/C++ 中**每个文件**开始都包含 x 个标头，其中包括 y 标头等。底线：Go 的编译时间与导入包的数量呈线性关系，而 C/C++ 则需要指数时间。

Golang 的编译速度为什么这么快？

在Go语言中，可以使用标准库`net/http`来发送HTTP POST请求，并且可以用`encoding/json`库来处理JSON数据。以下是如何发送包含JSON字符串的POST请求的一个步骤示例：

1. **定义要发送的数据结构**：首先定义一个与需要发送的JSON数据对应的Go结构体。

```go
type MyData struct {
    Field1 string `json:"field1"`
    Field2 int    `json:"field2"`
}
```

2. **创建JSON字符串**：使用`json.Marshal`函数来将Go结构体转换成JSON字符串。

```go
data := MyData{
    Field1: "value1",
    Field2: 42,
}

jsonData, err := json.Marshal(data)
if err != nil {
    // 处理错误情况
    log.Fatalf("Error happened in JSON marshal. Err: %s", err)
}
```

3. **创建POST请求**：使用`http.NewRequest`函数来创建一个POST请求，并将JSON字符串作为请求体。

```go
url := "http://example.com/api/resource"
req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
if err != nil {
    // 处理错误情况
    log.Fatalf("Error occurred while creating HTTP request. Err: %s", err)
}
```

4. **添加请求头**：设置HTTP请求头`Content-Type`为`application/json`，这表明正在发送的数据类型是JSON。

```go
req.Header.Set("Content-Type", "application/json")
```

5. **发送请求并处理响应**：使用`http.Client`的`Do`方法发送请求，并处理服务器返回的响应。

```go
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
    // 处理错误情况
    log.Fatalf("Error occurred while sending the HTTP request. Err: %s", err)
}
defer resp.Body.Close()

// 检查服务器响应的HTTP状态码是否为200 OK
if resp.StatusCode == http.StatusOK {
    // 处理成功的情况，例如读取响应体
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
} else {
    // 处理服务器返回的错误
    log.Printf("Server responded with a non-200 status code: %d", resp.StatusCode)
}
```

上述代码展示了如何构建一个POST请求，其中包含JSON数据，并且发送该请求到服务器。在实际的编程实践中，通常还需要进行更多的错误检查和异常处理，以确保程序的健壮性。

我不熟悉`napping`，但是使用 Golang 的`net/http`包效果很好（[playground](http://play.golang.org/p/Qpob4Yu3wG)）：

    func main() {
        url := "http://restapi3.apiary.io/notes"
        fmt.Println("URL:>", url)
    
        var jsonStr = []byte(`{"title":"Buy cheese and bread for breakfast."}`)
        req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonStr))
        req.Header.Set("X-Custom-Header", "myvalue")
        req.Header.Set("Content-Type", "application/json")
    
        client := &http.Client{}
        resp, err := client.Do(req)
        if err != nil {
            panic(err)
        }
        defer resp.Body.Close()
    
        fmt.Println("response Status:", resp.Status)
        fmt.Println("response Headers:", resp.Header)
        body, _ := io.ReadAll(resp.Body)
        fmt.Println("response Body:", string(body))
    }

你可以只使用`post`发布你的json。

    values := map[string]string{"username": username, "password": password}
    
    jsonValue, _ := json.Marshal(values)
    
    resp, err := http.Post(authAuthenticatorUrl, "application/json", bytes.NewBuffer(jsonValue))

如果你已经有一个结构体。

    import (
        "bytes"
        "encoding/json"
        "io"
        "net/http"
        "os"
    )
    
    // .....
    
    type Student struct {
        Name    string `json:"name"`
        Address string `json:"address"`
    }
    
    // .....
    
    body := &Student{
        Name:    "abc",
        Address: "xyz",
    }
    
    payloadBuf := new(bytes.Buffer)
    json.NewEncoder(payloadBuf).Encode(body)
    req, _ := http.NewRequest("POST", url, payloadBuf)
    
    client := &http.Client{}
    res, e := client.Do(req)
    if e != nil {
        return e
    }
    
    defer res.Body.Close()
    
    fmt.Println("response Status:", res.Status)
    // Print the body to the stdout
    io.Copy(os.Stdout, res.Body)
    

完整[要点](https://gist.github.com/ReeganExE/af2259bcdec3e8535bfaaa86a2c03e39)。

除了标准的 net/http 包之外，您还可以考虑使用我的[GoRequest](http://github.com/parnurzeal/gorequest)，它包装了 net/http，让您的生活更轻松，而无需过多考虑 json 或 struct。但您也可以在一个请求中混合搭配它们！（您可以在 gorequest github 页面中查看更多详细信息）

所以，最终你的代码将变成如下所示：

    func main() {
        url := "http://restapi3.apiary.io/notes"
        fmt.Println("URL:>", url)
        request := gorequest.New()
        titleList := []string{"title1", "title2", "title3"}
        for _, title := range titleList {
            resp, body, errs := request.Post(url).
                Set("X-Custom-Header", "myvalue").
                Send(`{"title":"` + title + `"}`).
                End()
            if errs != nil {
                fmt.Println(errs)
                os.Exit(1)
            }
            fmt.Println("response Status:", resp.Status)
            fmt.Println("response Headers:", resp.Header)
            fmt.Println("response Body:", body)
        }
    }
    

这取决于您想要如何实现。我创建这个库是因为我和你有同样的问题，我想要更短的代码，易于使用 json，并且在我的代码库和生产系统中更易于维护。

http 或 https 的 post 请求示例

        //Encode the data
           postBody, _ := json.Marshal(map[string]string{
              "name":  "Test",
              "email": "Test@Test.com",
           })
           responseBody := bytes.NewBuffer(postBody)
        //Leverage Go's HTTP Post function to make request
           resp, err := http.Post("https://postman-echo.com/post", "application/json", responseBody)
        //Handle Error
           if err != nil {
              log.Fatalf("An Error Occured %v", err)
           }
           defer resp.Body.Close()
        //Read the response body
           body, err := ioutil.ReadAll(resp.Body)
           if err != nil {
              log.Fatalln(err)
           }
           sb := string(body)
           log.Printf(sb)

Golang 如何在 post 请求中发送 json 字符串？

在 Golang 中，我们可以使用 `os` 标准库中的 `Executable` 函数来获取当前正在执行的可执行文件的完整路径，然后使用 `filepath` 标准库中的 `Dir` 函数来从完整路径中提取出目录。

下面是一个如何获取当前运行文件所在目录的示例代码：

```go
package main

import (
	"fmt"
	"os"
	"path/filepath"
)

func main() {
	// 获取当前执行的可执行文件的路径
	exePath, err := os.Executable()
	if err != nil {
		panic(err)
	}

	// 获取可执行文件所在的目录
	exeDir := filepath.Dir(exePath)

	fmt.Println("当前运行文件的目录是:", exeDir)
}
```

在这个例子中，我们首先调用了 `os.Executable()` 函数来获取可执行文件的完整路径。如果调用成功，它会返回路径字符串和 `nil` 错误。如果有错误发生，我们通过 `panic` 终止程序。获取到可执行文件的完整路径后，我们使用 `filepath.Dir()` 函数来从中提取出文件所在的目录。

执行上面的程序，它将打印出当前运行的可执行文件所在的目录。这对于许多需要相对于可执行文件定位资源文件的应用程序非常有用，例如配置文件和模板。

编辑：从 Go 1.8（2017 年 2 月发布）开始，推荐的方法是[`os.Executable`](https://tip.golang.org/pkg/os/#Executable)：

> `func Executable() (string, error)`
> 
> 可执行文件返回启动当前进程的可执行文件的路径名。无法保证路径仍然指向正确的可执行文件。如果使用符号链接来启动进程，则结果可能是符号链接或其指向的路径，具体取决于操作系统。如果需要稳定的结果，path/filepath.EvalSymlinks 可能会有所帮助。

要仅获取可执行文件的目录，您可以使用[`path/filepath.Dir`](https://golang.org/pkg/path/filepath/#Dir).

[例子](https://play.golang.org/p/_aolLr7uEH)：

    package main
    
    import (
        "fmt"
        "os"
        "path/filepath"
    )
    
    func main() {
        ex, err := os.Executable()
        if err != nil {
            panic(err)
        }
        exPath := filepath.Dir(ex)
        fmt.Println(exPath)
    }
    

* * *

旧答案：

你应该能够使用[`os.Getwd`](http://golang.org/pkg/os/#Getwd)

    func Getwd() (pwd string, err error)
    

> Getwd 返回与当前目录相对应的根路径名。如果当前目录可以通过多个路径到达（由于符号链接），Getwd 可能会返回其中任何一个。

例如：

    package main
    
    import (
        "fmt"
        "os"
    )
    
    func main() {
        pwd, err := os.Getwd()
        if err != nil {
            fmt.Println(err)
            os.Exit(1)
        }
        fmt.Println(pwd)
    }

这应该可以做到：

    import (
        "fmt"
        "log"
        "os"
        "path/filepath"
    )
    
    func main() {
        dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
        if err != nil {
                log.Fatal(err)
        }
        fmt.Println(dir)
    }

使用[osext包](https://github.com/kardianos/osext)

它提供的函数`ExecutableFolder()`返回当前运行的程序可执行文件所在文件夹的绝对路径（对于 cron 作业很有用）。它是跨平台的。

[在线文档](http://godoc.org/github.com/kardianos/osext)

    package main
    
    import (
        "github.com/kardianos/osext"
        "fmt"
        "log"
    )
    
    func main() {
        folderPath, err := osext.ExecutableFolder()
        if err != nil {
            log.Fatal(err)
        }
        fmt.Println(folderPath)
    }

我从 Node.js 转向 Go。相当于 Go 中的 Node.js`__dirname`是：

    _, filename, _, ok := runtime.Caller(0)
    if !ok {
        return errors.New("unable to get the current filename")
    }
    dirname := filepath.Dir(filename)
    

该线程中还提到了一些其他内容以及为什么它们是错误的：

*   `os.Executable()`将为您提供当前运行的可执行文件的文件路径。这相当于`process.argv[0]`在 Node.js 中。`__dirname`如果您想获取子包的 ，则情况并非如此。
*   `os.Getwd()`会给你当前的工作目录。这相当于`process.cwd()`在 Node.js 中。当您从另一个目录运行程序时，这将是错误的。

最后，我建议不要为此用例引入第三方包。这是您可以使用的包：

    package current
    
    // Filename is the __filename equivalent
    func Filename() (string, error) {
        _, filename, _, ok := runtime.Caller(1)
        if !ok {
            return "", errors.New("unable to get the current filename")
        }
        return filename, nil
    }
    
    
    // Dirname is the __dirname equivalent
    func Dirname() (string, error) {
        filename, err := Filename()
        if err != nil {
            return "", err
        }
        return filepath.Dir(filename), nil
    }
    

请注意，我已调整`runtime.Caller(1)`为 1，因为我们想要获取调用的包的目录`current.Dirname()`，而不是包含该包的目录`current`。

**更新 (12/23)**正如 @VonC[下面指出的](https://stackoverflow.com/a/72174376/145435)，当您运行`go build`并分发二进制文件时，`runtime.Caller(0)`, 将继续是_您的目录_。这可能不是您想要的。此行为与 不同`__dirname`，后者将反映文件所在位置的目录名。Go 中的这种行为没有完美的等价物。

如果你这样做：

    dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(dir)
    

当您使用 GoLand 等 IDE 运行程序时，您将获得 /tmp 路径，因为可执行文件将从 /tmp 保存并运行

我认为获取当前工作目录或“。”的最佳方法 是 ：

    import(
      "os" 
      "fmt"
      "log"
    )
    
    func main() {
      dir, err := os.Getwd()
        if err != nil {
            log.Fatal(err)
        }
      fmt.Println(dir)
    }
    

os.Getwd **()**函数将返回当前工作目录。

所有问题