Боков Глеб's questions

我正在Metait.com上学习“分层数据”课程。例如，采用一个递归实体，它可以具有到父实体及其子实体的链接：MenuItem

public class MenuItem
{
    public int Id { get; set; }
    public string? Title { get; set; }
    public int? ParentId { get; set; }
    public MenuItem? Parent { get; set; }
    public List<MenuItem> Children { get; set; } = new();
}

现在，如果我们MenuItem按如下方式初始化几个：

using (ApplicationContext db = new ApplicationContext())
{
    // пересоздаем бд
    db.Database.EnsureDeleted();
    db.Database.EnsureCreated();
 
    // добавляем начальные данные
    MenuItem file = new MenuItem { Title = "File" };
    MenuItem edit = new MenuItem { Title = "Edit" };
    MenuItem open = new MenuItem { Title = "Open", Parent = file };
    MenuItem save = new MenuItem { Title = "Save", Parent = file };
 
    MenuItem copy = new MenuItem { Title = "Copy", Parent = edit };
    MenuItem paste = new MenuItem { Title = "Paste", Parent = edit };
 
    db.MenuItems.AddRange(file, edit, open, save, copy, paste);
    db.SaveChanges();
}

那么，例如，Menuitem对于标题，File将会有MenuItem带有标题Open和的子项Save：

using (ApplicationContext db = new ApplicationContext())
{
    // получаем все пункты меню из бд
    var menuItems = db.MenuItems.ToList();
    Console.WriteLine("All Menu:");
    foreach (MenuItem m in menuItems)
    {
        Console.WriteLine(m.Title);
    }
    Console.WriteLine();
    // получаем определенный пункт меню с подменю
    var fileMenu = db.MenuItems.FirstOrDefault(m => m.Title == "File");
    if(fileMenu != null)
    {
        Console.WriteLine(fileMenu.Title);
        foreach(var m in fileMenu.Children)
        {
            Console.WriteLine($"---{m.Title}");
        }
    }
}

File
---Open
---Save

但是该字段是如何初始化的Children呢？我们没有在任何地方显式设置它的值，并且在生成的 SQL 查询中完全不存在这样的字段：

CREATE TABLE "MenuItems" (
    "Id"    INTEGER NOT NULL,
    "Title" TEXT,
    "ParentId"  INTEGER,
    CONSTRAINT "FK_MenuItems_MenuItems_ParentId" FOREIGN KEY("ParentId") REFERENCES "MenuItems"("Id"),
    CONSTRAINT "PK_MenuItems" PRIMARY KEY("Id" AUTOINCREMENT)
);

有很多关于如何使用 SSH 密钥建立与 VPS 的连接的材料（高质量文章的示例）。简而言之，使用ssh-keygen实用程序，您需要生成一对密钥（公钥和私钥），然后以某种方式将打开的密钥上传到 VPS。

根据该视频的解释，

像往常一样，我们通过不安全的通道（即互联网连接）传输数据包。我们使用公钥加密每个数据包，并使用私钥进行解密。公钥是公开的，万一有人拿到了也不可怕。它可以加密消息，但不能解密。

连接中的每个参与者都会创建一个公钥-私钥对，然后双方交换各自的公钥。

从逻辑角度来看，第一点难以理解的是，如果说密钥交换，为什么在本地机器和 VPS 上有一份公钥副本？原来客户端和服务器都用同一个公钥加密数据包？

但最重要的是：我们的说明中哪里提到了为服务器创建密钥对？我们在本地计算机上创建密钥并将公共密钥上传到服务器，以便可以解密来自服务器的响应。但是，如果没有私钥，服务器如何解密来自客户端的消息呢？

由于数据不可能以明文形式发送到服务器，因此我们只能断定VPS最初有私钥。但它与我们之前创建的公钥匹配吗？

本题的目的是获得有关算法的提示。我认为，无论语言如何，事件生成的实现都或多或少相同，但通知的显示将取决于平台。在这件事上，我们不会进入这样的丛林，但是，为了举一些例子，让我们考虑一下像“Microsoft To Do”这样的常规任务管理器。

此类应用程序工作的主要实体是任务（task）。准备了一个简单的C#类Task：

public class Task
{
  public required string ID { get; init; }
  public required string Title { get; set; }
  public string? Description { get; set; }
  public bool IsComplete { get; set; } = false; 
}

