本教程将告诉你如何完全在云端建立你自己的 Discord 机器人。

你不需要在你的电脑上安装任何东西，也不需要支付任何费用来托管你的机器人。

我们将使用一些工具，包括 Discord API、Python 库和一个名为 Repl.it 的云计算平台。

这个书面教程也有一个视频版本。

如何创建一个 Discord Bot 账户

为了使用 Python 库和 Discord API，我们必须首先创建一个 Discord Bot 账户。

以下是创建 Discord Bot 账户的步骤。

1. 确保你已经登录到 Discord 网站

2. 进入应用程序页面

3. 点击 New Application 按钮

4. 给应用程序一个名称，然后点击 Create 按钮

5. 进入 Bot 标签，然后点击 Add Bot。你必须点击 Yes, do it!

保持默认设置 Public Bot（选中）和 Require OAuth2 Code Grant（未选中）。

你的机器人已经创建完毕。下一步是复制令牌（token）。

这个令牌是你的机器人的密码，所以不要与任何人分享它。它可以让别人登录到你的机器人并做各种坏事。

如果不小心被分享，你可以重新生成令牌。

如何邀请你的机器人接入一个服务器

现在你必须让你的机器人用户接入一个服务器。要做到这一点，你应该为它创建一个邀请 URL。

转到 OAuth2 标签。然后在 scopes 部分选择 bot。

现在为机器人选择你想要的权限。我们的机器人将主要使用文本信息，所以我们不需要很多的权限。你可能需要更多的权限，这取决于你希望你的机器人做什么。对 Administrator 的权限要小心。

选择适当的权限后，点击权限上方的 copy 按钮。这将复制一个 URL，可用于将机器人添加到一个服务器。

把这个 URL 粘贴到你的浏览器，选择一个服务器来接入机器人，然后点击 Authorize。

要添加机器人，你的账户需要 Manage Server 的权限。

现在你已经创建了机器人用户，我们将开始为机器人编写 Python 代码。

如何用 discord.py 库编写一个基本的 Discord 机器人代码

我们将使用 discord.py， 这个 Python 库来编写机器人的代码。discord.py 是 Discord 的一个 API 封装器，使在 Python 中更容易创建一个 Discord 机器人。

如何创建一个 Repl 项目并安装 discord.py

你可以在你的本地电脑上用任何代码编辑器开发机器人。然而，在本教程中，我们将使用 Repl.it，因为它操作起来比较简便。Repl.it 是一个在线 IDE，你可以在你的网络浏览器中使用。

首先进入 Repl.it。创建一个新的 Repl，选择 Python 作为语言。

要使用 discord.py 库，只要在 main.py 的顶部写上 import discord。当你按下 run 按钮时，Repl.it 会自动安装这个依赖。

如果你喜欢在本地编码机器人，你可以在 MacOS 上使用这个命令来安装 discord.py：

python3 -m pip install -U discord.py

你可能需要使用 pip3 而不是 pip。

如果你使用的是 Windows，那么你应该使用下面一行代码：

py -3 -m pip install -U discord.py

如何为你的机器人设置 Discord 事件

discord.py 基于事件的概念。一个事件是你监听的东西，然后对其作出回应。例如，当一条消息发生时，你会收到一个关于它的事件，你可以对其作出回应。

让我们做一个机器人，回复一个特定的消息。这个简单的机器人代码，以及代码解释，来自于the discord.py documentation。我们将在以后为机器人添加更多的功能。

将这段代码添加到 main.py 中。如果你愿意，你可以给这个文件起个别的名字，但不要叫 discord.py。我很快会解释这些代码的作用。

import discord
import os

client = discord.Client()

@client.event
async def on_ready():
    print('We have logged in as {0.user}'.format(client))

@client.event
async def on_message(message):
    if message.author == client.user:
        return

    if message.content.startswith('$hello'):
        await message.channel.send('Hello!')

client.run(os.getenv('TOKEN'))

当你在 Discord 上创建你的机器人用户时，你复制了一个令牌。现在我们要创建一个 .env 文件来存储该令牌。如果你在本地运行你的代码，你不需要 .env 文件。只要用令牌替换 os.getenv('TOKEN') 就可以了。

.env 文件是用来声明环境变量的。在 Repl.it 上，你创建的大多数文件对任何人都是可见的，但 .env 文件只对你可见。 其他人将无法看到公共 repl 里的.env文件的内容。

因此，如果你在 Repl.it 上开发，应该只在 .env 文件中存储私人信息，如令牌或密钥。

点击 Add file按钮，创建一个名为 .env 的文件。

在文件中添加以下一行，包括你之前复制的令牌（token）：

TOKEN=[paste token here]

现在让我们来看看每一行代码在你的 Discord 机器人中的作用是什么。

1. 第一行是导入 discord.py 库。
2. 第二行导入 os 库，但这只是用于从 .env 文件中获取 TOKEN 变量。如果你不使用 .env 文件，你不需要这一行。
3. 接下来，我们创建一个 Client 的实例。这是与 Discord 的连接。
4. @client.event() 装饰器被用来注册一个事件。这是一个异步库，所以事情是通过回调完成的。回调是一个当其他事情发生时被调用的函数。在这段代码中，当机器人准备开始使用时，on_ready() 事件被调用。然后，当机器人收到一个消息时，on_message() 事件被调用。
5. on_message() 事件在每次收到消息时都会触发，但如果消息是来自我们自己，我们不希望它做任何事情。因此，如果Message.author 与 Client.user 相同，代码只是返回。
6. 接下来，我们检查 Message.content 是否以 $hello 开头。如果是，那么机器人就会向它所使用的频道回复 Hello!。
7. 现在机器人已经设置好了，最后一行是用登录令牌运行机器人。它从 .env 文件中获取令牌。

我们有了机器人的代码，现在我们只需要运行它。

如何运行机器人

现在点击上面的 run 按钮，在 repl.it 中运行你的机器人。

如果你是在本地编写机器人，你可以在终端使用下面这些命令来运行该机器人。

在 Windows 系统：

py -3 main.py

在别的系统：

python3 main.py

现在去你的 Discord 房间，输入$hello。你的机器人应该返回 Hello。

如何改进机器人

现在我们有了一个基本的机器人工作，我们将改进它。它被称为 鼓励机器人 是有原因的。

每当有人发来含有悲伤或压抑字眼的信息时，这个机器人就会以鼓励的信息来回应。

任何人都可以为机器人添加鼓励信息，用户提交的信息将被储存在 Repl.it 数据库中。

当有人在聊天中输入 $inspire 信息时，机器人也会从 API 中随机返回一句鼓舞人心的话。

我们将从添加 $inspire 功能开始。

如何在机器人上添加鼓舞人心的名言

我们将从一个名为 zenquotes.io 的 API 中获得鼓舞人心的语录。我们需要再导入几个 Python 模块，添加一个get_quote()函数，并更新我们的机器人代码以调用该函数。

下面是更新后的代码。在代码之后，我将解释新的部分。

import discord
import os
import requests
import json

client = discord.Client()

def get_quote():
  response = requests.get("https://zenquotes.io/api/random")
  json_data = json.loads(response.text)
  quote = json_data[0]['q'] + " -" + json_data[0]['a']
  return(quote)

@client.event
async def on_ready():
  print('We have logged in as {0.user}'.format(client))

@client.event
async def on_message(message):
  if message.author == client.user:
    return

  if message.content.startswith('$inspire'):
    quote = get_quote()
    await message.channel.send(quote)

client.run(os.getenv('TOKEN'))

我们现在必须导入 requests 模块。这个模块允许我们的代码进行 HTTP 请求，从 API 获得数据。API 返回 JSON，所以 json 模块使我们更容易处理返回的数据。

get_quote() 函数是非常简单的。首先，它使用 requests 模块从 API URL 请求数据。API 会返回一个随机的鼓舞人心的引言。如果当前的 API 停止工作，这个函数可以很容易地被重写，以从不同的 API 获得引言。

接下来在这个函数中，我们使用 json.load() 将 API 的响应转换为 JSON。通过试验和错误，我找到了如何将 JSON 中的引言转换成我想要的字符串格式。引言被作为一个字符串从函数中返回。

代码中最后更新的部分是在最后。以前，它寻找以 $hello 开头的信息。现在它寻找的是 $inspire。它不再返回 Hello!，而是用 quote = get_quote() 来获取引言，并返回引言。

在这一点上，你可以运行你的代码并尝试一下。

如何向机器人添加鼓励性的信息

现在我们要实现的功能是，当用户发布带有悲伤字眼的信息时，机器人会以鼓励性的信息进行回应。

如何在机器人中添加悲伤的词语

首先，我们需要创建一个 Python 列表，其中包含机器人将回应的悲伤的词语。

在创建client变量后添加以下一行:

sad_words = ["sad", "depressed", "unhappy", "angry", "miserable"]

请随意在列表中添加更多的单词。

如何向机器人添加鼓励性的信息

现在我们将添加一个鼓励性的信息列表，机器人将用这些信息来回应。

在你创建的sad_words列表后面添加以下列表:

starter_encouragements = [
  "Cheer up!",
  "Hang in there.",
  "You are a great person / bot!"
]

像以前一样，请随时在列表中添加更多你选择的短语。我现在只使用三个项目，因为以后我们会增加用户添加更多鼓励性短语的能力，供机器人使用。

如何回复留言

现在我们需要更新我们的机器人来使用我们创建的两个列表。首先，导入随机模块，因为机器人将随机选择鼓励信息。在代码顶部的导入语句中添加以下一行。import random。

现在我们将更新on_message()函数，以检查所有信息，看它们是否包含sad_words列表中的一个词。如果发现一个悲伤的词，机器人将发送一条随机的鼓励信息。

以下是更新后的代码：

async def on_message(message):
  if message.author == client.user:
    return

  msg = message.content

  if msg.startswith('$inspire'):
    quote = get_quote()
    await message.channel.send(quote)
    
  if any(word in msg for word in sad_words):
    await message.channel.send(random.choice(starter_encouragements))

这是一个测试机器人的好时机。你现在知道的足够多，可以创建你自己的机器人。但接下来你将学习如何实现更高级的功能，并使用 Repl.it 数据库存储数据。

如何启用用户提交信息

这个机器人是完全正常的，但现在让我们从 Discord 中直接更新机器人。用户应该能够添加更多的鼓励性信息，以便机器人在检测到一个悲伤的词时使用。

我们将使用 Repl.it 的内置数据库来存储用户提交的信息。这个数据库是一个键值存储，内置于每个 Repl.it 中。

在代码的顶部，在其他导入语句下，添加 from replit import db。这将使我们能够使用 Repl.it 数据库。

用户将能够直接从 Discord 聊天中为机器人添加自定义鼓励信息。在我们为机器人添加新的命令之前，让我们创建两个辅助函数，将自定义消息添加到数据库并删除它们。

