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

我非常高兴地阅读了问题的答案讲座：什么可以准确识别网站访问者？。在此过程中，本讲座回答了以下问题：“最流行的身份验证/授权策略是什么？”以及算法的大概描述。好吧，在这个问题上，我想考虑一个更复杂的情况 - 多个应用程序的单一身份验证。

假设我们正在开发 Google Apps 或 Microsoft Office 的类似产品。我们的应用程序（例如 Microsoft Word（例如 N-Docs）或 Google Spreadsheets（例如 N-Spreadsheets））可以作为本机应用程序下载，也可以使用精简的 Web 版本。由于这些应用程序来自同一制造商，因此可以组织单个认证/授权中心。

问题是：什么样的认证策略是合适的，以便一个应用程序中的授权自动执行同一制造商的所有应用程序中的授权？

我们可以肯定地说这是可能的，因为谷歌以某种方式成功了（在网络应用程序的情况下，当然，并且最有可能的是在本机 Andorid 应用程序的情况下）。但这里使用什么身份验证策略呢？

• 就网络而言，我们为每个站点单独存储 cookie，并且我们将在不同的域或子域上拥有应用程序。
• 对于本机应用程序，我们将在系统目录中为每个应用程序拥有一个单独的文件夹，并且无法轻松访问其他应用程序的文件夹。

我正在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有意义存在的那些设备上（即主要在桌面设备上）。我不应该这样做有什么合理的理由吗？