我不认为创建一个单独的实体有任何意义Notification，因为任何事物Notification只有与特定任务相关时才有意义，并且该实体除了时间之外不会有任何字段。尽管在“Microsoft 待办事项”列表中，您只能为每个任务设置一个警报，但在 Google 日历事件中，您可以指定多个警报，因此我将执行相同的操作：

public class Task
{

  public required string ID { get; init; }
  public required string Title { get; set; }
  public string? Description { get; set; }
  public bool IsComplete { get; set; } = false; 

  // Новое
  public List<DateTime> Notifications { get; set; } = [];

}

现在有必要创建一个事件生成算法，根据该算法，在正确的时间就可以知道应该立即提醒用户哪个任务。

最简单（但也是愚蠢）的解决方案如下：

1. 创建一个周期为 1 分钟的重复计时器
2. 每分钟从按时间筛选的数据源（例如数据库）中抓取所有任务。更详细地说，您需要找到那些具有Notifications与当前分钟相对应的数组元素的任务。（如何在数据库中实现数组的存储是单独讨论的）。
3. 为每个提醒调用事件处理程序

我想从性能的角度来看，每分钟爬行整个数据库是一个坏主意，并且字段Notifications不能成为索引以加快搜索速度。我认为用于本机开发的编程语言应该为此类任务提供某种 API。同样重要的是，应用程序可以在后台工作时显示警报。

虽然这个问题是关于算法的，而不是关于在特定编程语言和特定库中的实现，但是如果你对我的技术栈感兴趣，那么它就是 C#、.NET MAUI 和 Blazor。由于开发是同时针对多个平台（Android、iOS、macOS、Windows、Tizen）进行的，因此一些具有现成解决方案的 Andorid 库不足以解决此问题；您可能必须自己实施一切。

如您所知，带有环境变量的文件（通常具有带或不带文件名的扩展名.env）通常不会被版本控制系统跟踪，以防止数据库密码等数据泄露。SLL 密钥和证书文件怎么样？我请你分别考虑本地开发、分期和制作的情况。

关于这个话题的思考过程

本土化发展模式

如果在本地开发模式下您使用自行颁发的（例如，使用mkcert）SSL 密钥和证书，那么通常我认为没有理由将它们排除在版本控制系统的跟踪之外。它似乎不包含任何敏感数据。

强制每个团队成员自己颁发证书的唯一可能原因是 mkcert 中可能缺少强制浏览器信任已颁发证书的命令。如果确实没有这样的命令，那么每个参与者都必须自己运行该命令mkcert，这不仅会颁发密钥和证书，而且浏览器也会信任它们。在 Windows 上没有 mkcert 的情况下执行此操作并不容易（在我提出问题时我无法做到这一点）。

根据评论更新

正如@andreymal 评论的那样，

如果您将自行颁发的证书添加到受信任的浏览器中，那么泄露其私钥将允许攻击者发起中间人攻击，因此非常危险

我希望这不会成为在本地开发模式下仅使用 HTTP 协议（​​而不是 HTTPS）的理由。

生产

我不确定，但我认为生产模式的 SSL 密钥和证书是不应泄露的秘密信息。有一定的可能性，它们也可以使用浏览器开发者模式作为 CSS 或 JS 文件进行一般查看，但这又是一个假设。

与本地开发模式下每个团队成员都可以拥有自己的自行颁发的 SSL 密钥和证书不同，在生产模式下，每个人都会有一个密钥和一个证书（很可能由授权组织以可报销的方式颁发）。如果是这样，它们将不得不被排除在版本控制之外，并以其他方式在团队成员之间转移。

根据评论更新

有人提出这样的问题：如果理论上一两个生产服务器管理员知道就足够了，为什么团队成员应该了解生产 SSL？我的答案是：根据项目组装和部署的自动化的组织方式，有时在源代码文件中拥有 SLL 密钥和证书会很方便。

首先值得警惕的是，只有生产服务器的管理员才应该知道 SSL 密钥。我并不是说这是错误的，但在这种情况下，当只有一两个团队成员拥有 SSL 密钥和证书时，可能会出现问题。例如，管理员没有上班，但需要发布应用程序修补程序。或者应用程序运行所需的文件分散在团队成员中而不是组织在一起。