在 get_quote() 函数后添加以下代码:

def update_encouragements(encouraging_message):
  if "encouragements" in db.keys():
    encouragements = db["encouragements"]
    encouragements.append(encouraging_message)
    db["encouragements"] = encouragements
  else:
    db["encouragements"] = [encouraging_message]

def delete_encouragment(index):
  encouragements = db["encouragements"]
  if len(encouragements) > index:
    del encouragements[index]
  db["encouragements"] = encouragements

update_encouragements()函数接受一个鼓励信息作为参数。

首先，它检查 encouragements 是否是数据库中的一个键（key）。如果是，它将获得已经在数据库中的鼓励信息列表，将新的鼓励信息添加到列表中，并将更新的列表存储在数据库中的 encouragements 键下。

如果数据库中还没有 encouragements，就用这个名字创建一个新的键，并将新的鼓励信息作为列表中的第一个元素加入。

delete_encouragement() 函数接受一个索引作为参数。

它从数据库中获取存储在 encouragements 键下的鼓励信息列表。如果鼓励列表中的项目数量大于索引，则删除该索引处的列表项。

最后，更新后的列表被存储在数据库的 encouragements 键下。

下面是 on_message() 函数的更新代码。在代码之后，我将解释新的部分。

async def on_message(message):
  if message.author == client.user:
    return

  msg = message.content
 
  if msg.startswith("$inspire"):
    quote = get_quote()
    await message.channel.send(quote)

  options = starter_encouragements
  if "encouragements" in db.keys():
    options = options + db["encouragements"]

  if any(word in msg for word in sad_words):
    await message.channel.send(random.choice(options))

  if msg.startswith("$new"):
    encouraging_message = msg.split("$new ",1)[1]
    update_encouragements(encouraging_message)
    await message.channel.send("New encouraging message added.")

  if msg.startswith("$del"):
    encouragements = []
    if "encouragements" in db.keys():
      index = int(msg.split("$del",1)[1])
      delete_encouragment(index)
      encouragements = db["encouragements"]
    await message.channel.send(encouragements)

上面的第一行新代码是 options = starter_encouragements。我们复制了变量 starter_encouragements的值，因为我们要把用户提交的信息添加到该列表中，然后再为机器人选择一条随机信息来发送。

我们检查 encouragements 是否已经在数据库键中（意味着用户已经提交了至少一条自定义消息）。如果是的话，我们就把用户信息添加到启动器的鼓励信息中。

然后，机器人现在不是从 starter_encouragements 中随机发送消息，而是从 options 中随机发送消息。

下一段新的代码是将用户提交的新消息添加到数据库中。如果一条 Discord 信息以 $new开头，那么 $new 之后的文字将被用作新的鼓励信息。

代码msg.split("$new",1)[1]从 $new 命令中分离出信息，并将该信息存储在一个变量中。在这行代码中，注意"$new "中的空格。我们要的是空格之后的所有内容。

我们调用 update_encouragements 辅助函数处理新消息，然后机器人向 discord 聊天室发送一条消息，确认消息被添加。

第三个新部分（在上面代码的末尾）检查新的 discord 消息是否以$del 开头。这是删除数据库中 encouragements 列表中的一个项目的命令。

首先，一个名为 encouragements 的新变量被初始化为一个空数组。这样做的原因是，如果数据库中不包括 encouragement 键，这部分代码将发送一个空数组的信息。

如果 encouragement 键在数据库中，索引将从以 $del 开始的 Discord 消息中分离出来。然后，调用delete_encouragement()函数，传入要删除的索引。更新的鼓励列表被加载到 encouragements 变量中，然后机器人向 Discord 发送一条带有当前列表的消息。

最后要添加机器人的功能

该机器人应该可以工作，所以现在是测试它的好时机。我们现在将添加一些最后的功能。

我们将增加从 Discord 中直接获得用户提交的信息列表的功能，并且我们将增加关闭和开启机器人是否对伤心话做出反应的功能。

我将给你们提供程序的全部最终代码，然后我将在下面讨论更新的代码。

import discord
import os
import requests
import json
import random
from replit import db

client = discord.Client()

sad_words = ["sad", "depressed", "unhappy", "angry", "miserable"]

starter_encouragements = [
  "Cheer up!",
  "Hang in there.",
  "You are a great person / bot!"
]

if "responding" not in db.keys():
  db["responding"] = True

def get_quote():
  response = requests.get("https://zenquotes.io/api/random")
  json_data = json.loads(response.text)
  quote = json_data[0]["q"] + " -" + json_data[0]["a"]
  return(quote)

def update_encouragements(encouraging_message):
  if "encouragements" in db.keys():
    encouragements = db["encouragements"]
    encouragements.append(encouraging_message)
    db["encouragements"] = encouragements
  else:
    db["encouragements"] = [encouraging_message]

def delete_encouragment(index):
  encouragements = db["encouragements"]
  if len(encouragements) > index:
    del encouragements[index]
  db["encouragements"] = encouragements

@client.event
async def on_ready():
  print("We have logged in as {0.user}".format(client))

@client.event
async def on_message(message):
  if message.author == client.user:
    return

  msg = message.content

  if msg.startswith("$inspire"):
    quote = get_quote()
    await message.channel.send(quote)

  if db["responding"]:
    options = starter_encouragements
    if "encouragements" in db.keys():
      options = options + db["encouragements"]

    if any(word in msg for word in sad_words):
      await message.channel.send(random.choice(options))

  if msg.startswith("$new"):
    encouraging_message = msg.split("$new ",1)[1]
    update_encouragements(encouraging_message)
    await message.channel.send("New encouraging message added.")

  if msg.startswith("$del"):
    encouragements = []
    if "encouragements" in db.keys():
      index = int(msg.split("$del",1)[1])
      delete_encouragment(index)
      encouragements = db["encouragements"]
    await message.channel.send(encouragements)

  if msg.startswith("$list"):
    encouragements = []
    if "encouragements" in db.keys():
      encouragements = db["encouragements"]
    await message.channel.send(encouragements)
    
  if msg.startswith("$responding"):
    value = msg.split("$responding ",1)[1]

    if value.lower() == "true":
      db["responding"] = True
      await message.channel.send("Responding is on.")
    else:
      db["responding"] = False
      await message.channel.send("Responding is off.")

client.run(os.getenv("TOKEN"))

添加到代码中的第一个部分就在 starter_encouragements 列表下面：

if "responding" not in db.keys():
  db["responding"] = True

我们在数据库中创建一个名为 responding 的新键，并将其设置为 true。我们将用它来决定机器人是否应该对悲伤的话语做出反应。由于数据库即使在程序停止运行后也会被保存，所以我们只在新键不存在的情况下创建它。

代码的下一个新部分是，对伤心话做出反应的部分现在在这个 if 语句里面：if db["responding"]:。只有当db["responing"] = True时，机器人才会对悲伤的词语做出反应。更新这个值的动作是在下一节之后。

接下来，在使机器人响应 $del 命令的代码之后，有新的代码来响应作为 Discord 消息发送的 $list 命令。

这一部分首先是创建一个名为 encouragements 的空列表。然后，如果数据库中已经有鼓励语（encouragements），这些鼓励语将取代刚刚创建的空列表。

最后，机器人将鼓励（encouragements）列表作为 Discord 消息发送出去。

接下来是最后的新部分。这段代码使机器人对 $responding 命令作出反应。这个命令的参数是 true 或 false。下面是一个使用例子。$responding true。

代码首先用value = msg.split("$responding",1)[1] 获得一个值（和前面一样，注意"$responding"的空格）。然后有一个 if/else 语句，适当地设置数据库中的 responding 键，并向 Discord 发送一个通知信息。如果参数不是 true，代码就假定为 false。

该机器人的代码已经完成！你现在可以运行机器人并试用它了。但还有一个重要的步骤，我们接下来会讨论。

如何设置机器人连续运行

如果你在 repl.it 中运行你的机器人，然后关闭它所运行的标签，你的机器人将停止运行。

但有两种方法可以让你的机器人持续运行，即使在你关闭你的网络浏览器之后。

第一个方法和最简单的方法是在 Repl.it 注册付费计划。他们最便宜的付费计划被称为黑客计划，它包括五个永远在线的 repls 项目。

你可以通过这个链接获得三个月的免费服务（限于前 1000 人）： https://repl.it/claim?code=tryalwayson2103

当你注册了该计划，打开你的 Repl，点击顶部的项目名字。然后选择 Always On (永久在线) 选项。

还有一种方法可以使你的代码保持运行，即使是在免费计划，但它有点复杂。Repl.it 在标签关闭之后。但即使是网络服务器，也只能在没有任何使用的情况下运行一个小时。

下面是 repl.it 文档中的内容：

当部署完，服务器将继续在后台运行，甚至在你关闭浏览器标签之后。服务器将保持运行和活跃，直到最后一次请求后一个小时，之后它将进入睡眠阶段。睡眠中的 Repls 一旦收到一个请求就会被唤醒；不需要重新运行。然而，如果你对你的服务器做了修改，你将需要重新启动 repl，以便看到这些修改反映在新版本中。

为了保持机器人的持续运行，我们将使用另一项免费的服务，叫做 Uptime Robot。

Uptime Robot 可以被设置为每 5 分钟 ping 一次在 repl.it 上机器人的网络服务器。有了持续的 ping，机器人将永远不会进入睡眠阶段，而会一直运行。

因此，我们必须再做两件事来使我们的机器人持续运行：

1. 在 repl.it 中创建一个网络服务器，然后
2. 设置 Uptime Robot，以持续地 ping 该 Web 服务器。

如何在 repl.it 中创建一个 Web 服务器

创建一个网络服务器比你想象的要简单。

要做到这一点，在你的项目中创建一个新的文件，叫做 keep_alive.py。

然后添加以下代码:

from flask import Flask
from threading import Thread

app = Flask('')

@app.route('/')
def home():
    return "Hello. I am alive!"

def run():
  app.run(host='0.0.0.0',port=8080)

def keep_alive():
    t = Thread(target=run)
    t.start()

在这段代码中，我们使用 Flask 来启动一个网络服务器。该服务器向访问它的人返回 “Hello. I am alive.” 给任何访问它的人。该服务器将在与我们的机器人分开的线程上运行。我们不会在这里讨论所有的东西，因为其他的东西与我们的机器人并不相关。

现在我们只需要机器人来运行这个网络服务器。

在 main.py 的顶部添加以下一行来导入服务器。

from keep_alive import keep_alive

要在运行 main.py 时启动网络服务器，请在机器人运行前的倒数第二行添加以下一行。

keep_alive()

当你加入这段代码后在 repl.it 上运行机器人时，一个新的 Web 服务器窗口将被打开。这里有一个网络服务器的 URL。复制这个 URL，这样你就可以在下一节中使用它。

如何设置机器人运行