再说一次，我并不是说每个人都应该这样做，但我将项目收集在一个文件夹中，该文件夹中放置了应用程序在服务器上工作所需的所有内容，特别是 ssl 密钥、证书和环境变量文件：

因此，构建项目后，剩下的就是以一种或另一种方式将文件发送到 VPS 并docker compose build在 VPS 上重新启动它。

我知道有各种各样的高级部署方法，特别是 GitHub 上的 CI/CD 或各种 AWS 工具。例如，您可以使用 AWS 组织环境变量的注入，而无需使用 .env 文件 - SSL 可能有类似的东西。但所有这些都将开发商与特定的供应商联系在一起。有时这是合理的，但当最初只有一个使用裸 Ubuntu 的 VPS 时，仍然必须有某种方法来有效地组织部署。

您可以使用绝对 URL 嵌入图像，如下所示：

html <img src="https://www.example.com/images/dinosaur.jpg">

但这是没有意义的，因为它只会让浏览器通过每次向 DNS 服务器请求 IP 地址来完成更多工作。您几乎总是将网站图像与 HTML 保存在同一服务器上。

MDN 网络文档

这是否会扩展到缩短的绝对路径，例如/ru/docs/Learn/HTML/Multimedia_and_embedding/Images_in_HTML？如果没有，那么应该首选相对路径......

使用自动实现的属性，您可以简化代码，同时 C# 编译器透明地为您提供一个支持字段。

官方指南

“透明提供”是什么意思？

public class Person
{

  public uint ID { get; init; }
  public required string Name { get; init; }  
  public required string Email;
  
}

据我实验，在属性的情况下，orName字段不会自动生成。或者它是以我无法访问的方式生成的？_namename

清晰界定问题的边界

虽然我试图在标题中说清楚，但我会重申这个问题的重点是以下条件组合：

• Getters 只返回对应字段的值，没有别的。
• 设置器只设置相应字段的新值，没有别的。
• getter 和 setter 都是公开的

因此，诸如“setter 不仅可以设置一个值，还可以做其他事情”或“setter 可以设为私有，从而使特定字段成为只读”之类的答案不会回答所提出的问题。

正在考虑的案例中 getter 和 setter 无用的理由

在教授支持 OOP 的语言时，通常会说这样的话：

使用修饰符隐藏字段private或 protected通过公共 getter 和 setter 从外部访问它们是一种很好的做法。

至于你不应该打开类用户不需要的字段这一事实，没有人反对 - 一切都是理性的。但是这个问题是关于那些需要从外部访问的字段。并且他们也应该被私有化并且公共的 getters 和 setters 应该被添加到他们的声明听起来像一个背景不清楚的教条。

例如，这个 Java 类：

class Person {

 private String name;
 private String email;

  
 public String getName() {
   return this.name;
 }

 public void setName(String newName) {
   this.name= newName;
 } 


 public String getEmail() {
   return this.email;
 }

 public void setEmail(String newEmail) {
   this.email = newEmail;
 }

}

不同于班级

class Person {

 public String name;
 public String email;

}

只是以一种复杂的方式访问字段nameand email，但结果是，用户仍然可以读取和更改这些字段，因此不清楚人们常说的“使用 getter 和 setter 更安全”的依据是什么。

一般来说，在 C# 中，有一个传统是用 getter 和 setter 覆盖所有字段：

public class Person
{
  public string Name { get; set; };
  public string Email { get; set; };
}

再说一次：与下面的代码相比，它是否真的提供了一些东西，或者它只是某种抽象的最佳实践，比如“每个人都这样做，你也这样做”？

public class Person
{
  public string Name;
  public string Email;
}

使用以下设置运行docker-compose实用程序时：

version: "3"

services:

  Database:

    image: postgres
    container_name: Database
    restart: always
    ports:
      - "5432:5432"
    environment:
      POSTGRES_PASSWORD: "*****" # TODO Переместить в .env

为数据库自动创建一个卷。显然，他的名字是一个哈希和，例如b8e00e114ac2d57b5907e0bd75cb046721b50eeff5d74f12a。

由于在商业开发的条件下，需要组织与开发相关的所有内容，包括 Docker 镜像、容器和卷，因此您需要给卷起一个名称，以便您可以了解它属于哪个项目。怎么做？

就像问题的作者一样，package-lock.json 是干什么用的？，只是阅读文档并没有让我清楚为什么需要 package-lock.json 。几年来，我只是愚蠢地遵循了应该使用版本控制系统监控这个文件的建议，但是在组织已安装依赖项的版本时，我总是设置特定版本，而不是范围，例如：

{
  "private": "true",
  "dependencies": {
    "@nestjs/common": "9.0.7",
    "@nestjs/core": "9.0.7",
    "@nestjs/platform-express": "9.0.7",
    "@nestjs/typeorm": "9.0.0"
  }
}

代替

{
  "private": "true",
  "dependencies": {
    "@nestjs/common": "^9.0.7",
    "@nestjs/core": "^9.0.7",
    "@nestjs/platform-express": "^9.0.7",
    "@nestjs/typeorm": "^9.0.0"
  }
}

因为它在某种程度上更平静，尤其是在团队中工作时。

但是，这仍然不好 - 您需要了解我在做什么以及为什么要这样做，因此出现了问题：如果存在 package-lock.json，我采取的版本安全措施（安装特定版本）是否有意义？

在 mdn 网络文档上有一篇关于响应式图像的精彩文章，其中介绍了两种处理响应式图像的工具——srcset和sizes属性以及图片和源标签：

<img srcset="elva-fairy-320w.jpg 320w,
             elva-fairy-480w.jpg 480w,
             elva-fairy-800w.jpg 800w"
     sizes="(max-width: 320px) 280px,
            (max-width: 480px) 440px,
            800px"
     src="elva-fairy-800w.jpg" alt="Elva dressed as a fairy">

<picture>
  <source media="(max-width: 799px)" srcset="elva-480w-close-portrait.jpg">
  <source media="(min-width: 800px)" srcset="elva-800w.jpg">
  <img src="elva-800w.jpg" alt="Chris standing up holding his daughter Elva">
</picture>

这就是我不明白的，所以这是在这种情况下使用哪个工具。在第一种情况下（使用img），我们只有分辨率不同，而显示的是相同的图像（至少我们知道这一点，渲染浏览器不会检查这一点）。如果我们制作不同的图像怎么办？假设对于宽屏幕 - 横向，对于窄屏幕 - 纵向。我们可以说：“ srcset和sizes不是为此而设计的”。好的，如果图像的不同不仅仅是扩展名，那么技术上会出现什么问题？

图片/来源也是如此。在每个源标签中，我们有不同的图像，但技术上的问题是这些图像只会在分辨率上有所不同？

文章说：

注意：您应该只将属性media用于艺术品；使用时media，请勿将媒体条件与sizes.

本说明仅提出新问题：

1. 为什么该属性只能用于media艺术媒体？是什么原因？
2. 说是使用属性media，而不是标签source。也就是说，如果我们没有带装饰的案例，那么source可以使用标签，只是没有属性media？

我最近在尝试使用非 root 帐户通过 rsync 将数据发送到权限为 777 的目录时提出了一个非常具体的问题“Permission denied (13)”错误，但答案只提出了更多问题。我似乎根本不理解这个概念，这就是为什么我问这个更笼统的问题。

那么，我是否理解正确，当我们调用chmod（例如，授予读写访问权限）时，默认情况下，权限仅扩展到直接包含在此目录中的文件，而不是子目录中的文件？（我还听说过您可以递归地授予许可这一事实）。

我经常在同一个项目中看到eslintrc和prettierrc，而且至少大部分 prettierrc 规则都被ESLint覆盖了。是否可以说“Prettier 完全没有必要，因为它完全复制了更强大的 ESLint 的功能”？

刚刚通过npx react-native init AwesomeTSProject --template react-native-template-typescript. Expo 不适合我，因为据我所知，这个框架只为 Android 和 iOS 构建，我打算在所有支持的平台上运行该应用程序。

一般来说，我尽量不使用项目生成器，原因有两个：

1. 很多不必要的
2. 建议的文件结构通常不适合我。

但是，我还没有 100% 手动部署 React Native 项目的方法，因此我必须清理和重新组织建议的文件结构。

首先引起您注意的是 Ruby 文件（.ruby-version、 Gemfile、Gemfile.lock）的存在。从逻辑的角度来看，尚不清楚这些文件在 React Native 项目中的作用——他们是否建议我用 Ruby 编写服务器部分？