现在，我们需要设置 Uptime Robot，使其每隔 5 分钟就对网络服务器进行一次 ping。这将使机器人持续运行。

在 https://uptimerobot.com/ 上创建一个免费账户。

一旦你登录到你的账户，点击 “Add New Monitor”。

对于新的监控器（monitor），选择 “HTTP(s)” 作为监控器类型，并命名为你喜欢的任何名字。然后，从 repl.it 中粘贴你的网络服务器的 URL。最后，点击 “Create Monitor”。

我们完成了！现在，这个机器人将持续运行，所以人们可以一直在 Repl.it 上 与它互动。

结语

你现在知道如何用 Python 创建一个 Discord 机器人，并在云上持续运行。

discord.py 库还可以做很多其他的事情。因此，如果你想让 Discord 机器人拥有更多的功能，你的下一步是查看 discord.py 文档

100 天编程挑战在希望提升技能的编程学习者和经验丰富的开发者中都非常流行。它是如此受欢迎，以至于我们的 Discord 服务器有一个频道专门讨论它。

应大家的要求，我们创建了一个 Discord 机器人，帮助人们跟踪他们在挑战中的进展。

今天我将向你展示如何创建你自己的 “100 天编程挑战”机器人。

目录

• 创建一个 Discord 机器人应用程序
• 设置你的项目
• 创建 Discord 机器人
• Discord 中的网关事件
• 连接到数据库
• 环境变量验证
• 交互事件
• 准备命令
• 数据库模型
• 编写机器人命令

创建一个 Discord 机器人应用程序

你的第一步是设置一个 Discord 机器人应用程序。前往 Discord Developer Portal，如果需要，请登录，并从侧边栏选择 “Applications”。

从侧边栏选择 “Bot”，然后点击 “Add Bot” 按钮。这将为你的应用程序创建一个 Discord Bot 账户。

这是你将获得的机器人令牌（token）的截图。保密这个令牌是非常重要的，因为它允许你的代码连接到你的机器人。请保证它的安全，不要与任何人分享它。

现在你需要将机器人添加到一个服务器上，与它进行交互。点击侧边栏上的 “OAuth2” 选项，然后选择 “URL Generator”。

在 “Scopes” 下，选择bot和application.command。bot范围允许你的机器人账户加入服务器，而application.command范围允许你更新斜线命令（后面会有更多介绍 slash commands）。

当你选择bot时，会出现一个新的 “Bot Permissions” 部分。选择以下权限：

• Send Messages
• Embed Links
• Read Messages/View Channels

复制生成的 URL，并将其粘贴到你的浏览器。这将使你通过 Discord 的程序，将你的新机器人添加到一个服务器。

注意，你必须在你想添加机器人的服务器中拥有管理服务器的权限。如果你没有这个权限，你可以创建一个服务器来测试你的机器人。

现在你已经准备好写一些代码了！

设置你的项目

你首先需要为你的项目创建基础设施和工具。

确保你安装了 Node.js 版本 16和npm。注意，你将使用的软件包不支持早期版本的 Node。

准备package.json文件

为你的项目创建一个目录，或文件夹。打开你的终端，指向这个新文件夹。运行命令npm init来设置你的package.json文件。在本教程中，默认值就足够了，但你可以根据你的需要自由编辑。

你最终应该得到一个类似于以下的package.json：

{
  "name": "100doc-tutorial",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC"
}

现在你需要做一些改变，为 TypeScript 的实现做好准备。

首先，将index.js的main值替换为./prod/index.js——你将设置你的 TypeScript 编译到prod目录。

然后删除test脚本，添加以下两个脚本：

"build": "tsc",
"start": "node -r dotenv/config ./prod/index.js"

build脚本将把你的 TypeScript 编译成 JavaScript，以便 Node 可以运行它，start脚本将运行index.js入口文件。

在这里添加-r dotenv/config将动态导入并运行dotenv包中的config方法，它从.env文件中加载你的环境变量。

你的下一步是安装依赖项。使用npm install，安装这些依赖项：

• discord.js – 这是一个处理连接到网关和管理 Discord API 调用的库
• @discordjs/builders – 用于构建应用程序命令的 discord.js 包
• @discordjs/rest – 用于与 Discord REST API 互动的自定义 API 客户端
• discord-api-types – Discord REST API 的类型定义和处理程序
• dotenv – 一个将`.env'值加载到 Node 进程的包
• mongoose – MongoDB 连接的驱动，提供了结构化数据的工具

最后，用npm install --save-dev安装开发依赖项。开发依赖是指在开发环境中处理你的项目所需要的包，但在生产中运行代码库时不需要。

• typescript – 这是 TypeScript 语言的包，它包括用 TypeScript 编写代码并将其编译为 JavaScript 所需的一切。
• @types/node – TypeScript 依靠类型定义来理解你写的代码。这个包定义了 Node.js 运行环境的类型，例如process.env对象。

安装了这些软件包后，你现在应该有一个类似于以下的package.json：

{
  "name": "100doc-tutorial",
  "version": "1.0.0",
  "description": "",
  "main": "./prod/index.js",
  "scripts": {
    "build": "tsc",
    "start": "node -r dotenv/config ./prod/index.js"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "@discordjs/builders": "^0.11.0",
    "@discordjs/rest": "^0.2.0-canary.0",
    "discord.js": "^13.6.0",
    "dotenv": "^14.2.0",
    "mongoose": "^6.1.7"
  },
  "devDependencies": {
    "@types/node": "^17.0.10",
    "typescript": "^4.5.4"
  }
}

准备好 TypeScript

TypeScript 的编译器提供了许多不同的设置，以最大限度地提高你对生成的 JavaScript 的控制。

你通常可以通过项目根部的tsconfig.json文件修改编译器设置。你可以用npx tsc --init为这个文件生成默认的模板，如果你在其他项目中设置了一个模板，可以使用现有的模板，甚至可以从头开始写一个。

因为编译器的设置可以显著改变 TypeScript 的行为，所以在学习本教程时最好使用相同的设置。以下是你应该使用的设置：

{
  "compilerOptions": {
    "target": "ES6",
    "module": "CommonJS",
    "rootDir": "./src",
    "outDir": "./prod",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "resolveJsonModule": true
  }
}

这里最重要的设置是rootDir和outDir的设置。这些设置告诉编译器，你所有的代码都在src目录下，而生成的 JavaScript 应该在prod目录下。

如果你想测试你的设置，创建一个src目录并在里面放置一个index.ts文件。编写一些代码（如console.log语句）并在终端运行npm run build。你应该看到一个prod目录被创建，其中的index.js包含了你的编译代码。

其他设置说明

如果你使用git作为版本控制，你要避免将秘密的和不必要的代码推送到你的仓库。在你的项目根目录下创建一个.gitignore文件，并添加以下内容：

/node_modules/
/prod/
.env

.gitignore文件告诉git不要追踪符合你输入的模式的文件/文件夹。忽略 node_modules文件夹可以防止你的仓库变得臃肿（node_modules 实在太大了，有黑洞之称）。

推送已编译的 JavaScript 也是不必要的，因为你的项目通常在运行前就已经在生产中编译了。.env文件包含秘密值，如 API 密钥和令牌，所以它们不应该被提交到版本库。

创建 Discord 机器人

你的下一步是准备初始的机器人连接。如果你之前没有这样做，创建一个src目录和一个index.ts文件。

从一个匿名的立即执行的函数表达式（IIFE）开始，以允许顶层的await使用：

(async () => {

})();

在这个函数中，你将实例化你的 Discord 机器人。在文件的顶部，用import { Client } from "discord.js";导入Client类。Client类代表你的 Discord 机器人的会话。

在你的函数中，构建一个新的Client实例，并将其分配给BOT变量，const BOT = new Client();。现在，`BOT'变量将代表你的机器人。

为了将你的机器人连接到 Discord 网关并开始接收事件，你需要在你的机器人实例上使用.login()方法。.login()方法需要一个参数，即你之前创建的机器人应用程序的令牌（token）。

discord.js中的许多方法是异步的，所以你需要在这里使用await。在你的IIFE中加入await BOT.login(process.env.BOT_TOKEN);这一行。

你的 index.ts 文件现在应该看起来像这样：

import { Client } from "discord.js";

(async () => {
  const BOT = new Client();

  await BOT.login(process.env.BOT_TOKEN);
})();

如果你尝试运行npm run build，你会看到一个错误：An argument for 'options' was not provided.。

在 discord.js 13 中，当你实例化你的机器人时，你需要指定 Gateway Intents。Gateway Intents 告诉 Discord 你的机器人应该接收哪些事件。

在你的src文件夹中，创建一个config文件夹 - 然后在config中，创建一个IntentOptions.ts文件。

在这个新文件中，添加 “export const IntentOptions = ["GUILDS"]”一行。这将告诉 Discord 你的机器人应该接收公会事件（Guild events）。

然后，在你的index.ts文件中，给你的new Client()调用添加一个参数：new Client({intents: IntentOptions})。你需要在文件的顶部用 import { IntentOptions } from "./config/IntentOptions;，导入它。

看来你仍然有一个错误：Type 'string' is not assignable to type 'number | `${bigint}` | IntentsString | Readonly<BitField<IntentsString, number>> | RecursiveReadonlyArray<number | `${bigint}` | IntentsString | Readonly<...>>'.

TypeScript 将你的IntentOptions数组推断为一个字符串，但Client构造函数期望的是更具体的类型。

回到你的config/IntentOptions.ts文件，添加另一个导入。import { IntentsString } from "discord.js"。然后用新的类型定义更新你的变量： export const IntentOptions: IntentsString[] = ["GUILDS"];。

现在npm run build应该成功了。如果你已经把你的新机器人（bot）添加到一个 Discord 服务器，运行npm start将显示你的机器人在该服务器中上线。然而，机器人还不会对任何事情做出反应，因为你还没有开始监听事件。

Discord 中的网关事件（Gateway Events）

网关事件是在 Discord 上发生动作时产生的，通常以 JSON payloads（有效载荷）的形式发送到客户端（包括你的机器人）。你可以用.on()方法监听这些事件，允许你为你的机器人编写逻辑，以便在特定事件发生时执行。