那么，第二个问题是是否可以安全地删除所有这些文件。

关于 JavaScript 中的深度复制对象有很多讨论，并且在 StackOverflow 上提供了许多英文版的解决方案。我什至有我自己的。

但在我再次承担这项任务之前，我想问一个问题——原则上是否可以自主克隆任意对象？许多解决方案（包括我的最新版本）没有考虑到：

• 具有“函数”类型值的属性
• Getter 和 Setter
• 不可枚举的属性
• Maps 和 Sets（更不用说 WeakMap 和 WeakSet）

我知道这条信息不仅被专业人士阅读，而且还被那些不了解问题深度的初学者阅读，因此可能很想回答这样的问题：“哈！是的，它是初级的！const clone = { ...original }-就是这样！ ！！”。但如果就这么简单，我在 Web 开发的第七年就不会问这个问题了，所以让我们分解并清除流行的误解。

但首先，让我们澄清定义。 深拷贝一个对象意味着更改克隆对象的任何属性，包括其所有子对象的属性，都不会以任何方式影响原始实例，而克隆对象与原始实例完全相同，包括属性函数，非- 可枚举的属性，等等。

错误决策的分析与排除

序列化后反序列化

在这个方法中，我们首先用 序列化对象，JSON.stringify(original)然后用 反序列化它JSON.parse。在一行中，它将是这样的：

JSON.parse(JSON.stringify(original))

让我们尝试克隆以下原始对象：

const original = {
    alpha: "FOO",
  bravo: () => { return "BAR" }
}

const clone = JSON.parse(JSON.stringify(original));

但是如果我们将它打印到控制台，那么bravo属性将会丢失。此外，这种方法对我们来说不再感兴趣。

Object.assign 和传播运算符

查看语法

const clone = { ...original }

或者

const clone = Object.assign({}, original )

不做深度克隆——事实上，这是用一个容器替换另一个容器，内容引用与原始对象相同的内存区域。

const original = {
    alpha: "FOO",
  bravo: {
    charlie: "BAR"
  }
}

const clone = { ...original };
clone.bravo.charlie = "HOGE";

console.log(original.bravo.charlie); // "HOGE"!!! Какого ... ?!

对于对象的特殊情况 - 数组也是如此：

const clone = [ ...original ];

好吧，正如 Dan Abramov 在他的 Redux 中所建议的那样，分别复制每个子对象是 21 世纪第三个十年的某种狂野——当我被提议做时，我可以谈论什么样的纳米技术、机器人技术和火星地球化这么日常的工作？这就是这种日常废话的样子：

function updateVeryNestedField(state, action) {
  return {
    ...state,
    first: {
      ...state.first,
      second: {
        ...state.first.second,
        [action.someId]: {
          ...state.first.second[action.someId],
          fourth: action.someValue
        }
      }
    }
  }
}

深度复制任意对象的问题

复制功能

首先，尚不清楚函数的深度克隆实际上意味着什么。从技术上讲，这可能意味着声明与现有函数相同的函数，但在不同的内存区域中。但也许我错过了一些东西。

我的职业生涯是从 ES6 语法开始的，所以我没有发现程序员使用函数作为类来敲钉子的时候。如果不考虑这些技巧，那么

function original() {

}

const clone = original;

虽然不会是深拷贝，但它会导致任何问题吗？

我在英语的 StackOverflow 上找到了这个解决方案：

const newFunc = oldFunc.bind({}); 

如果这样的解决方案不会引起任何副作用，那么我会注意到它。

一种或另一种方式，我们在这里谈论对象的深度克隆，特别是属性-函数（方法）。在那里，在方法内部，也可以有this，并且在深度复制期间，必须将链接指向this克隆。

复制 getter 和 setter

当对 getter 和 setter 进行迭代时Object.entries(original)（如我上面的解决方案），值将是这些 getter 和 setter 返回的值（并且由于 setter 本质上不返回任何内容，这将是undefined）：

const original = {
  alpha: "FOO",
  get charle() {
    return this.alpha + "__" + "BAR";
  },
  set delta(value) {
    this.alpha = value;
  }
}

for (const [key, value] of Object.entries(original)) {
  console.log(key);
  console.log(value);
}

此处属性的值charle将是字符串FOO__BAR。

alpha
FOO
charle
FOO__BAR
delta
undefined

它不会像这样工作（会有相同的结果）：

for (const key of Object.keys(original)) {
  // ...
}

不可枚举的属性

说实话，根据我的所有经验，我几乎从不需要迭代不可枚举的属性。但原则上，我们可以了解不可枚举属性 * 的存在（例如，通过Object.getOwnPropertyNames(object1)），甚至更多地转向它们，因此更进一步 - 上述所有问题。

地图和集合

Map 无法转换为 JSON，这可能会导致问题（我不确定我之前建议的解决方案是否可以通过改进来最终确定；可能需要从根本上改变方法）。

也许这些集合需要通过创建一个相同类型的新容器来单独处理。但毕竟，随着时间的推移，新的容器会被添加到 ES6 中，然后你将不得不对实现进行更改

最后一个问题

问题是：上述所有与派生对象的深度克隆有关的问题，以及我没有提及的问题，原则上是可以克服的吗？在创建深拷贝功能时可以考虑到这一点吗？或者，仅自主复制仅包含可序列化为 JSON 的数据类型（数字、字符串、布尔值、null、数组、对象）的对象是否现实？

“服务器！” - 我想回答这个看似愚蠢的问题。但如果真的这么简单，我就不会在我从事 Web 开发的第七年问他了。

尽管有条件地将 Web 应用程序分为客户端和服务器部分很流行，但现代 Web 应用程序的架构并不是那么二元的：

• 数据库可以在单独的服务器上
• 可以有多个数据库，每个数据库都在自己的服务器上
• 除了“客户端”（通常任意多个）和“服务器”（鉴于前两点已经相当混乱的概念）之外，可能还有第三方服务，例如日志记录或分析，每个服务器都有自己的

已经向我解释过，有必要区分“服务器”作为角色 - 与客户端相关的源和数据处理程序，客户端不必知道其结构（“黑匣子” “ 概念）; 并且作为这个非常黑匣子的基础设施。所以，在这个问题上，我对第二个问题更感兴趣。

那么，接受来自客户端的 HTTP 请求并进行初始处理的带有三个问号的系统元素的名称是什么？我们不能只称它为“服务器”，因为服务器可以随心所欲，并且每个都有自己的角色（处理来自客户端的请求、存储数据、存储文件等）。例如，在创建视频托管时，建议至少提供两台服务器，其中一台将接管仅视频文件的返回。

术语 HTTP 服务器也没有明确地描述这个元素。假设接收来自客户端的请求的同一台服务器与第三方服务（如分析）的服务器交换数据。数据交换的协议是什么？很可能是 HTTP(S)。在问这个问题的时候，我对数据库的了解是肤浅的，但我可以假设与位于不同服务器上的数据库进行数据交换，无论如何，有时也通过 HTTP 协议进行。

但是“后端”可能是指前端另一端的所有东西——处理来自客户端的 HTTP 请求的同一个黑盒子，但前端开发人员可能事先不知道其结构。如果是这样，那么“支持”也不会是您问题的答案。

我还想指出当他们说“无服务器应用程序”时造成的混乱。实际上，它们意味着您不必自己编写服务器代码，而是提供了一个由服务所有者提供的具有完善逻辑的现成服务器（如果我错了，请纠正我）。

我真的很想使用 Java 引入的“servlet”这个词，但就我输入的模糊规范定义而言，这个词很可能并不代表我的意思。此外，该元素接受来自客户端的不同请求，与电子总线的概念有点相关。

根据此链接，localhost 是顶级域（TLD）。

问题出现了 - 一个 TLD 可以紧跟一个三级域等等吗？当我们从本地开发模式切换到生产模式时会出现这种情况，而我们需要在本地开发模式下测试依赖子域的逻辑。

假设我们有ru和en locale subdomains 。然后在本地模式下，我们将拥有localhost、ru.localhost和en.localhost 域。在生产中，我们将拥有一个成熟的域，至少包含两个级别（例如，example.com）。然后除了example.com我们还有 ru.example.com和en.example.com。

因此，当切换到生产模式时，我们要么进行一级转换，要么直接跳过ru.localhost中的 SLD 。它呢？