第一个要监听的事件是 “ready” 事件。当你的机器人连接到网关并准备处理事件时，这个事件就会发生。在你的.login()调用上面，添加BOT.on("ready", () => console.log("Connected to Discord!");。

为了使你的修改生效，再次使用npm run build来编译新的代码。现在，如果你尝试npm run start，你应该看到 “Connected to Discord!” 打印在你的终端。

连接到数据库

你将使用mongoose包来连接到 MongoDB 实例。如果你愿意，你可以在本地运行 MongoDB，或者你可以使用 MongoDB Atlas 免费层来实现基于云的解决方案。

如果你没有 MongoDB Atlas 账户，freeCodeCamp 有一个关于设置一个账户的好教程。

获得你的数据库的连接字符串，并将其添加到你的.env文件中，作为MONGO_URI=""，连接字符串要在引号之间。对于数据库的名称，使用oneHundredDays。

创建一个名为 “database” 的目录来存放包含数据库逻辑的文件。在这个目录中，创建一个名为connectDatabase.ts的文件。你将在这里编写启动数据库连接的逻辑。

从一个导出的函数声明开始：

export const connectDatabase = async () => {

}

注意，你需要在这里使用 async 关键字，因为数据库连接方法是异步的。

mongoose 提供了一个 connect 方法用于连接数据库。在你的文件顶部用 import { connect } from "mongoose"; 导入它。

然后用 await connect(process.env.MONGO_URI); 在你的函数中使用该方法。在这之后添加一个 console.log 语句，这样你就可以确定你的机器人已经连接到了数据库。

你的 connectDatabase.ts 文件现在看起来应该是这样的：

import { connect } from "mongoose";

export const connectDatabase = async () => {
    await connect(process.env.MONGO_URI);
    console.log("Database Connected!")
}

现在，在你的 index.ts 文件中，用 import { connectDatabase } from "./database/connectDatabase" 导入这个函数，并在你的 IIFE 中添加 await connectDatabase()，就在 .login() 方法之前。继续并再次运行 npm run build。

哦，不——一个错误！

环境变量验证

环境变量的问题是，它们都可能是 undefined。如果你在环境变量名称中打错了字，或者把名称和其他名称混在一起，就会经常发生这种情况（我在写这个教程时犯了一个错误，在一些地方用TOKEN而不是BOT_TOKEN）。

TypeScript 警告你，connect 方法需要一个字符串，而 undefined 值会破坏事情。你可以解决这个问题，但首先你要写一个函数来处理验证你的环境变量。

在你的 src 目录下，创建一个 utils 目录，包含你的实用函数。在那里添加一个 validateEnv.ts 文件。

在该文件中创建一个名为 validateEnv 的函数。这个函数将是同步的，不需要 async 关键字。在这个函数中，添加条件来检查你的两个环境变量。如果缺少任何一个，返回 false。否则，返回 true。

你的代码可能看起来像这样：

export const validateEnv = () => {
  if (!process.env.BOT_TOKEN) {
    console.warn("Missing Discord bot token.");
    return false;
  }

  if (!process.env.MONGO_URI) {
    console.warn("Missing MongoDB connection.");
    return false;
  }
  return true;
};

回到你的 index.ts 文件，用 import { validateEnv } from "./utils/validateEnv" 导入这个验证函数。然后在你的 IIFE 的开头，使用一个 if 语句，如果函数返回 false，就提前返回。你的 index.ts 应该看起来像：

import { Client } from "discord.js";
import { connectDatabase } from "./database/connectDatabase";
import { validateEnv } from "./utils/validateEnv";

(async () => {
  if (!validateEnv()) return;

  const BOT = new Client();

  BOT.on("ready", () => console.log("Connected to Discord!"));

  await connectDatabase();

  await BOT.login(process.env.BOT_TOKEN);
})();

如果你再次尝试 npm run build，你会看到和之前一样的错误信息。这是因为虽然我们知道环境变量存在，但 TypeScript 仍然无法推断出它。验证函数被设置为在环境变量丢失时退出进程，所以我们要告诉 TypeScript 它肯定是一个字符串。

回到你的 connectDatabase.ts 文件中，在 connect 函数中使用 process.env.MONGO_URI as string来强迫类型为 string。错误应该消失了，你现在可以运行 npm run build 和 npm start。

你应该看到你为 Discord 和 MongoDB 连接写的信息在终端打印出来。

交互事件

虽然你的机器人取得了很大的进展，但它仍然没有做任何事情。为了接收命令，你将需要创建另一个事件监听器。

Discord推出了 slash 命令，具有一个新的用户界面和一个新的网关事件。当有人用你的机器人使用 slash命令时，interactionCreate 事件被触发。这是你想要监听的事件。因为逻辑比 ready事件更复杂，你将需要创建一个单独的文件。

在你的 src 目录下，创建一个 events 目录，并在其中创建 onInteraction.ts 文件。首先定义一个导出的函数 onInteraction。这应该是一个异步函数，有一个名为 interaction 的单一参数。

export const onInteraction = async (interaction) => {

};

为了给你的参数提供一个类型定义，从discord.js导入Interaction类型。

import { Interaction } from "discord.js";

export const onInteraction = async (interaction: Interaction) => {

};

interaction事件实际上是在任何命令交互上触发的，这包括像按钮点击和选择菜单，以及我们想要的 slash 命令。

因为你将只为这个机器人编写 slash 命令，你可以过滤掉任何其他的交互类型，帮助 TypeScript 理解你正在处理的数据。

在你的新函数中，添加一个条件来检查interaction.isCommand()。稍后你将在这个块中编写逻辑。

import { Interaction } from "discord.js";

export const onInteraction = async (interaction: Interaction) => {
  if (interaction.isCommand()) {
  }
};

现在，在你的 index.ts 文件中，你可以加载另一个监听器。在你的 .on("ready") 监听器旁边，添加一个BOT.on("interactionCreate") 监听器。对于这个事件，回调需要一个 interaction 参数，你可以把它传递给你新的 onInteraction 函数。

  BOT.on(
    "interactionCreate",
    async (interaction) => await onInteraction(interaction)
  );

记住，你将需要导入你的 onInteraction 函数。

很好！你可以运行 npm run build 来确认 TypeScript 没有抛出任何错误，但如果没有实际的命令来使用，你还不能完全测试这段代码。

准备命令

我维护了一些 Discord 机器人，我发现有一件事有助于保持代码的可维护性和可读性，那就是使组件模块化。

定义一个接口

你将首先需要为你的命令定义一个共同的结构。在src中创建一个interfaces文件夹，然后在interfaces中创建一个名为Command.ts的文件。

现在你要创建一个接口。在 TypeScript 中，接口经常被用来定义对象的结构，也是众多用于声明变量类型的工具之一。

在你的Command.ts文件中，创建一个名为Command的导出接口：

export interface Command {

}

你的接口将有两个属性——data，它将保存要发送给 Discord 的命令数据，以及 run，它将保存回调函数和命令逻辑。

对于 data 属性，从 @discordjs/builders 导入 SlashCommandBuilder 和SlashCommandSubcommandsOnlyBuilder。将 data 属性定义为这两种类型中的一种。

对于 run 属性，从 discord.js 导入 CommandInteraction 类型。将 run 定义为一个函数，接收一个 CommandInteraction 类型的参数并返回一个 void Promise。

import {
  SlashCommandBuilder,
  SlashCommandSubcommandsOnlyBuilder,
} from "@discordjs/builders";
import { CommandInteraction } from "discord.js";

export interface CommandInt {
  data: SlashCommandBuilder | SlashCommandSubcommandsOnlyBuilder;
  run: (interaction: CommandInteraction) => Promise<void>;
}

创建一个命令列表

接下来你需要一个地方来存储你所有的命令。在 src 目录下创建一个名为 commands 的文件夹，并添加一个名为 _CommandList.ts 的文件。这里的下划线将使这个文件保持在列表的顶部。

_CommandList.ts 文件将需要两行。首先，导入你的 Command 接口，然后声明一个 CommandList 数组。这个数组现在是空的，但是要给它一个 Command[] 的类型，这样 TypeScript 就知道它最终会容纳你的命令对象。这个文件应该是这样的：

import { Command } from "../interfaces/Command";

export const CommandList: Command[] = [];

这个文件的目的是创建一个你的机器人的命令数组，你将在交互事件监听器中进行迭代。可以使之自动化，但对于较小的机器人来说，它们往往是不必要的复杂。

检查命令的执行情况

在你的 onInteraction.ts 文件中，你应该开始研究寻找和运行命令的逻辑。

在你的 interaction.isCommand() 条件块中，通过 CommandList 数组（记得要导入它！）进行 for...of 循环。

for (const Command of CommandList) {

}

从 Discord 收到的交互 payload （有效载荷）包括一个 commandName 属性，你可以用它来查找用户选择的命令。要检查这一点，将 interaction.commandName 与 Command.data.name 属性进行比较。

if (interaction.commandName === Command.data.name) {

}

现在，如果你已经找到了用户选择的命令，你需要运行该命令的逻辑。这是通过 Command.run(interaction) 的调用来实现的--将交互的 payload（有效载荷）传递给命令。

你的最终文件应该是这样的：

import { Interaction } from "discord.js";
import { CommandList } from "../commands/_CommandList";

export const onInteraction = async (interaction: Interaction) => {
  if (interaction.isCommand()) {
    for (const Command of CommandList) {
      if (interaction.commandName === Command.data.name) {
        await Command.run(interaction);
        break;
      }
    }
  }
};

注意，在我们运行命令后，我们 break 循环，以避免不必要的搜索。

数据库模型

在你准备开始编写命令之前，还有一个步骤。这个机器人将跟踪你的社区成员的 100 天编程挑战的进展。而你需要将该进度存储在数据库中。

mongoose 可以帮助你结构化你的 MongoDB 记录，以防止你将畸形或不完整的数据传入数据库。

首先，在你的 database 目录下创建一个 models 文件夹。在这个 models 文件夹中，创建一个 CamperModel.ts 文件。这将是你的用户对象的结构。

你首先需要从 mongoose 库中导入必要的值。在文件的顶部添加 import { Document, model, Schema } from "mongoose";。

因为你正在使用 TypeScript，你需要为你的数据库对象创建一个类型定义。创建另一个接口，就像你为你的命令所做的那样，名为CamperInt。

export interface CamperInt extends Document {

}

extends 关键字告诉TypeScript我们要在 Document 类型的基础上添加属性。

你的数据库模型将有四个属性。把这些添加到你的接口中：

• discordId: string; - Discord 中的每个用户对象都有一个唯一的标识符，称为Snowflake，用于区分他们与其他用户。与用户名或判别符（用户名后的四位数）不同，id值不能被改变。这使得它成为将你的存储数据与 Discord 用户联系起来的理想值。
• round: number; - 这将代表用户在挑战中所处的“回合”。当某人完成了 100 天的挑战，他们可以选择再次进行挑战。当他们这样做的时候，他们通常称其为“第二轮”。
• day: number; - 这代表用户在挑战中的日期。
• timestamp: number; - 你将使用这个值来跟踪用户最后一次提交 100 天编程挑战帖子的时间。

很好！现在你需要为你的数据库条目定义模式。mongoose 使用一个 Schema 对象来定义进入数据库集合的文件的形状。Schema 导入有一个构造函数，你将把它分配给一个变量。

export const Camper = new Schema();

这个构造函数接受一个对象作为其参数，这个对象定义了数据库的键和类型。继续，传入一个与你的界面相似的对象。

export const Camper = new Schema({
    discordId: String,
    round: Number,
    day: Number,
    timestamp: Number,
})

注意，我们使用的是String而不是string。String是指JavaScript的原始类型，而string是TypeScript的类型定义。

接下来你需要创建model。在 mongoose 中，model 对象的作用是在MongoDB数据库中创建、读取和更新你的文档。在你文件的底部添加 export default model();。

model 函数需要几个参数。第一个是一个字符串，是你数据库中的文档（documents）的名称。对于这个集合（collection），使用 "camper"。第二个参数是用于数据的模式（schema）--使用你的 Camper 模式（schema）。

默认情况下，mongoose 将使用你的 model 名称的复数版本作为集合。在我们的例子中，这将是 "campers"。如果你想改变它，你可以传入第三个参数 {集合: "name" } 来设置集合为 name。

如果你使用的是 JavaScript，这就足以让你的数据库模型设置好。然而，由于你使用的是TypeScript，你应该利用类型安全的优势。model() 默认返回一个 Document 类型的 any。

为了解决这个问题，你可以在 model 函数中传递一个泛型。从某种意义上说，泛型可以作为类型定义的变量。你需要为你的 model 设置泛型以使用你的接口。通过将 model 改为 model<CamperInt>，来添加泛型。

这里只有一个步骤了。你的 CamperInt 接口只定义了你在 MongoDB 文档中设置的属性，但并不包括标准属性。

将你的 export interface CamperInt 改为 export interface CamperInt extends Document。这告诉 TypeScript，你的类型定义是现有 Document 类型定义的扩展——你基本上是在向该结构添加属性。

你的最终文件应该看起来像这样：

import { Document, model, Schema } from "mongoose";

export interface CamperInt {
  discordId: string;
  round: number;
  day: number;
  timestamp: number;
}

export const Camper = new Schema({
  discordId: String,
  round: Number,
  day: Number,
  timestamp: Number,
});

export default model<CamperInt>("camper", Camper);

作为一个安全检查，再次使用npm run build。你不应该在终端看到任何错误。

编写机器人命令

你终于准备好开始编写一些命令了。由于这是一个 100 天代码机器人，你应该从创建 100 天代码更新的命令开始。

100 Command

在你的 commands 文件夹中，创建一个 oneHundred.ts 文件。这将保存你的100天代码命令。用 import { Command } from ".../interfaces/Command;导入你的命令接口。

现在声明一个导出的变量oneHundred，并赋予它Command类型：

import { Command } from "../interfaces/Command";

export const oneHundred: Command = {

};

首先，创建 data 属性。你将使用 @discordjs/builders 包来创建一个 slash 命令。

首先从 @discordjs/builders 包中导入 SlashCommandBuilder()。然后，用 new SlashCommandBuilder() 在data 属性中构建一个新实例。你将在这里使用一些方法来传递你想要的信息到构建器中。

.setName() 方法允许你设置斜线命令的名称。设置名称为 "100"。setDescription() 选项允许你在 Discord 的用户界面中显示命令的描述。将描述设为 "Check in for the 100 Days of Code challenge"。

Slash 命令也可以接受 option 值。这些是用来接受用户的参数的，有各种类型。对于这个命令，你需要一个字符串选项，使用 addStringOption() 方法。选项方法需要一个回调函数，有一个 option 参数。

然后你可以在 option 参数上使用连锁方法来配置参数的信息。使用 .setName() 方法给选项取名为"message"，使用.setDescription()方法给它取名为"The message to go in your 100 Days of Code update"。最后，使用.setRequired()方法将该选项设置为必填。

以下是你现在应该有的东西：

import { SlashCommandBuilder } from "@discordjs/builders";
import { Command } from "../interfaces/Command";

export const oneHundred: Command = {
  data: new SlashCommandBuilder()
    .setName("100")
    .setDescription("Check in for the 100 Days of Code challenge.")
    .addStringOption((option) =>
      option
        .setName("message")
        .setDescription("The message to go in your 100 Days of Code update.")
        .setRequired(true)
    ),
};

如果你在 IDE 中编码启用了智能提示，你可能已经注意到，这将在 data 属性上抛出一个类型错误（type error）。这是因为 SlashCommandBuilder 实际上返回了一个 Omit 类型！ Omit 类型是用来告诉 TypeScript，该类型和另一个类型几乎相同，但删除了特定属性。

前往你的 interfaces/Command.ts 文件，更新类型。用 Omit<SlashCommandBuilder, "addSubcommandGroup" | "addSubcommand"> 替换 SlashCommandBuilder 类型。这将告诉TypeScript，data 应该是一个SlashCommandBuilder，但没有那两个特定的属性。

import {
  SlashCommandBuilder,
  SlashCommandSubcommandsOnlyBuilder,
} from "@discordjs/builders";
import { CommandInteraction } from "discord.js";

export interface Command {
  data:
    | Omit<SlashCommandBuilder, "addSubcommandGroup" | "addSubcommand">
    | SlashCommandSubcommandsOnlyBuilder;
  run: (interaction: CommandInteraction) => Promise<void>;
}

很好！现在你的类型错误已经解决了，回到你的 oneHundred.ts 命令文件--是时候编写命令逻辑了。

你的机器人响应命令的所有逻辑将被放在 run 属性中。就像你在界面中做的那样，首先创建一个接受 interaction 参数的async函数。然后，让你的函数的第一行是 await interaction.deferReply();。

Discord 期望机器人在三秒内对一个命令做出反应。因为这个命令可能需要更长的时间来处理，使用 .deferReply() 方法会发送一个确认响应，让你有整整 15 分钟的时间来发送实际响应。

接下来，你需要从该命令中提取一些数据。首先，用 const { user } = interaction;将 user 对象从交互的有效载荷中解构出来。user 对象代表调用该命令的 Discord 用户。

然后用 const text = interaction.options.getString("message", true); 获得你发送的 message 选项。通过这一行，你正在访问交互的 options 属性。.getString() 方法专门抓取一个字符串选项（记得你在 data 中创建了这个选项），"message"是这个选项的name。true参数表示这是一个必选项，所以TypeScript不会认为它是空的。

你的文件应该看起来像这样：

import { SlashCommandBuilder } from "@discordjs/builders";
import { Command } from "../interfaces/Command";

export const oneHundred: Command = {
  data: new SlashCommandBuilder()
    .setName("100")
    .setDescription("Check in for the 100 Days of Code challenge.")
    .addStringOption((option) =>
      option
        .setName("message")
        .setDescription("The message to go in your 100 Days of Code update.")
        .setRequired(true)
    ),
  run: async (interaction) => {
    await interaction.deferReply();
    const { user } = interaction;
    const text = interaction.options.getString("message", true);
  },
};

这个命令的下一步将是从你的数据库中获取数据。因为你的许多命令都需要这样做，你应该为它创建一个模块。

处理数据库逻辑

创建一个 src/modules 目录，并在其中添加一个 getCamperData.ts 文件。创建一个导出的异步函数getCamperData，并给它一个名为 id 的字符串参数。然后，在该函数中，你可以查询数据库。

从 database 目录中导入你的 CamperModel，并使用 findOne() 方法来查询营员的 id：const camperData = await CamperModel.findOne({ discordId: id });。

import CamperModel from "../database/models/CamperModel";

export const getCamperData = async (id: string) => {
  const camperData = await CamperModel.findOne({ id });
};

我们在这里还有一个步骤。如果 camper 以前没有使用过机器人，他们就不会有现有的数据库记录。findOne()在这种情况下会返回 null,所以你可以添加一个回退值。

import CamperModel from "../database/models/CamperModel";

export const getCamperData = async (id: string) => {
  const camperData =
    (await CamperModel.findOne({ discordId: id })) ||
    (await CamperModel.create({
      discordId: id,
      round: 1,
      day: 0,
      date: Date.now(),
    }));
};

在这里，我们在第一轮第 0 天开始一个新的 camper，如果他们使用 100 command，这允许我们更新他们的状态。

最后，你需要 返回（return）你的数据。在函数的末尾添加 return camperData。为了额外的类型安全，将你的函数的返回类型定义为 Promise<CamperData>。

import CamperModel, { CamperInt } from "../database/models/CamperModel";

export const getCamperData = async (id: string): Promise<CamperInt> => {
  const camperData =
    (await CamperModel.findOne({ discordId: id })) ||
    (await CamperModel.create({
      discordId: id,
      round: 1,
      day: 0,
      date: Date.now(),
    }));
  return camperData;
};

你现在有了从数据库中获取 camper 数据的方法，但你也需要一种方法来更新它。在你的/src/modules目录下创建另一个文件，叫做 updateCamperData.ts。这将处理增加 camper 的进度的逻辑。

从一个导出的异步函数开始，称为 updateCamperData。它应该接受一个 Camper 参数，这将是你从 MongoDB 获取的数据。

import { CamperInt } from "../database/models/CamperModel";

export const updateCamperData = async (Camper: CamperInt) => {
    
};

你唯一要更新数据的时候是在 /100 命令中——在那里你要增加营员的日计数，检查他们是否开始了新的一轮（round），并更新时间戳。

首先，用 Camper.day++; 来增加日计数。根据 100 天编程挑战的工作方式，如果 camper 已经过了第 100 天，那么他们就开始了新的“一轮（round）”。你需要一个条件来检查 Camper.day > 100，如果是的话，就把日子重置为 1，并增加一轮（round）。

在这个条件之后，用 Camper.timestamp = Date.now(); 更新时间戳，用 await Camper.save(); 保存数据。最后，返回修改后的数据对象，这样你就可以在命令中使用它。

你的最终文件应该是这样的：

import { CamperInt } from "../database/models/CamperModel";

export const updateCamperData = async (Camper: CamperInt) => {
  Camper.day++;
  if (Camper.day > 100) {
    Camper.day = 1;
    Camper.round++;
  }
  Camper.timestamp = Date.now();
  await Camper.save();
  return Camper;
};

100 Command Continued

现在你的数据库逻辑已经准备好了，返回到你的oneHundred.ts文件。作为提醒，该文件应该看起来像这样：

import { SlashCommandBuilder } from "@discordjs/builders";
import { Command } from "../interfaces/Command";

export const oneHundred: Command = {
  data: new SlashCommandBuilder()
    .setName("100")
    .setDescription("Check in for the 100 Days of Code challenge.")
    .addStringOption((option) =>
      option
        .setName("message")
        .setDescription("The message to go in your 100 Days of Code update.")
        .setRequired(true)
    ),
  run: async (interaction) => {
    await interaction.deferReply();
    const { user } = interaction;
    const text = interaction.options.getString("message", true);
  },
};

在文件的顶部导入你的两个新模块（modules）。然后，在你从交互对象中提取数值的逻辑之后，用const targetCamper = await getCamperData(user.id);从数据库中获取 camper 的数据。用 const updatedCamper = await updateCamperData(targetCamper); 来更新数据。

import { SlashCommandBuilder } from "@discordjs/builders";
import { Command } from "../interfaces/Command";
import { getCamperData } from "../modules/getCamperData";
import { updateCamperData } from "../modules/updateCamperData";

export const oneHundred: Command = {
  data: new SlashCommandBuilder()
    .setName("100")
    .setDescription("Check in for the 100 Days of Code challenge.")
    .addStringOption((option) =>
      option
        .setName("message")
        .setDescription("The message to go in your 100 Days of Code update.")
        .setRequired(true)
    ),
  run: async (interaction) => {
    await interaction.deferReply();
    const { user } = interaction;
    const text = interaction.options.getString("message", true);

    const targetCamper = await getCamperData(user.id);
    const updatedCamper = await updateCamperData(targetCamper);
  },
};

现在你需要构建响应，以便在 camper 使用该命令时将其送回。

为此，你将使用Discord的消息嵌入功能。首先从 discord.js 导入 MessageEmbed 构造函数，然后用 const oneHundredEmbed = new MessageEmbed(); 创建一个新的嵌入。MessageEmbed 类有几个方法可以用来创建嵌入的内容。

使用 .setTitle() 方法来设置嵌入的标题为"100 Days of Code"。

使用.setDescription() 方法将嵌入的描述设置为 camper 在命令中提供的信息（记得你之前将其提取到text变量）。嵌入的作者可以被设置，并将显示在嵌入的顶部。

使用 .setAuthor() 方法传递一个对象，其 name 属性设置为 user.tag（将显示 camper 的用户名和判别符，如nhcarrigan#0001），iconURL属性设置为user.displayAvatarUrl()（将 camper 的头像附加到嵌入文件上）。

嵌入（Embeds）也接受字段，它是较小的文本块，有自己的标题和描述。.addField() 方法需要两个或三个参数，第一个是字段的标题，第二个是字段的描述，第三个是可选的布尔值，将字段设置为内联（inline）。

使用.addField()方法来添加两个字段。第一个字段的标题应该设置为 "Round"，描述设置为 updatedCamper.round.toString()。第二个字段的标题应该设置为 "Day"，描述设置为 updatedCamper.day.toString()。这两个字段都应该是内联的（inline）。

对于你嵌入的最后一部分，使用 .setFooter() 方法来添加小的页脚文本。传递一个对象，其 text 属性设置为"Day completed:" + new Date(upedCamer.timestamp).toLocaleDateString()以显示 camper 报告他们进展的时间。

最后，你需要把这个新嵌入的内容发回给 camper。因为你已经用interaction.deferReply() 调用发送了一个响应，你不能再发送一个响应。相反，你需要编辑你发送的那个。

使用await interaction.editReply()来编辑响应。.editReply()方法接收一个具有各种属性的对象,在这种情况下，你正在发送一个嵌入（embed）。传递一个对象，其 embeds 属性设置为[oneHundredEmbed]。

注意，这是一个包含你的嵌入的数组。Discord 消息最多可以包含 10 个嵌入物（embeds），API 希望有一个嵌入对象（embed objects）的数组来匹配。

你的最终命令文件应该是这样的：

import { SlashCommandBuilder } from "@discordjs/builders";
import { MessageEmbed } from "discord.js";
import { Command } from "../interfaces/Command";
import { getCamperData } from "../modules/getCamperData";
import { updateCamperData } from "../modules/updateCamperData";

export const oneHundred: Command = {
  data: new SlashCommandBuilder()
    .setName("100")
    .setDescription("Check in for the 100 Days of Code challenge.")
    .addStringOption((option) =>
      option
        .setName("message")
        .setDescription("The message to go in your 100 Days of Code update.")
        .setRequired(true)
    ),
  run: async (interaction) => {
    await interaction.deferReply();
    const { user } = interaction;
    const text = interaction.options.getString("message", true);

    const targetCamper = await getCamperData(user.id);
    const updatedCamper = await updateCamperData(targetCamper);

    const oneHundredEmbed = new MessageEmbed();
    oneHundredEmbed.setTitle("100 Days of Code");
    oneHundredEmbed.setDescription(text);
    oneHundredEmbed.setAuthor({
      name: user.tag,
      iconURL: user.displayAvatarURL(),
    });
    oneHundredEmbed.addField("Round", updatedCamper.round.toString(), true);
    oneHundredEmbed.addField("Day", updatedCamper.day.toString(), true);
    oneHundredEmbed.setFooter({
      text:
        "Day completed: " +
        new Date(updatedCamper.timestamp).toLocaleDateString(),
    });

    await interaction.editReply({ embeds: [oneHundredEmbed] });
  },
};

注册命令

如果你运行npm run build和npm start，一切都会启动——但你没有办法实际使用你的新命令。这是因为 Discord 要求命令被注册，以便它们在应用程序的用户界面上可用。要做到这一点，我们需要采取几个步骤。

首先，前往你的_CommandList.ts文件，导入你的oneHundred命令。把它添加到你的CommandList数组中，这样它就可以在其他地方使用。

import { Command } from "../interfaces/Command";
import { oneHundred } from "./oneHundred";

export const CommandList: Command[] = [oneHundred];

现在是时候添加逻辑来发送命令信息给 Discord 了。在你的src/events目录下，添加一个onReady.ts文件。我们将在"ready"事件中使用它。

创建一个名为onReady的出口异步函数，并给它一个名为BOT的参数。从 discord.js 导入Client类型，并将BOT类型定义设为Client。

import { Client } from "discord.js";

export const onReady = async (BOT: Client) => {};

现在从@discordjs/rest导入REST模块。这将允许你实例化一个 API 客户端，你将用它来发送命令。用const rest = new REST();构建一个新的实例。

你需要对你的 REST 客户端进行一些配置。首先，向REST()构造函数传递一个对象，并将version属性设置为"9"。这告诉客户端使用 Discord 的 API 版本 9，这是目前最新的版本。

然后，在构造函数上链接一个.setToken()调用，将API token（口令）设置为process.env.BOT_TOKEN, 你必须将其强制为一个字符串。

import { REST } from "@discordjs/rest";
import { Client } from "discord.js";

export const onReady = async (BOT: Client) => {
  const rest = new REST({ version: "9" }).setToken(
    process.env.BOT_TOKEN as string
  );
};

API 希望命令数据以特定的 JSON 格式发送，但值得庆幸的是，我们使用的 slash 命令生成器有一个方法专门用于此。导入你的CommandList，然后创建一个新的数组并映射你的命令数据。

const commandData = CommandList.map((command) => command.data.toJSON());

在你向 Discord 发送命令之前，有必要注意有两种类型的命令。全局命令Global Commands 在你的机器人被使用的所有地方都可用，但需要一个小时左右的时间来更新。Guild Commands 只在单个服务器中可用，但会立即更新。因为这个机器人被设计为在单个服务器中运行，所以我们要使用 Guild Commands。

你需要获得你使用该机器人的服务器的 ID。要做到这一点，确保你在你的 Discord 应用程序中启用了开发者模式，然后右击你的服务器图标并选择 “Copy ID”。在你的 .env 文件中，添加一个 GUILD_ID 变量，并将你复制的 ID 分配给它。它应该看起来像 GUILD_ID="778130114772598785"。

回到你的 onReady.ts 文件中，用 await rest.put() 开始你的 API 调用。发送一个 PUT 请求将更新任何现有的命令，而 POST 将试图创建新的命令，如果命令共享一个名字就会出错。从discord-api-types/v9导入Routes，并在rest.put() 调用中传递 Routes.applicationGuildCommands() 调用。这将被用来构建 API 端点以发送命令。

调用 applicationGuildCommands() 时，将接受两个参数。

首先是应用程序的 ID，以便将这些命令与之联系起来。你可以从 BOT.user.id 的值中得到它，但 user 有可能是未定义的，所以你需要选择性地把它连起来。使用 BOT.user?.id || "missing id" 来添加一个会出错的后备值——这将允许我们知道机器人的 ID 是否丢失。

第二个参数是服务器 ID，你把它设置为process.env.GUILD_ID（记得要强制使用这个类型！）。

.put()调用也需要第二个参数，这是你要发送的数据。以{ body: commandData }的形式传递，以符合预期格式。

最后，在文件末尾添加一个console.log("Discord ready!")，以表明你的机器人已经上线。

import { REST } from "@discordjs/rest";
import { Routes } from "discord-api-types/v9";
import { Client } from "discord.js";
import { CommandList } from "../commands/_CommandList";

export const onReady = async (BOT: Client) => {
  const rest = new REST({ version: "9" }).setToken(
    process.env.BOT_TOKEN as string
  );

  const commandData = CommandList.map((command) => command.data.toJSON());

  await rest.put(
    Routes.applicationGuildCommands(
      BOT.user?.id || "missing id",
      process.env.GUILD_ID as string
    ),
    { body: commandData }
  );

  console.log("Discord ready!");
};

切换到你的 index.ts 文件，找到你的 "ready" 事件监听器。用新的 onReady 函数替换 console.log调用--记得导入它，回调中异步调用。

import { Client } from "discord.js";
import { IntentOptions } from "./config/IntentOptions";
import { connectDatabase } from "./database/connectDatabase";
import { onInteraction } from "./events/onInteraction";
import { onReady } from "./events/onReady";
import { validateEnv } from "./utils/validateEnv";

(async () => {
  if (!validateEnv()) return;
  const BOT = new Client({ intents: IntentOptions });

  BOT.on("ready", async () => await onReady(BOT));

  BOT.on(
    "interactionCreate",
    async (interaction) => await onInteraction(interaction)
  );

  await connectDatabase();

  await BOT.login(process.env.BOT_TOKEN);
})();

现在运行npm run build和npm start，并在Discord中连接你的服务器。如果你输入/，你应该看到你的新/100命令显示出来。尝试使用该命令并检查响应。

祝贺你！你有了你的第一个成功的命令。有了你所创建的所有基础结构，添加其他的命令就会顺利得多。让我们现在就去做吧。

编辑命令

如果成员在他们的 /100 信息中出现了错误，会发生什么？因为机器人会发送回复，camper 无法编辑它（Discord 不允许你编辑你没有发送的信息）。你应该创建一个命令，允许 camper 这样做。

在你的 src/commands 目录下创建一个 edit.ts 文件。就像你对 /100 命令所做的那样，导入你的SlashCommandBuilder 和 Command 接口，并导出一个 edit 对象，其类型为 Command。

使用 SlashCommandBuilder 来准备 data 属性。给这个命令取名为 edit，描述为Edit a previous 100 days of code post，然后添加两个字符串选项。第一个字符串选项应该有一个名字 embed-id 和一个描述"ID of the message to edit"，第二个应该有一个名字message和一个描述 "The message to go in your 100 Days of Code update" 。这两个选项都应该是必需的。

你的代码应该是这样的：

import { SlashCommandBuilder } from "@discordjs/builders";
import { Command } from "../interfaces/Command";

export const edit: Command = {
    data: new SlashCommandBuilder()
    .setName("edit")
    .setDescription("Edit a previous 100 days of code post.")
    .addStringOption((option) =>
      option
        .setName("embed-id")
        .setDescription("ID of the message to edit.")
        .setRequired(true)
    )
    .addStringOption((option) =>
      option
        .setName("message")
        .setDescription("The message to go in your 100 Days of Code update.")
        .setRequired(true)
    ),
}

用一个异步函数和一个 interaction（交互）参数创建你的run属性。从交互中获得 channel 和 user，并抓住 embed-id和 message选项。不要忘记延迟响应！

    run: async (interaction) => {
        await interaction.deferReply();
        const { channel, user } = interaction;
        const targetId = interaction.options.getString("embed-id", true);
        const text = interaction.options.getString("message", true);
    }

channle属性是 nullable（例如，在通过 DM 发送互动的情况下），所以你要检查它是否存在。如果它不存在，则回应一个命令缺少参数的消息。

    if (!channel) {
      await interaction.editReply({
        content: "Missing channel parameter.",
      });
      return;
    }

现在你知道了这个 channel 的存在，你可以根据 camper 提供的ID来获取他们想要编辑的信息。使用channel.messages.fetch() 来做这件事，把 targetId 作为参数传入。

因为目标 message 有可能不存在，你需要在你的代码中考虑到这一点。添加一个条件来检查这一点，如果没有找到消息，则回应一个解释。

    const targetMessage = await channel.messages.fetch(targetId);

    if (!targetMessage) {
      await interaction.editReply({
        content:
          "That does not appear to be a valid message ID. Be sure that you are using this command in the same channel as the message.",
      });
      return;
    }

你需要检查的最后一件事是，camper 正在编辑的信息实际上属于他们。你可以用.embeds属性来访问嵌入（embed），和你发送的方式一样，该属性以嵌入对象（embed objects）数组的形式返回。

从数组中抓取第一个嵌入对象（embed objects），然后检查嵌入作者是否与用户的标签相符。如果不是，让他们知道他们不能编辑这个帖子。

    const targetEmbed = targetMessage.embeds[0];

    if (targetEmbed.author?.name !== user.tag) {
        await interaction.editReply({
            content: "This does not appear to be your 100 Days of Code post. You cannot edit it."
        })
    }

现在你已经确认一切都正确了，你可以在嵌入（embed）上使用 .setDescription() 来更新文本。然后，用新的嵌入（embed）来编辑消息，并对互动作出确认。

你的完整代码应该是这样的：

import { SlashCommandBuilder } from "@discordjs/builders";
import { Command } from "../interfaces/Command";

export const edit: Command = {
  data: new SlashCommandBuilder()
    .setName("edit")
    .setDescription("Edit a previous 100 days of code post.")
    .addStringOption((option) =>
      option
        .setName("embed-id")
        .setDescription("ID of the message to edit.")
        .setRequired(true)
    )
    .addStringOption((option) =>
      option
        .setName("message")
        .setDescription("The message to go in your 100 Days of Code update.")
        .setRequired(true)
    ),
  run: async (interaction) => {
    await interaction.deferReply();
    const { channel, user } = interaction;
    const targetId = interaction.options.getString("embed-id", true);
    const text = interaction.options.getString("message", true);

    if (!channel) {
      await interaction.editReply({
        content: "Missing channel parameter.",
      });
      return;
    }

    const targetMessage = await channel.messages.fetch(targetId);

    if (!targetMessage) {
      await interaction.editReply({
        content:
          "That does not appear to be a valid message ID. Be sure that you are using this command in the same channel as the message.",
      });
      return;
    }

    const targetEmbed = targetMessage.embeds[0];

    if (targetEmbed.author?.name !== user.tag) {
      await interaction.editReply({
        content:
          "This does not appear to be your 100 Days of Code post. You cannot edit it.",
      });
    }

    targetEmbed.setDescription(text);
    await targetMessage.edit({ embeds: [targetEmbed] });
    await interaction.editReply({ content: "Updated!" });
  },
};

将新的 edit 命令添加到你的 CommandList 数组中，然后创建并运行你的机器人，你应该看到新的命令。尝试编辑你之前发送的嵌入文件（embed）。

查看命令

Campers 应该有办法查看他们当前的进度，因此我们需要创建一个命令来执行此操作。到目前为止，你应该对命令结构感到满意。我们鼓励你遵循这些说明，尝试编写代码。

在你的命令目录下创建一个view.ts文件，并设置好你的命令变量。在data属性中创建一个命令，其名称为view，描述为 Shows your latest 100 days of code check in。这个命令不需要任何选项。

在 run 属性中设置你的异步函数，并推迟交互响应。从交互中提取 user 对象。使用你的 getCamperData 模块从数据库中获取 camper 的数据。然后，检查数据的 day 属性是否有一个非零值。如果没有，让 camper 知道他们还没有开始100天的编程挑战，可以用 /100 命令来做。

创建一个嵌入，标题设置为 My 100DoC Progress。将描述设置为Here is my 100 Days of Code progress. I last reported an update on:, 并添加 camper 的时间戳。添加一个 Round 和 Day 字段，并设置嵌入的作者。然后在交互响应中发送嵌入的内容。

记得把你的新命令添加到 CommandList 中，然后尝试创建和启动你的机器人。你应该看到这个命令是可用的，并且能够从它那里得到一个响应。

如果你没有得到回应，以下是你的代码应该是这样的：

import { SlashCommandBuilder } from "@discordjs/builders";
import { MessageEmbed } from "discord.js";
import { Command } from "../interfaces/Command";
import { getCamperData } from "../modules/getCamperData";

export const view: Command = {
  data: new SlashCommandBuilder()
    .setName("view")
    .setDescription("Shows your latest 100 Days of Code check in."),
  run: async (interaction) => {
    await interaction.deferReply();
    const { user } = interaction;
    const targetCamper = await getCamperData(user.id);

    if (!targetCamper.day) {
      await interaction.editReply({
        content:
          "It looks like you have not started the 100 Days of Code challenge yet. Use `/100` and add your message to report your first day!",
      });
      return;
    }

    const camperEmbed = new MessageEmbed();
    camperEmbed.setTitle("My 100DoC Progress");
    camperEmbed.setDescription(
      `Here is my 100 Days of Code progress. I last reported an update on ${new Date(
        targetCamper.timestamp
      ).toLocaleDateString()}.`
    );
    camperEmbed.addField("Round", targetCamper.round.toString(), true);
    camperEmbed.addField("Day", targetCamper.day.toString(), true);
    camperEmbed.setAuthor({
      name: user.tag,
      iconURL: user.displayAvatarURL(),
    });

    await interaction.editReply({ embeds: [camperEmbed] });
  },
};

帮助命令

你需要创建的最后一件事是一个帮助命令，它将向camper 解释如何与机器人互动。

在 command 目录下创建你的 help.ts 文件，并创建你的 data 属性。给该命令起名为 help，并说明Provides information on using this bot（提供关于使用该机器人的信息）。

用 async 函数设置你的run属性，并记住推迟回复的时间。创建一个嵌入，并使用描述和字段来提供你想与 camper 分享的信息。在交互响应中发送嵌入的信息。

将你的新帮助命令加载到 CommandList 中，并创建启动你的机器人来测试它。你应该看到一个带有你创建的嵌入的响应。

你的嵌入可能看起来不同，这取决于你选择分享什么信息。以下是我们用于上述嵌入的代码：

import { SlashCommandBuilder } from "@discordjs/builders";
import { MessageEmbed } from "discord.js";
import { Command } from "../interfaces/Command";

export const help: Command = {
  data: new SlashCommandBuilder()
    .setName("help")
    .setDescription("Provides information on using this bot."),
  run: async (interaction) => {
    await interaction.deferReply();
    const helpEmbed = new MessageEmbed();
    helpEmbed.setTitle("100 Days of Code Bot!");
    helpEmbed.setDescription(
      "This discord bot is designed to help you track and share your 100 Days of Code progress."
    );
    helpEmbed.addField(
      "Create today's update",
      "Use the `/100` command to create your update for today. The `message` will be displayed in your embed."
    );
    helpEmbed.addField(
      "Edit today's update",
      "Do you see a typo in your embed? Right click it and copy the ID (you may need developer mode on for this), and use the `/edit` command to update that embed with a new message."
    );
    helpEmbed.addField(
      "Show your progress",
      "To see your current progress in the challenge, and the day you last checked in, use `/view`."
    );
    helpEmbed.setFooter({ text: `Version ${process.env.npm_package_version}` });
    await interaction.editReply({ embeds: [helpEmbed] });
    return;
  },
};

注意：我们应该使用 npm_package_version 来显示机器人的当前版本。

结语

恭喜！你已成功为 100 天编程挑战构建了一个 Discord 机器人。

如果你有兴趣进一步探索，可以查看本教程参考的实时机器人的源代码，其中包括自定义错误、日志记录、外部错误报告和文档站点。

只需要一小部分熟练的自动化工程师和领域专家就有可能将整个团队中的最繁琐的工作实现自动化。

在这篇文章中，我们将探讨基于 Python（一种强大的且简单易学的编程语言）来实现自动化工作流程的一些基础知识。我们将使用 Python 来编写一个简单有用的小型自动化脚本，这个脚本能够整理指定文件夹中的文件，并将其放到对应的文件夹中。

我们的目标不是在一开始就编写完美的代码以及构建一套理想的自动化体系。

当然我们也不会创建任何“非法”的脚本。相反的，我们将研究如何创建一个能够自动整理文件夹内容的脚本。

目录

1. 自动化的领域
   • 简单的自动化
   • 公共 API（Application Program Interface 应用程序接口）的自动化
   • API 的逆向工程
2. 自动化的道德考量
3. 创建整理文件夹脚本
4. 一份自动化程序的完整指南

自动化的领域

让我们从定义哪种类型的自动化开始。

自动化技术适用于大多数领域。从初级的，它可以帮你从一堆文档中提取邮箱地址，这样你就可以群发邮件了。到复杂一点的，优化大型公司的内部工作流程。

当然，从小型的个人脚本到可以替代人工的大型自动化系统，这中间需要一个学习的过程。所以让我们来看看你适合从哪个领域开始自动化之旅。

简单的自动化

直接针对工作中的某一点流程实现简单的自动化。这其中可以是某些小型的独立的步骤，例如整理项目并重新编排目录中的文件，也可以是整个工作流程中一部分，例如自动调整已经保存文件的大小。

公共 API 的自动化

现如今我们可以通过 HTTP（Hypertext transfer protocol 超文本传输协议）请求对应的 API 来实现绝大部分程序的功能，因此自动调用公共 API 是最常见的自动化程序。例如，如果你需要给你家的花园实现自动化灌溉。

为此，你需要根据当天天气来决定是要浇水还是有雨要来。

API 的逆向工程

在实际的程序中，基于 API 逆向工程的自动化程序更为常见。在下文的“自动化的道德考量”中也会探讨机器人冒名顶替真是人类的问题

通过对一个 API 进行逆向工程，我们可以了解用户在某个应用中的操作流程。例如登录一个网页游戏的步骤。

通过理解登录和身份验证的逻辑，我们可以使用脚本来复制这一动作。然后即使他们不对外提供应用界面，我们也可以创建自己的接口脚本来使用他们的应用。

无论你是出什么目的，请考虑一下它是否合法。

你也不想惹麻烦，对吧？😁

道德考量

GitHub 上有个人联系到我说：

“点赞数和订阅数就是数字时代的货币，但是你们正在让它贬值。”

This stuck with me and made me question the tool I've built for exactly that purpose.
我一直思考着这个问题，并开始质疑我构建程序真正的目的是什么。

事实是，这些互动和点赞可以通过自动化的方式进行伪造，这种伪造越来越多，导致扭曲和破坏了社交媒体的正常运行。

如果不使用机器人或者其他的刷赞系统，用户和广告公司将看不到那些真正产出好内容并创造价值的人

我的一个朋友借助但丁《神曲》中《地狱篇》的“九层地狱”的情景，来向我解释随着你社会影响力的一步步扩大，你越来越难以意识到这个系统实际的破败之处。

我想和你分享这个观点，因为我认为这能非常准确的描述在我使用 InstaPy 工具与网红合作期间所看到的一切。

第一层：灵薄狱

假如你不使用机器人。

第二层：纵欲

当你手动的开始点赞和关注尽可能多的人，并让他们也点赞和关注你的文章。

第三层：暴食

当你加入一个 Telegram 群，大家点赞并评论 10 张照片，那么接下来的 10 个人也会点赞并评论你的照片。

第四层：贪婪

当你使用低成本的虚拟助手帮你点赞和关注。

第五层：愤怒

当你使用机器人去点赞，但是没有任何点赞的回馈（但是你不用付费，例如 Chrome 游览器中的扩展程序）。

第六层：异端

当你使用机器人给出 50+个点赞并获得 50+个点赞（但是你不用付费，例如 Chrome 游览器中的扩展程序）。

第七层：施暴

当你使用机器人点赞、关注、评论 200-700 张照片，并无视禁言的警告。

第八层：欺诈

当你付费给未知的第三方服务去自动的帮你获得点赞和关注，同时也用你的账号去点赞和关注别人。

第九层：背叛者

当你付费购买点赞和关注数，试图去包装自己成为一个网红。

在社交媒体上面使用机器人非常常见，以致于如果你不包装，你会被卡在第一层，即灵薄狱，与你的同行比起来你的关注人数没有增长，订阅量也低。

从经济型理论看，这叫囚徒困境和零和博弈。如果我不使用机器人，但是你用了，你就赢了。如果你没有用，但我用了，我就赢了。如果我们都不用，那么我们就能共赢。但是对于那些没有使用机器人的人是没有奖励的，大家就都在用，那么没有人会赢。

请警惕这点，不要忘记整个工具对社交媒体的影响。

来源：SignalSciences.com

我们希望规避道德问题，并继续开展一个自动化的项目。这就是我们为什么只是创建一个简单的目录整理脚本来帮祝你整理乱糟糟的文件。

创建整理目录脚本

现在让我们来看一个非常简单的脚本。它会自动整理指定的目录，将其中的文件根据文件后缀名移动到对于的文件夹。

下图就是我们将要做的事情：

设置参数解析器

由于我们会用到操作系统的功能，比如移动文件，所以我们需要导入 os 库。除此之外，我们还希望用户能够控制要整理的文件夹，因此我们还会用到 argparse 库。

import os
import argparse

导入了这两个库之后，我们首先要设置参数解析器。确保为每个参数有对应的描述和帮助文本，以便用户在输入 --help 时得到帮助。

我们的参数会被命名为 --path。 参数名前面的双破折号告诉库这是一个可选参数。默认情况下，我们使用当前目录，因此将默认值设为 .。

parser = argparse.ArgumentParser(
    description="Clean up directory and put files into according folders."
)

parser.add_argument(
    "--path",
    type=str,
    default=".",
    help="Directory path of the to be cleaned directory",
)
# 解析用户提供的path参数的值
args = parser.parse_args()
path = args.path

print(f"Cleaning up directory {path}")

这就完成了参数解析的部分，非常简单易读，对吧？

让我们执行一下脚本，检查是否有报错。

python directory_clean.py --path ./test

=> Cleaning up directory ./test

一旦执行，我们可以在控制台中看到目录名称被打印出来，完美。

现在让我们来使用 os 库来获取给定路径下的文件。

从文件夹中获取文件列表

通过给 os.listdir(path) 方法提供一个有效的路径，我们就能获得该目录内所有文件和文件夹的列表。

在列出了文件夹内所有的元素后，我们需要对文件和文件夹进行区分，因为我们只需要整理文件而不是文件夹。

我们使用 Python 的列表来遍历所有元素，根据是否满足是文件还是文件夹的条件将他们放到新的列表中。

# 获取目录中的所有文件
dir_content = os.listdir(path)
# 根据文件和文件名创建相对路径
path_dir_content = [os.path.join(path, doc) for doc in dir_content]
# 过滤目录内容到文档或文件夹列表
docs = [doc for doc in path_dir_content if os.path.isfile(doc)]
folders = [folder for folder in path_dir_content if os.path.isdir(folder)]
# 记录文件移动的数量
# 列出已经创建的文件夹以免出现重复
moved = 0
created_folders = []

print(f"Cleaning up {len(docs)} of {len(dir_content)} elements.")

和之前一样，让我们确保用户能够得到反馈。所以需要打印一个告知用户多少文件被移动的信息。

python directory_clean.py --path ./test

=> Cleaning up directory ./test
=> Cleaning up 60 of 60 elements.

当我们再次执行 python 脚本之后，我们可以看到在 /test 文件夹下将会出现 60 个被移动的文件。

根据文件后缀名创建文件夹

接下来也是最重要的一步是根据每个文件的后缀名创建文件夹。我们希望通过遍历所有已经过滤好的文件，如果没有创建对应后缀名的文件夹，就创建一个。

os 库能给我们提供非常友好的功能，例如拆分给定文件的类型和路径，提取文件路径和文件名。

# 遍历所有的文件，并移动到对应的文件夹中
for doc in docs:
    # 提取文件后缀名
    full_doc_path, filetype = os.path.splitext(doc)
    doc_path = os.path.dirname(full_doc_path)
    doc_name = os.path.basename(full_doc_path)

    print(filetype)
    print(full_doc_path)
    print(doc_path)
    print(doc_name)

    break

如果我们的目录包含成堆的文件，那么上面代码末尾的 break 语句用于确保我们的终端不会列满所有的文件信息。

我们设置好这一步之后，让我们执行一下脚本，看到的内容可能类似这样的：

python directory_clean.py --path ./test

=> ...
=> .pdf
=> ./test/test17
=> ./test
=> test17

我们可以通过上面的实现，分离文件类型，然后从完整路径中提取部分内容。

现在我们有了文件类型，我们就能检查拥有这个文件类型的同名文件夹是否已经存在。

在开始这一步之前，我们需要跳过一些文件。如果我们使用当前目录 . 作为路径，我们需要避免 python 脚本也被移动。可以通过一个简单的 if 条件语句来解决这个问题。

另外，我们也不希望移动隐藏文件，所有 . 开头的文件也要跳过。 macOS 上的 .DS_Store 就是一个例子。

    # 当在目录中存在 名为 directory_clean 的文件或 . 开头的文件在时跳过
    if doc_name == "directory_clean" or doc_name.startswith('.'):
        continue
    # 获得子文件夹的名称，创建其中不存在的文件夹名
    subfolder_path = os.path.join(path, filetype[1:].lower())

    if subfolder_path not in folders:
        # 创建文件夹

处理完 python 脚本路径和隐藏文件后，我们可以继续在系统中创建文件夹了。

除了我们的判断之外，如果一开始读取目录时发现同名文件夹已经存在，我们需要一种能够检测已创建文件夹的方法。这就是我们要声明数组变量 create_folders = [] 的原因。它将用来存储已被检测过的文件名。

os 库中提供了一个 os.mkdir(folder_path) 的方法用于根据路径创建新文件夹。

这个方法可能会抛出异常，告诉我们文件夹已经存在。所以我们需要确保异常被捕获。

if subfolder_path not in folders and subfolder_path not in created_folders:
    try:
        os.mkdir(subfolder_path)
        created_folders.append(subfolder_path)
        print(f"Folder {subfolder_path} created.")
    except FileExistsError as err:
        print(f"Folder already exists at {subfolder_path}... {err}")

在编写完创建文件夹的代码后，让我们重新运行一遍脚本。

python directory_clean.py --path ./test 

=> ...
=> Folder ./test/pdf created.

在第一次执行时，我们从日志列表看到，我们已经创建了以文件后缀名命名的文件夹。

最后一步就是移动文件到它们对应的父文件夹中。

当使用 os 库时需要明白的最重要的一点是，有些操作无法撤销。例如，删除文件的情况。因此，在执行脚本前我们需要先注释掉部分内容

这也是为什么我们的 os.rename(...) 方法会在这里被注释掉。

# 获取新文件路径，移动文件
    new_doc_path = os.path.join(subfolder_path, doc_name) + filetype
    # os.rename(doc, new_doc_path)
    moved += 1

    print(f"Moved file {doc} to {new_doc_path}")

运行完我们的脚本并看到正确的日志之后，我们可以撤销 os.rename() 方法的注释，并最终写成这样的。

# 获取新文件路径，移动文件
    new_doc_path = os.path.join(subfolder_path, doc_name) + filetype
    os.rename(doc, new_doc_path)
    moved += 1

    print(f"Moved file {doc} to {new_doc_path}")

print(f"Renamed {moved} of {len(docs)} files.")

python directory_clean.py --path ./test

=> ...
=> Moved file ./test/test17.pdf to ./test/pdf/test17.pdf
=> ...
=> Renamed 60 of 60 files.

最后的这个运行结果会将所有文件移动到对应的文件夹中，我们的目录不需要手动操作也能很好的被整理。

下一步，我们可以利用我们上面创建好的脚本去做更多是事情，例如，安排脚本在每个星期一定时清理 Downloads 文件夹，以便让其看起来更整洁有序。

这也是我们在 Udemy 中创建的名为创建自动化程序的后续课程

一份完整的日常自动化程序指南

Felix 和我在学习 InstaPy 库和他的 Travian-Bot 库的基础上创建了一个教你如何创建自己的机器人的在线视频。实际上，他也因为这个库太火爆导致想关闭这个项目。

原文：How to Build a Bot and Automate your Everyday Work，作者：Tim Grossmann