还有，有没有其他类似的案例，类似于 localhost？

这个问题被证明是抽象的，但不幸的是，字符限制不允许在标题中包含最少的解释。最有可能的是，正确答案将是以下两个选项之一：

1. 告诉实例做某事
2. 在实例上做某事

不及物动词（第一个选项）和及物动词（第二个选项）之间的区别是一样的。

大约 4 年以来，我认为第一个选项是正确的，因为从 OOP 的角度来看，实例方法的观点是封装适用于实例数据的行为（通常，它们可能不适用于数据，但随后许多 IDE 会提议使方法静态）。

典型的例子，比如“命令一个实例做某事”——rabbit.jump()或者car.move()，也就是说，我们告诉兔子跳，让汽车开车，而我们不需要知道它是如何在那里实现的。

然而，Bruce Eckel 的名著《Java Philosophy》中的第一个例子展示了根据第二种情况使用方法（如果 Light 真的是从英文翻译过来的，除了“light”意味着“灯”）。如果兔子可以自己跳，那么灯就不会自己亮（ ） light.on()，也不会使自己变亮（brighten()）。我理解这些方法是否适用于灯，灯只是细节之一，但我的英语水平不足以说翻译者在翻译light为“灯泡”时犯了错误。

但是我在读完这本书多年后问了这个问题，也是有原因的——我决定将HTTP.ResponseNode.js 中的一个对象包装成一个界面更方便的对象。本机的典型用例HTTP.Response：

response.
    writeHead(500, "Internal server error").
    end();

也就是说，要向客户端发送响应，您需要调用两个方法。该方法end来自对象的线程实体response，但与可用性相比，它的实现细节对我来说不是很有趣，所以我决定添加一个方法来处理调用方法writeHead和end.

我想调用这个方法sendor submit，但这response.submit()意味着请求应该自己发送。老实说，我不知道该对象reponse是如何安排在那里的——也许它真的是自己发送的，但我仍然想澄清一下这个问题中正在讨论的理论点。

这个神圣但过时的 NodeJS 截屏视频展示了这种创建文件流的方式（用 TypeScript 重写）：

import FileSystem from "fs";

const fileReadingStream: FileSystem.ReadStream = new FileSystem.ReadStream(FILE_PATH);

TypeScript 会说这种方式现在无效：

TS2345: Argument of type 'string' is not assignable to parameter of type 'ReadableOptions | undefined'

在查看了类型定义之后，我不明白现在如何建议创建文件流。

类ReadStream没有自己的（非继承的）构造函数，但stream.Readable继承自的构造函数具有以下形式

constructor(opts?: ReadableOptions);

ReadableOptions表单的接口在哪里

interface ReadableOptions extends StreamOptions<Readable> {
  encoding?: BufferEncoding | undefined;
  read?(this: Readable, size: number): void;
}

指定路径的选项在哪里？

:focus在为移动设备布局时为按钮和链接的伪类添加样式是否有意义？事实上，在移动设备上，一个事件:focus（如:hover），如果它存在，不清楚何时以及最重要的是为什么它会起作用。

我预见到了反对意见：“所以桌面设备需要这种状态的样式 - 以便对带有 Tab 键的按钮迭代做出反应。而且由于在自适应设计中我们事先不知道用户控制哪个设备，那么你仍然需要为:focusand :hover因此，在现代 CSS 中，有一个类似 的媒体查询@media (hover: hover)，您可以使用它应用样式，特别是 - 对于伪类:focus，并且:hover仅在事件:hover有意义存在的那些设备上（即主要在桌面设备上）。我不应该这样做有什么合理的理由吗？

本机模块http，https不需要主机来运行简单的服务器。我想出于安全原因，您需要决定将服务哪个主机，然后拒绝 HOST 标头与设置不匹配的请求。

假设我们服务127.0.0.1:1337。但是，如果我们根据子字符串检查标头，则带有标头的请求localhost:1337将无效127.0.0.1。是的，我们知道在这种情况下localhost它是 的代词127.0.0.1，但情况并非总是如此。因此，要标记localhost为有效，您需要以编程方式转换localhost为127.0.0.1:1337. 但是如何在本地做到这一点？

我要求您不要在这件事上推荐任何库和框架，因为这里我们谈论的是通过本机方式独立实现此功能。