qinsicheng (秦晨)

show history for selection lines in Zed

qinsicheng — Thu, 23 Apr 2026 22:20:47 +0800

相信使用过 JetBrains 产品的用户，对内置的 Git 操作都会觉得很方便。其中很重要的一个功能：选中某几行代码，鼠标右键，使用 show history for selection。就能展示出这几行代码的 git 提交历史记录，这个功能真的太香了。

这个功能在很多编辑器上都不支持，我目前在使用 Zed 编辑器，最开始对 Git 操作支持很少，我都是使用 lazygit 来操作，但上面提到的功能无法实现。所以我就尝试编写脚本去实现这个功能。本质上就是使用 git 原生命令行操作：git log -L <range:file> 。将内容输出到一个临时文件中，然后通过 zed 编辑器打开它，同时使用 diff 语法展示高亮信息。

效果展示：

Fish 代码

function git_line_history --description "Show git history for specific lines in a file"
    # Validate argument count
    if test (count $argv) -ne 3
        echo "Usage: git_line_history <file_path> <start_line> <end_line>"
        return 1
    end

    set -l file_path $argv[1]
    set -l start_line $argv[2]
    set -l end_line $argv[3]

    # Verify the file exists
    if not test -f "$file_path"
        echo "Error: file '$file_path' does not exist"
        return 1
    end

    # Verify we are inside a git repository
    if not git rev-parse --is-inside-work-tree >/dev/null 2>&1
        echo "Error: current directory is not inside a git repository"
        return 1
    end

    # Create temporary files
    set -l temp_file (mktemp -t git_history.XXXXXXXXXX.diff)
    set -l raw_log_file (mktemp -t git_history.XXXXXXXXXX.raw)

    # Build the line range argument for git log -L
    set -l line_range "$start_line,$end_line:$file_path"

    # Fetch the line history
    git log --date=format:'%Y-%m-%d %H:%M:%S' -L $line_range >$raw_log_file 2>&1

    if test $status -ne 0
        echo "Error: failed to execute git log"
        if test -s $raw_log_file
            echo "Details:"
            cat $raw_log_file
        end
        rm -f $raw_log_file $temp_file
        return 1
    end

    # Process output: filter diff metadata and add separators between commits
    awk '
    BEGIN { in_commit = 0; has_content = 0; }
    /^commit / {
        if (in_commit && has_content) print "\n--------------------------------------------------\n"
        in_commit = 1
        has_content = 1
        print
        next
    }
    /^diff --git|^index |^--- a\/|^\+\+\+ b\/|^@@ .* @@/ { next }
    {
        if (in_commit) print
        has_content = 1
    }
    ' $raw_log_file >$temp_file

    rm -f $raw_log_file

    # Check if the result is empty
    if not test -s $temp_file
        echo "Note: no matching commit history found"
        rm -f $temp_file
        return 0
    end

    # Choose an editor: prefer zeditor (Arch Linux), fall back to subl, then $EDITOR
    set -l editor_cmd
    if command -q zeditor
        set editor_cmd zeditor
    else if command -q zed
        set editor_cmd zed
    else if command -q subl
        set editor_cmd subl
    else if set -q EDITOR
        set editor_cmd $EDITOR
    else
        echo "Error: no suitable editor found"
        echo "Temporary file location: $temp_file"
        return 1
    end

    $editor_cmd "$temp_file"

    # Clean up old temporary files from previous runs
    function cleanup_git_history --on-event fish_exit
        # Clean up old temporary files from previous runs
        set -l tmpdir (dirname (mktemp -u))
        rm -f $tmpdir/git_history.*.diff 2>/dev/null
        rm -f $tmpdir/git_history.*.raw 2>/dev/null
    end

    return 0
end

function zed_git_line_history --description "Zed editor wrapper for git_line_history"
    # Extract line range from Zed environment variables
    set -l start_line $ZED_ROW
    set -l selection "$ZED_SELECTED_TEXT"
    set -l line_count (printf '%s\n' "$selection" | wc -l | string trim)
    set -l end_line (math $start_line + $line_count - 1)
    set -l file_path "$ZED_FILE"

    git_line_history "$file_path" $start_line $end_line
end

Zed 配置

task

{
   "label": "git_line_history",
   "command": "zed_git_line_history",
   "env": {
     "ZED_ROW": "$ZED_ROW",
     "ZED_SELECTED_TEXT": "$ZED_SELECTED_TEXT",
     "ZED_FILE": "$ZED_FILE"
   },
   "hide": "always",
   "allow_concurrent_runs": true,
   "use_new_terminal": true
 },

keymap

{
  "context": "vim_mode == normal || vim_mode == visual",
  "bindings": {
      "g h": ["task::Spawn", { "task_name": "git_line_history" }],
   }
}

西安垚海有大佬在里面吗？求问怎么样

qinsicheng — Mon, 20 Apr 2026 21:37:54 +0800

想了解里面公司内文化，氛围。以及是否靠谱

利用 Delegated Types 与 Self Joins 设计高扩展性系统

qinsicheng — Thu, 15 Jan 2026 22:17:13 +0800

前言

如何设计一套类似Confluence、语雀、Notion这类 CMS 系统，在一个容器内，里面含有大量的不同形式的内容，同时多种内容又有很多类似的操作：移动、复制、删除、支持评论等。一个文档下可以写文本，也可以再次建立子文档，文本评论也可以建立子评论。一篇文档能够清晰的查看操作历史、变化内容。同时一个容器内可能还会新增一些不同的内容，又同时也要支持上述的操作。

https://dev.37signals.com/the-rails-delegated-type-pattern/ 文章中探讨了 37Signals 团队如何设计系统架构，保证高维护性和高扩展性。其核心概念就是 Recording、Recordable 和 Event。本质上，他们利用了Delegated Types + Self Joins模式设计架构，来最大程度上支持高扩展性和可维护性。

参考资料：

Active Record Associations — Ruby on Rails Guides

https://api.rubyonrails.org/classes/ActiveRecord/DelegatedType.html

Active Record Associations — Ruby on Rails Guides

以下几种模式需要清楚：

基础模型关联

最常见的关联关系，相当于每个独立的表，通过一个索引关联 ID 来关联其他模型

高级模型关联

Polymorphic Associations

class Picture < ApplicationRecord
  belongs_to :imageable, polymorphic: true
end

class Employee < ApplicationRecord
  has_many :pictures, as: :imageable
end

class Product < ApplicationRecord
  has_many :pictures, as: :imageable
end

这里相当于图片资源，可能属于是用户的，也可能属于是产品的。未来可能还有其他地方也使用图片。那这里在图片模型中就会定义两个字段：

imageable_id
imageable_type

通过 rails 的关联模型，就能直接扩展和关联想要的数据，在复用历史模型的情况下，支持可拓展性

Self Joins

class Employee < ApplicationRecord
  # an employee can have many subordinates.
  has_many :subordinates, class_name: "Employee", foreign_key: "leader_id"

  # an employee can have one leader.
  belongs_to :leader, class_name: "Employee", optional: true
end

一个领导有很多员工，但领导本身也是一个员工，也可能有上级领导。统一存在一个表中，通过一个leader_id进行关联。

这本质上利用了树结构进行灵活的扩展，通过自连接替换掉了普通的模型关联。对于多层级但又是同一类型的实体，这种模式很方便。

Single Table Inheritance 单表继承

允许多个模型存储在单个数据库表中。当你拥有不同类型实体，它们共享共同属性和行为，但又有特定行为时，这非常有用。

例如，假设我们有 Car 、 Motorcycle 和 Bicycle 模型。这些模型将共享诸如 color 和 price 之类的字段，但每个模型都有独特的行为。它们也各自拥有自己的控制器。

class Vehicle < ApplicationRecord
end

class Car < Vehicle
end

class Motorcycle < Vehicle
end

所有模型使用一张表（vehicle），通过一个type字段来区分不同的类型。这样可以避免重复建表，又保留了扩展性。不同的类型，做各自特别的处理。

不过 STI 有个问题：随着业务复杂化，多个类型需要存储特定的数据，这些数据对有的类型有用，对有的类型无用，会导致原本的一张表中字段越来越多，很多字段对某些类型来说就是NULL值。

Delegated Types 委托类型

这正是为了解决 STI 的问题而出现的：

可能一开始使用单表继承很方便，但随着业务的复杂化，可能多个类型需要存储特定的数据，这些特定的数据，对有的类型有用，对有的类型无用，会导致原本的一张表中，字段越来越多，而又不是每个类型，都要使用的。那就可以把核心公共字段放在原始表上，然后创建各个类型具体字段到具体的表中。

# Schema: entries[ id, entryable_type, entryable_id, created_at, updated_at, created_by, updated_by ]
class Entry < ApplicationRecord
  delegated_type :entryable, types: %w[ Message Comment ], dependent: :destroy
end

module Entryable
  extend ActiveSupport::Concern

  included do
    has_one :entry, as: :entryable, touch: true
  end
end

# Schema: messages[ id, subject, body ]
class Message < ApplicationRecord
  include Entryable
end

# Schema: comments[ id, content ]
class Comment < ApplicationRecord
  include Entryable
end

数据创建时使用：

Entry.create! entryable: Message.new(subject: "hello!")

数据使用时：

比如我希望文本搜索 Entry 中的内容时，可以将命令委托到特定的类上

class Entry < ApplicationRecord
  delegated_type :entryable, types: %w[ Message Comment ], dependent: :destroy
  delegate :searchable_content, to: :leafable
end

class Message < ApplicationRecord
  include Entryable

  def searchable_content
    body
  end
end

class Comment < ApplicationRecord
  include Entryable

  def searchable_content
    content
  end
end

从业务场景看设计选择

通过一个实际的业务场景来理解这些设计模式的选择。

假设我们有一个报价单系统，报价单下包含多种服务，这些服务大致类似，但又有各自不同的订阅内容。

公共信息：订阅时长、原价格、实际价格、创建人、创建时间、更新人、更新时间、价格版本

特定信息：

A 服务需要：订阅数量
B 服务需要：订阅类型
C 服务可能还需要其他信息...

传统设计

# 报价单表
class Quotation < ApplicationRecord
  # 关联A服务
  has_many: :project_service
  # 关联B服务
  has_many: :bid_info
end

# A服务 存储：订阅服务多久，原价格，实际价格，创建人，创建时间，更新人，更新时间，价格版本，订阅数量
class ProjectService < ApplicationRecord
  belongs_to :quotation
end

# B服务 存储：订阅服务多久，原价格，实际价格，创建人，创建时间，更新人，更新时间，价格版本，订阅类型
class BidInfo < ApplicationRecord
  belongs_to :quotation
end

可以看到每个服务核心内容是一致的，但是又有一些各自的信息。假如说我再加一个新的服务，就需要再修改

# 报价单表
class Quotation < ApplicationRecord
  # 关联A服务
  has_many: :project_service
  # 关联B服务
  has_many: :bid_info
  # 关联C服务
  has_many: :market_service
end

# C服务
class MarketService < ApplicationRecord
  belongs_to :quotation
end

现在遇到两个场景：

我想查看一个报价单下有哪些订阅服务，并分页查看，怎么写？
我想统计报价单下某些类别的金额，怎么写？

统计可能稍好一些，大不了就是多查几个表。但分页获取怎么做呢？

按照委托模式设计的话，可以这样：

# 报价单表
class Quotation < ApplicationRecord
  has_many: :quotion_service
end

# 服务表
class Service < ApplicationRecord
  delegated_type :serviceable, types: %w[ ProjectService BidInfo ], dependent: :destroy
end

module Serviceable
  extend ActiveSupport::Concern

  included do
    has_one :service, as: :serviceable, touch: true
  end
end

class ProjectService < ApplicationRecord
  include Serviceable
end

class BidInfo < ApplicationRecord
  include Serviceable
end

这个方案虽然多了一张表，关系也更复杂，但带来的好处很明显：

所有服务的统计、分页、批处理都能直接从services表获取
新增服务类型只需要添加新的 Recordable 类型，不需要修改报价单模型
统一的管理接口，便于维护

WriteBook 源码查看

源码：https://once.com/writebook

class Book < ApplicationRecord
  has_many :leaves, dependent: :destroy
end

class Leaf < ApplicationRecord
  include Editable, Positionable, Searchable

  belongs_to :book, touch: true
  delegated_type :leafable, types: %w[ Page Section Picture ], dependent: :destroy
  delegate :searchable_content, to: :leafable

  scope :with_leafables, -> { includes(:leafable) }
end

class Page < ApplicationRecord
  include Leafable
end

class Section < ApplicationRecord
  include Leafable
end

class Picture < ApplicationRecord
  include Leafable
end

这里的设计很清晰：

Book是容器
Leaf是通用记录层（Recording）
Page、Section、Picture是具体内容（Recordable）

37Signals 的核心设计思想

回到 37Signals 文章提出的概念

Recording（记录外壳）

存储所有内容的公共属性：ID、创建时间、创建者、位置信息等。相当于给所有内容穿了一个统一的外套。

Recordable（记录内核）

存储特定类型的具体数据。文档有文档的数据结构，评论有评论的数据结构。

关键设计：Recordable 是不可变的。用户操作修改时，不是修改原来的 Recordable，而是拷贝并创建一条新的数据，同时创建一个 Event。

Event（事件）

记录操作历史，关联新旧版本 ID。历史版本查看实际上就是查看一系列 Event，回滚到特定版本只需要把相应的 Recordable 挂载到 Recording 上。

在 CMS 系统中往往有文档历史更新记录的查看功能，所以在设计上，Recordale 是不能修改的。如果用户操作修改，则拷贝并创建一条新的数据，和一个 Event。Event 关联两个版本 ID，Recordable 挂载到新的 Recording 上，历史版本查看，实际上就是一个个事件，如果要回滚文档到某个具体的版本，只需要把 Recordable 挂载到特定的 Recording 上。

树形结构设计：Self Joins 的应用

在 CMS 系统中，内容往往需要支持树形结构：文档可以包含子文档，评论可以有子评论。

37Signals 文章中还提到一个值得学习的点：通过自连接来替换关联关系。实际上就是 Recordable 本身有一个parent_id。

用 Confluence 举例，假设有这样的文档结构：

- A文档
  - B文档
    - C文档
      - 1评论
      - 2评论
    - D文件列表

看起来就像一个目录结构，文档、评论、文件列表可以自由地挂载到任意位置。其他服务也可以挂载。通过parent_id就可以做到：被挂载的服务无需知道以后会有什么挂载在自己下面，只要遵守规范，就能获得一致性处理。

这种设计的优雅之处在于：

Delegated Types负责处理内容的水平扩展（不同类型的内容）
Self Joins负责处理内容的垂直组织（树形结构）

总结

Delegated Types + Self Joins这种设计模式为构建复杂 CMS 系统提供了一个优雅的解决方案：

Delegated Types解决了“多种内容类型统一管理”的问题
Self Joins解决了“无限层级嵌套结构”的问题
不可变 Recordable + Event解决了“完整版本历史”的问题

这种架构的核心优势在于：将内容类型的变化与内容结构的变化解耦。当需要新增内容类型时，只需实现新的 Recordable；当需要调整组织结构时，只需调整parent_id关系。两者互不干扰，系统维护性和扩展性都得到了保证。

对于需要处理复杂内容关系、支持未来扩展的现代应用系统，这一模式提供了一个经过实践验证的优秀设计范式。

kamal 加速

qinsicheng — Wed, 03 Dec 2025 21:04:50 +0800

国内墙的原因，导致在使用 kamal 部署到服务器上慢的要死，最近折腾了一下，在不适用代理情况下，第一次部署在两分钟内，之后更新就在三十秒左右。

举例项目

脚手架生成的最基本项目

-> ruby -v
ruby 3.4.6(2025-09-16 revision dbd83256b1) +PRISM [x86_64-linux]

-> rails -v 
Rails 8.1.1

-> rails new demo --css tailwind -d postgresql

dockerfile syntax 卡住

# syntax=docker.m.daocloud.io/docker/dockerfile:1
# check=error=true

实际测试下来比较稳定，偶尔会卡住

dockerHub 登录一直卡住

我换成腾讯云 docker 个人仓库，我看免费有十个，个人完全够用了，需要提前绑定密码，账号就是腾讯云用户 Id

# Where you keep your container images.
registry:
  # Alternatives: hub.docker.com / registry.digitalocean.com / ghcr.io / ...
  server: "ccr.ccs.tencentyun.com"

  # Needed for authenticated registries.
  username: "xxxxxxx"

  # Always use an access token rather than real password when possible.
  password:
    - KAMAL_REGISTRY_PASSWORD

docker pull 卡主

镜像名使用毫秒镜像 - 告别蜗牛速度！国内专线拉取镜像！

FROM docker.1ms.run/ruby:$RUBY_VERSION-slim AS base

debain 卡主

# 换清华源
RUN sed -i 's|deb.debian.org|mirrors.tuna.tsinghua.edu.cn|g' /etc/apt/sources.list.d/debian.sources && \
  sed -i 's|security.debian.org|mirrors.tuna.tsinghua.edu.cn|g' /etc/apt/sources.list.d/debian.sources && \
  sed -i 's|http://|https://|g' /etc/apt/sources.list.d/debian.sources

bundle install 卡住

RUN gem sources --add https://gems.ruby-china.com/ --remove https://rubygems.org

另外把 gemfile 里的 source 也改了

source "https://gems.ruby-china.com/"

其他小问题

healthy check

# 检查一下是否正常
get "up" => "rails/health#show", as: :rails_health_check

数据库登录错误

我是先部署了一个 demo 服务，看成功了后。想着把我实际服务部署上去，结果数据库一直显示没有对应配置用户名，因为我在 deploy.yml 中数据库配置的一样，而之前部署的时候数据库应该是已经配置好了，我就把之前的那个实例删掉，重新部署，看正常了

kamal-proxy 显示已经有一个服务了

还是一样的，之前已经配置了一个服务，现在再配一个新的，又是一样的配置信息。参考：https://github.com/basecamp/kamal/issues/1147

总结

感觉 kamal2 已经很方便了，相比版本 1。个人开发者感觉可以很方便部署服务，建议没用过的，先看官网 DHH 演示，基本无坑，除了墙。

Dockerfile 最终版

# syntax=docker.m.daocloud.io/docker/dockerfile:1
# check=error=true

ARG RUBY_VERSION=3.4.6
FROM docker.1ms.run/ruby:$RUBY_VERSION-slim AS base

WORKDIR /rails

RUN sed -i 's|deb.debian.org|mirrors.tuna.tsinghua.edu.cn|g' /etc/apt/sources.list.d/debian.sources && \
  sed -i 's|security.debian.org|mirrors.tuna.tsinghua.edu.cn|g' /etc/apt/sources.list.d/debian.sources && \
  sed -i 's|http://|https://|g' /etc/apt/sources.list.d/debian.sources

RUN apt-get update -qq && \
  apt-get install --no-install-recommends -y curl libjemalloc2 libvips postgresql-client && \
  ln -s /usr/lib/$(uname -m)-linux-gnu/libjemalloc.so.2 /usr/local/lib/libjemalloc.so && \
  rm -rf /var/lib/apt/lists /var/cache/apt/archives

ENV RAILS_ENV="production" \
  BUNDLE_DEPLOYMENT="1" \
  BUNDLE_PATH="/usr/local/bundle" \
  BUNDLE_WITHOUT="development" \
  LD_PRELOAD="/usr/local/lib/libjemalloc.so"

FROM base AS build

RUN gem sources --add https://gems.ruby-china.com/ --remove https://rubygems.org 

RUN apt-get update -qq && \
  apt-get install --no-install-recommends -y build-essential git libpq-dev libyaml-dev pkg-config && \
  rm -rf /var/lib/apt/lists /var/cache/apt/archives

COPY Gemfile Gemfile.lock vendor ./

RUN bundle install && \
  rm -rf ~/.bundle/ "${BUNDLE_PATH}"/ruby/*/cache "${BUNDLE_PATH}"/ruby/*/bundler/gems/*/.git && \
  # -j 1 disable parallel compilation to avoid a QEMU bug: https://github.com/rails/bootsnap/issues/495
  bundle exec bootsnap precompile -j 1 --gemfile

COPY . .

RUN bundle exec bootsnap precompile -j 1 app/ lib/

RUN SECRET_KEY_BASE_DUMMY=1 ./bin/rails assets:precompile

西安还有在使用 Ruby 的公司吗？

qinsicheng — Wed, 22 Oct 2025 20:44:12 +0800

这两年整体环境都不太好，去成都参加活动的那次，感觉在用的公司也少，不过还是有一些，西安感觉都没有了。

omarchy 体验分享

qinsicheng — Sun, 14 Sep 2025 19:55:23 +0800

是什么？

地址：https://omarchy.org/

An opinionated Arch + Hyprland Setup by DHH

一个由 DHH 开源分享的一套初始化工具，基于 Arch Linux + Hyperland 平铺式桌面管理框架

更通俗的讲：开发环境不在使用 Windows，Mac，而是基于 Linux 系统

我们一想到 Linux 就能联想到黑乎乎啥也没有的命令行，或者是丑的不行的 Ubuntu 桌面。不过现在已经是 2025 年了，Linux 社区也在不断的发展，并有许多有趣新奇的玩意儿，但我们都知道 Linux 中很多东西都是自己配置的，你需要自己一步步添加或调整一些内容，而不像 window，mac 很多东西都是开箱即用的。而 Omarchy 就是一套快速设置的脚本，让你从安装系统到实际使用 Rails 开发，仅仅只需要五分钟时间。

怎么安装？

使用虚拟机

B 站有博主分享，我自己试了一下，安装好后没法启动，不知道什么没配好还是，后放弃

本机装系统

我最开始尝试在 Mac M2 上安装双系统，其中教程可以在 Omarchy 的 GitHub 上查看，但是不建议，因为 M2 架构的问题，很多组件是不支持的。虚拟机上也有很多坑，总之不建议

然后我在 ThinkPad X1 carbon gen9 上尝试安装，整体还是比较顺利的，不过还是有一些点需要注意：

使用一个 U 盘，烧制 Omarchy 提供的 ISO 文件，作为启动盘
Windows 启动时按 F12，然后进入执行系统安装
这时候会直接安装 arch linux，然后才安装 omarchy 和下载各种依赖的包，arch linux 好了后，就可以先退出了，因为国内墙的问题很多东西到后面也会报错，所以可以提前推出，去做一些调整，然后再继续安装
1. 修改 pacman 的源，iso 镜像中源配置文件中本身有中国的地址，但是你需要手动将那部分放到文件的开头
2. 安装 clash，因为后面要去 GitHub 中拉取项目，所以这里最好用 VPN，如果你能修改 host 访问那也行，我是不清楚怎么搞。启动代理后记得自己先验证一下是否能访问到
3. 在 ~/.auto... 执行这个脚本会继续安装之后网络情况好的话，应该就比较顺利安装了。

还有一点：我最开始想双系统运行，但是我执行 Omarchy 初始化任务时，发现只能选择整个磁盘，没办法安装好了后我的 window 启动不了了。Omarchy GitHub Discussion 中有讨论双系统怎么操作。可以自行尝试

使用体验

一进去系统，让我又重新体验到了第一次用 Vim 的感觉，怎么啥也没有啊，都不知道点哪里启动程序，哪里关闭程序，不过好在官方文档里面介绍的很详细，各种快捷键绑定来启动程序。

从这里的初体验也能体现出，这一套初始化设置对键盘优先爱好者很友善，也就是说尽可能通过键盘去控制行为，减少鼠标操作。DHH 也入坑 Nvim+LazyVim 了，所以一套下来各种快捷键，如果玩的好的，效率会很高吧。但是对于初次接触的使用者而言，痛苦面具带上，需要慢慢适应一下。我之前一直使用 Mac，所以命令行工具之类的常用，所以很快能习惯，但是对于 Window 用户，怕是很难上手。

Hyperland 大家应该之前都没听说过，我也是第一次接触，平铺式桌面？？？就是说窗口不会层层堆叠，而是有序的将这个屏幕拆分成块儿，这样能很直观的进行管理，不清楚的，可以看 B 站或者 DHH 的宣传视频

然后担心是否我们常用工具不能下载的问题，常见的编辑器我看都有，能用。微信的话我也下载能用。其他的暂时没测试。

安装前一直听说 Arch Linux 的滚挂问题，目前还没遇到，系统操作本身还是很丝滑的。就是很多快捷键记不住，也可以配置成自己常用的键。日常大部分操作我看都没问题，主要是操作习惯的问题。

总的来说研究这玩意儿，还是挺花时间的，确实有些东西需要自己配，比如输入法。建议自己想尝试的最好自己想清楚了，自己愿意投多少时间精力。我当时是被花里胡哨的介绍整上头了，如果想试了，也最好用虚拟机尝试，熟悉一下 Arch linux 之类的东西

注意事项：

不是所有电脑对 Arch Linux 都支持很好，最好去社区看看：https://bbs.archlinux.org/viewtopic.php?id=22816 ，你的电脑使用 Arch 是否有兼容问题

虚拟机安装，和双系统安装都可以去 GitHub 的 Discussion 中看看，很多人分享经验

Rails 层级设计演化（笔记）

qinsicheng — Sun, 13 Jul 2025 11:03:35 +0800

相关资料

最初的样子

我们都知道 rails 初始化项目，在层级拆分上只有两层

controller
model

controller 负责接收请求，model 负责实现存储，那业务逻辑在哪里实现？

可能为了 model 的干净，将业务逻辑写到 controller 中。也有可能为了代码复用，将业务逻辑写在 model 中。但不管选择哪种方式，如果不进行谨慎的管理，随着业务的不断迭代，你的 controller 或者 model 也会逐渐的臃肿，变得难以维护。自然而然的大家决定抽离出业务层，比如：Service，Command 等等

引入 Service/Command

比如我有一个报价单模型，我可能有类似的结构

# controller
class QuotationController < ApplicationController
end

# Command
class QuotationCommand
  def create
  end

  def list
  end

  def modify
  end

  def delete
  end
end

# model
class Quotation < ApplicationRecord
end

所有关于报价单的所有操作我都封装到 QuotationCommand 中，通过 Controller 调用 Command，最终调用 Model

可以看到我将增删改查的复杂业务逻辑统放入到 Command 中，假如我这时候再来一个新的需求比如我要导出一部分数据，我就简单的称为export吧，根据惯性我会将这个功能也实现到 QuotationCommand 中。一切自然而然，但是很明显我的这个类早已违反了单一功能原则（Single responsibility principle）,直到有一天这个巨无霸的 Command 也变得臃肿和难以维护，随便一个修改都可能是牵一发而动全身的。没办法我们再按照功能拆分一下吧。

看起来很漂亮，每个 Command 只负责自己的业务，保证职责单一，如果再出现新的业务只需要构建新的 Command 即可。

管理 Concern

我们目前的方案有什么问题呢？

比如ExportCommand导出功能是在列表查询的基础上做的，比如我有一个后台管理页面，它拥有一个列表搜索页，通过传递不同的筛选项，查询出不同的数据，使用ListCommand。现在我希望能将查询的数据导成 Excel，也就是ExportCommand负责的内容，毫无疑问我查询的功能已经有了，我只需要在ExportCommand中使用ListCommand即可，

# 紧耦合的Command示例
class ListCommand
  def initialize(params)
    @params = params
  end

  def call
    # 复杂的查询逻辑
    scope = User.all
    scope = scope.where(role: @params[:role]) if @params[:role]
    scope = scope.search(@params[:q]) if @params[:q]
    scope.order(created_at: :desc)
  end
end

class ExportCommand
  def initialize(params)
    @params = params
  end

  def call
    # 直接依赖ListCommand的实现
    users = ListCommand.new(@params).call

    # 导出逻辑
    CSV.generate do |csv|
      csv << %w[id name email]
      users.each { |u| csv << [u.id, u.name, u.email] }
    end
  end
end

那这就牵扯到一个问题：

Command 之前是否允许相互调用？

如果相互允许调用，势必引发耦合性，也就是ListCommand的修改势必会影响到ExportCommand, 或者说因为 ExportCommand 需要一些其他内容，反而去调整ListCommand的行为。

更好的方式应该将 Command 共用的业务逻辑，封装到一个独立的 Poro(Plain Old Ruby Object) 中，或者将业务封装到 Model 中，通过 Concern 来组织。

# 将查询逻辑提取到独立模块
module Search
  class UserSearch
    def initialize(scope = User.all)
      @scope = scope
    end

    def search(params)
      scope = @scope
      scope = filter_by_role(scope, params[:role]) if params[:role]
      scope = filter_by_keyword(scope, params[:q]) if params[:q]
      scope.order(created_at: :desc)
    end

    private

    def filter_by_role(scope, role)
      scope.where(role: role)
    end

    def filter_by_keyword(scope, keyword)
      scope.search(keyword) # 假设有search方法
    end
  end
end

# 解耦后的Command
class ListCommand
  def initialize(params)
    @params = params
  end

  def call
    Search::UserSearch.new.search(@params)
  end
end

class ExportCommand
  def initialize(params)
    @params = params
  end

  def call
    users = Search::UserSearch.new.search(@params)

    CSV.generate do |csv|
      csv << %w[id name email]
      users.each { |u| csv << [u.id, u.name, u.email] }
    end
  end
end

过度抽离 Command 本身可能会有什么问题？

我们引用一些评论

Now, the more common mistake is to give up too easily on fitting the behavior into an appropriate object, gradually slipping towards procedural programming.*

现在，更常见的错误是过于轻易地放弃将行为适配到适当的对象中，逐渐滑向过程编程。

Don’t lean too heavily toward modeling a domain concept as a Service. Do so only if the circumstances fit. If we aren’t careful, we might start to treat Services as our modeling “silver bullet.” Using Services overzealously will usually result in the negative consequences of creating an Anemic Domain Model, where all the domain logic resides in Services rather than mostly spread across Entities and Value Objects.

不要过于倾向于将领域概念建模为一个 Service。仅仅在情况适合时才这样做。如果我们不仔细地话，就可能会开始将 Services 视为建模的“银弹”。过度使用 Services 通常会导致创建贫血领域模型的负面后果，其中所有领域逻辑都驻留在 Services 中，而不是主要分布在实体和值对象中。

也就是说，如果我们如果不假思索的将所有的行为一股脑的塞进 Service 层级中，而不考虑内聚性，我们会渐渐走向面向过程编程，并且会导致模型贫血，即为携带数据的空壳。

所以我们再看看该怎么组织 Model？

假设我们有一个User模型，随着业务发展，它包含了用户认证、资料管理、权限检查、统计报表等多种功能，导致代码量过大。

# app/models/user.rb
class User < ApplicationRecord
  # 验证相关
  validates :email, presence: true, uniqueness: true
  validates :password, presence: true, length: { minimum: 8 }

  # 认证相关
  has_secure_password
  has_many :sessions

  def generate_auth_token
    # 生成认证token的逻辑
  end

  # 资料管理相关
  before_save :format_name
  has_one :profile

  def full_name
    "#{first_name} #{last_name}"
  end

  private def format_name
    self.first_name = first_name.capitalize
    self.last_name = last_name.capitalize
  end

  # 权限相关
  ROLES = %w[admin moderator user guest]

  def admin?
    role == 'admin'
  end

  def can_edit?(resource)
    admin? || resource.user == self
  end

  # 统计相关
  def self.active_users_count
    where(last_active_at: 1.week.ago..Time.current).count
  end

  def activity_score
    # 计算用户活跃度分数
  end

  # ... 更多方法 ...
end

里面混乱的组织着各种方法，假如我想找到某个功能，我需要一个个的看，哪些对我是有用的。这也称为Fat Model

但如果我们能用 Concern 进行合理化的拆分聚合，效果就会完全不同

拆分的目录结构：

app/
  models/
    concerns/
      user/
        authenticatable.rb
        profileable.rb
        roleable.rb
        reportable.rb

拆分后 Concern 模块

# app/models/concerns/user/authenticatable.rb
module User::Authenticatable
  extend ActiveSupport::Concern

  included do
    validates :email, presence: true, uniqueness: true
    validates :password, presence: true, length: { minimum: 8 }

    has_secure_password
    has_many :sessions
  end

  def generate_auth_token
    # 生成认证token的逻辑
  end
end

# app/models/concerns/user/profileable.rb
module User::Profileable
  extend ActiveSupport::Concern

  included do
    before_save :format_name
    has_one :profile
  end

  def full_name
    "#{first_name} #{last_name}"
  end

  private

  def format_name
    self.first_name = first_name.capitalize
    self.last_name = last_name.capitalize
  end
end

# app/models/concerns/user/roleable.rb
module User::Roleable
  extend ActiveSupport::Concern

  included do
    ROLES = %w[admin moderator user guest]
  end

  def admin?
    role == 'admin'
  end

  def can_edit?(resource)
    admin? || resource.user == self
  end
end

# app/models/concerns/user/reportable.rb
module User::Reportable
  extend ActiveSupport::Concern

  class_methods do
    def active_users_count
      where(last_active_at: 1.week.ago..Time.current).count
    end
  end

  def activity_score
    # 计算用户活跃度分数
  end
end

拆分后的 User 模型

# app/models/user.rb
class User < ApplicationRecord
  include User::Authenticatable
  include User::Profileable
  include User::Roleable
  include User::Reportable

  # 这里只保留模型特有的或无法分类的方法
end

这样拆分后，可能都不用构建特定的 Command，模型本身维护拆分良好的功能，来让 Controller 直接进行调用

但是这也要求团队内的成员遵守统一的规范和要求，并且具有良好的抽象化思想，这一点很难，最难的可能是如何给你的模块命名🤣，因为它直接反映了该模块儿的内涵。

面向资源思考

如何管理 Controller 或者说是路由，通过面向资源 (resource) 的方式。这是有些有趣的观点值得思考

引用

dhh 如何管理 Controller

Reconsider REST by 陈金洲

为什么需要它

传统的 Rails Controller 设计容易陷入"动作膨胀"的陷阱：

最初 Controller 只有默认的七个标准方法（index, show, new, edit, create, update, destory），对应代表的含义也很清晰明确，针对某一资源的查询，详情，新建，编辑，删除操作。但是随着业务的不断膨胀，Controller 内的非标准方法会越来越多，对于一个资源的操作也渐渐不再清晰。

比如说我有个一个 Topic(Model)，最初我只需要使用 CRUD 操作，七个标准方法能满足我的要求，后面我需要新加一个功能：喜欢（favorite）/取消喜欢（unfavorite），我可能直接这么写

# 传统方式 - 动作膨胀
class TopicsController < ApplicationController
  # 标准CRUD动作
  def index; end
  def show; end
  # ...

  # 自定义动作越来越多
  def favorite; end
  def unfavorite; end
  def publish; end
  def archive; end
  def recommend; end
  # ... 随着业务增长，这里会越来越长
end

这种设计会导致：

Controller 变得臃肿，难以维护
动作之间缺乏明确的组织原则
路由变得复杂且不一致

如何用资源思维重构？

重构前 - 传统方式

# routes.rb
resources :topics do
  member do
    post :favorite    # /topics/:id/favorite
    post :unfavorite # /topics/:id/unfavorite
  end
end

# controllers/topics_controller.rb
def favorite
  current_user.favorites.create(topic: @topic)
  redirect_to @topic, notice: "已收藏"
end

def unfavorite
  current_user.favorites.where(topic: @topic).destroy_all
  redirect_to @topic, notice: "已取消收藏"
end

重构后 - 资源方式

# routes.rb
resources :topics do
  resource :favorite, only: [:create, :destroy] # 单数资源
end

# controllers/favorites_controller.rb
class FavoritesController < ApplicationController
  before_action :set_topic

  def create
    current_user.favorites.create(topic: @topic)
    redirect_to @topic, notice: "已收藏"
  end

  def destroy
    current_user.favorites.where(topic: @topic).destroy_all
    redirect_to @topic, notice: "已取消收藏"
  end

  private
  def set_topic
    @topic = Topic.find(params[:topic_id])
  end
end

那如果按照资源的方式思考，是不是可以理解为

create favorite 请求喜欢这个行为 => 创建喜欢这个资源

destory favorite 请求取消喜欢这个行为 => 删除喜欢这个资源

两个 Controller 都保持了简单和整洁。需要注意这里的 Favorite 可能是一个数据库存储的表，也可能只是一个业务逻辑模型。

其实这个思维更打动我的是，在 Model 设计上我们可以利用类似的想法，Model 并不代表一定要和数据库交互，我们可以通过 ActiveModel 来直接使用 Rails 提供的便利，比如校验，回调等行为。通过这种方式将抽象复杂的业务逻辑，思考为一个个小的资源对象，并相互发送信息。

总结

简略总结几点：

鼓励构建rich domain model，不过为了避免Fat
1. 使用 Concern 来组织 Model 的代码
2. 将复杂功能委托到额外的对象系统（PORO）
3. ActiveRecord 和 Poro 视为一整套领域模型，而至于是否需要持久化，业务逻辑消费者并不在意
对于复杂的行为，可构建 Service/Command，但是需要谨慎和良好的设计（比较有趣的是：37signal很激进，觉得 Service 层都是没有必要的。）
利用面向资源的方式进行思考和建模

Lazyapi 通过终端管理你的 API，尽可能减少双手离开键盘的次数😂

qinsicheng — Sun, 30 Mar 2025 17:14:32 +0800

Lazyapi

是什么？

通过终端操作的 API 管理工具，该项目受到lazygit的鼓舞与启发，在某些简单的 API 对接和调用的场景上，希望能简单，快速，直观的处理 API，包含：对 API 的增删改查，请求，历史请求记录等操作。

示例

使用

Github 下载项目到本地，并执行 go build 生成可执行文件

对于数据的存储与读取，通过 Sqlite，Mac 用户会自动尝试在 ~/Library/Application Support/lazyapi 下生成存储文件

在操作上，你可以选择先创建一个 API，然后对其进行请求发送，目前仅支持 GET/POST 请求，请求参数要求为 json 格式，如果是 POST 请求会放到 body 中，如果是 Get 请求，会拼接在 url 后面，后续会增加更细致的功能。

某些临时请求上，可以直接通过快捷键g快速生成一个 Get 请求，p快速生成一个 Post 请求，当回车后会直接发送请求

注意

由于底层使用的gocui对中文支持的不好，所以当中文输入处理上会有问题，目前仅 fork 了一个版本，解决了输入和展示的问题，但是在光标移动和删除上，仍有问题，需要操作两次才行，例如删除时，删除键按两次，因为底层存储时中文字长占了两位。

在 Zed 编辑器中使用 Telescope 风格进行查询定位文件

qinsicheng — Sat, 23 Nov 2024 13:37:58 +0800

尝试过nvim的人应该都对 telescope 这种文件查询风格很喜欢，当在输入时能自动进行重新查询，并通过上下键进行翻阅

我目前在使用另一款编辑器 Zed，它目前内置的查询并无法做到类似的操作。但通过内置的 Terminal+fzf+bat+rg 也能做到类似的效果

git 链接：https://l.ruby-china.com/photo/qinsicheng/8bebe536-17bd-4da9-8569-f554773e9533.gif 帖子里看没有打开成功

fish function

function search_and_edit
    # 使用rg进行文件搜索，并使用fzf进行预览
    set -l selected_file (rg --column --hidden --line-number --no-heading --color=always --smart-case --glob '!**/.git/' --glob '!**/node_modules/' . | fzf --ansi --delimiter : --preview 'bat --style=numbers,changes,header --color=always --highlight-line {2} {1}' --preview-window 'up:60%:+{2}+3/3' --layout=reverse)

    # 如果选择了文件，提取文件路径、行号和列号
    if test -n "$selected_file"
        set -l file (echo $selected_file | cut -d':' -f1)
        set -l line (echo $selected_file | cut -d':' -f2)
        set -l col (echo $selected_file | cut -d':' -f3)

        # 使用Zed编辑器打开文件
        zed $file:$line:$col
    end
end

Zed keymap

{
    "context": "Editor && vim_mode == normal && !VimWaiting && !menu",
    "bindings": {
      "space f": [
        "workspace::SendKeystrokes",
        // 在页面上打开Terminal，执行 search_and_edit(我定义的脚本)，执行结束后关闭
        ": new center terminal enter search_and_edit space && space exit enter"
      ]
    }
  }

这样通过快捷键就能快速打开进行查询，同时可以看到这种方式主要依赖于 Terminal，所以应该能很容易改到其他编辑器中。

另外让人很兴奋的一点，通过这种方式也能将lazygit通过相同的方式进行使用，因为现在 zed 的 git 工具并不完善。

参考帖子：https://github.com/zed-industries/zed/issues/8279

window 使用 docker 开发 ruby 有坑吗？

qinsicheng — Tue, 10 Sep 2024 09:02:13 +0800

最近想换个新笔记本电脑，内存怎么着也得 16g，感觉苹果最基本的都是 9 千多，但是 window 能便宜小一半，不知道作为 Ruby 开发有没有坑，使用 docker 跑一个容器来运行。

然后就是有没有推荐的产品

如何在文本编辑器中快速找到变量定义位置

qinsicheng — Sat, 10 Aug 2024 15:16:04 +0800

之前一直使用 Webstorm 开发前端项目，因为它的常量定义查询真的太方便了。最近许可证要过期了，就在想如何在：Zed，Vscode，ST 这种文本编辑器中去做到类似效果。

比如我目前开发的 Vue 项目，感觉提供的 LSP 和文本编辑器自带的定义查询并不能很好的支持

比如查询：

this.$CONS.ORDER.MODIFY_TASK.MODIFY_TYPE
this.info('app_users_lists.validation', 'blocks.base_info.attributes')

目前我在使用正则表达式去查询，效果是有的，但感觉表达式复杂不好写。想看看各位大佬是怎么解决类似问题的。

SublimeText Web 开发在 2024

qinsicheng — Sun, 16 Jun 2024 15:47:26 +0800

随着 LSP 和 AI 发展的越来越完善，SublimeText 也可通过各类插件享受到新的福利，最近尝试使用 ST4(SublimeText4) 作为主开发工具，体验上还是很爽的，所以想给想尝试的朋友一些推荐。

为什么不用 Vscode，Jetbrains 等主流 IDE 工具？

老实讲我感觉 ST 概念比较简单，很快，按钮少😂，但是功能上 IDE 肯定更全面，对新人更友善。每个人有自己在意的点，如果喜欢原先的开发工具也完全 OK，目前我通过插件将 ST 改成了一个简略版 IDE，对一些基础操作：git,sql,terminal,代码补全,定义/引用查找等功能已经集成的不错了，觉得 ST 是大家选择开发工具中的一个可选项。

Zed也很不错，不过还不太完善，所以感觉还等一段时间，很期待。

Plugins

插件统一通过Package Control下载即可

主题

视觉效果看着舒服是很重要的一个点，我目前尝试了：ayn,Material插件，感觉都不错，不过可能有些小细节，希望能自定义一下，比如注释代码的颜色，侧边栏字体大小，滚动块儿样式等等。

可以通过PackageResourceViewer插件，快速定位到插件样式定义文件，然后去修改

Git

Git 插件
GitGutter 插件
Sublime Merge 软件

通过Git,GitGutter可以很方便在写代码时操作 Git，不过有时候遇到代码冲突，分支管理等操作还是不太方便，通过 Sublime Merge 可以无缝衔接增强。

命令行

Terminal
Terminus

可以通过绑定快捷键，快速打开命令行，但是我发现 ST 中的 Panel 默认只能打开一个 Shell。通过快捷键可以解决这个问题：

{
   "keys": [
      "alt+1"
   ],
   "command": "toggle_terminus_panel",
   "args": {
      "panel_name": "first-panel"
   },
},
{
   "keys": [
      "alt+2"
   ],
   "command": "toggle_terminus_panel",
   "args": {
      "panel_name": "second-panel"
   },
},

这样就可以通过快捷键，切换到不同的 shell 中了。

SQL

SQLTools 插件

操作 SQL 的瑞士军刀，真的超级好用，提供 SQL 编写字段，表等补全功能，不过由于项目中没有 sql 文件，每次创建删除又很麻烦，需要注意 ST 原生的宏记录，对于创建新文件页面无效，我通过Multicommand插件，来编写宏：

// query_file.sublime-macro
{
    "cmd": ["new_file", "untitled.sql"],
    "args": {"syntax": "SQL"},
    "flags": ["window"]
}

文件操作

AdvancedNewFile 快速创建文件
Quick File Creator 快速指定目录创建文件
SyncedSideBar ST 在文件切换时，侧边文件导航栏并不会定位到当前文件，通过该插件可以自动定位
Local History 记录本地代码修改记录

AI 代码补全

Codeium

配置简单，响应快速，智商还算在线，官网上说比 Copilot 强，个人免费。

LSP

"LSP"
"LSP-css"
"LSP-eslint",
"LSP-json",
"LSP-typescript",
"LSP-volar"

目前写 Ruby 用的 LSP 是solargraph,可以看文档自己去配置就好，sublime-lsp。再说一遍 LSP 真香！！！

配置同步

Sync Settings

就是说在笔记本上 ST 的配置，想同步到台式机上，就可以通过该插件将配置同步到：gist.github.com

这一套下来，就基本上差不多了，像前端开发也会用Emmet插件，不过最近发现在写 Vue 时，常量的定义查找，标签组件的定义查找，都没用，只能通过文件名搜索查看，感觉还是不太方便，目前仍在找解决方案。

可以看出 ST 仍有一些不便之处，所以就得视情况而定去选择工具。为了某些优势，能容纳其他的问题。

最近想学着写写插件，前辈们有推荐的学习方式吗。

编辑器的发展趋势？

qinsicheng — Fri, 08 Mar 2024 18:34:17 +0800

之前一直使用 Jetbrain 系列的产品进行开发，操作都很舒服。当仍有一些问题让人无奈

占内存，比如开发 Java 时，本地跑几个服务内存就快没了，直接卡死
启动速度慢

然后就使用 Vscode，但是发现在打开一些特别大的文件时，还是不太行

最后使用 SublimeText，速度惊人

Sublime Text 给我的感觉是简单纯粹，但看到插件库维护的越来越少，都转到 Vscode 时还是觉得有些伤感。Vscode 似乎现在是最受欢迎的了。

感觉汇总出四个方向：

简单，快速
插件化，简单或复杂由自己说的算
巨无霸式，一条龙服务
LSP

以前看黑客与画家时，作者提到一百年后的编程语言的设想，这很酷，但写代码还是得有编辑器吧，那未来的编辑器是什么样子啊？难道直接对 AI 说需求，生成机器码

编程语言学习与人文语言学习是否有共同之处

qinsicheng — Sun, 24 Dec 2023 20:57:45 +0800

突然在想学习英语，德语和学习 Go，Lua 有什么差别，同样是学习一门不同的语言？

但新学一门编程语言明显速度要快的多，我能想到的答案是，我们在不断的使用它，类似的如果我们只通过书本学习编程语言那大概率也无法学会。

当我们敲击代码，并执行时，如果有显著语法错误，就会立刻得到反馈，如果逻辑错误，则在运行时得到反馈。（相当于找个外国人免费聊天，且帮我纠正错误，想到了grammarly）这个工具
当遇到不懂的内容，我们通过 Google，Github，StackOverFlow，CSDN 等工具查看相应的文章，获得一个更广泛和具体的概念。（而当我不懂一个单词的意思时，我往往只会查看中文翻译和英文翻译）
人文语言中有大量的关键词，每个事物对象都有自己的名字，而不是由我们去命名，当然我们可以起别名😁(起外号不好),我们大量的时间都在记住这些名称上，我记着我学习 Java 的第一课是写一个输出 Hello Word 时。我很痛苦的要记住每个单词是怎么拼写的😭 简写是一个好办法：K8s = Kubernetes，LOL = Laugh Out Loud java public class HelloWorld { public static void main(String[] args) { System.out.println("Hello World"); } }
朋友对我说，想快速学一门编程语言，比如 Rust，就去做一个会话管理工具。至少做个有趣的东西出来，整个过程便不会太枯燥，那学习英语的话我要用它做什么呢？写英文博客？

大学毕业后除了看国外文章，就没咋学了，感觉词汇量还是原来那些，每次都是坚持没超过一个月

面向对象的演化过程和解决问题

qinsicheng — Sat, 23 Dec 2023 15:02:55 +0800

面向对象的演化过程和解决问题

前言：

相信大家对面向对象这个概念已经很熟悉了，如果你是使用 Java 入门编程的，一定会被大量灌输：类，继承，多态的概念，但我们真的理解它们吗？一切就好像自然而然，写代码不就应该是这样吗？但事实上这些概念，只是我们脑海中的一个毫无意义的符号，当我们写一个类时，我们只是按照被教导的方式编写。好比现在最多的 Web 开发，业务是用户的增删改查，我们想到用户会有：name,age,gender 属性。于是我们创建一个实体：

class User {
  String name;
  Integer age;
  Integer gender;
}

然后按部就班的写出 Mapper(或 Dao) 层，Service 层，Controller 层，这就是 MVC 结构，它是如此的好用，让我们编写简单业务时十分顺手。但是当业务逐渐复杂时，我们在 Service，Controller 层中添加了大量的外部依赖，各种依赖注入，大量重复的代码堆砌在各个角落，一个变量被各个函数引用修改，当出现问题时，我们不得不到各个函数中查看，到底哪里出了问题，面向对象中的概念已抛到脑后。而且很糟的一点是，好像除了 Web 开发，想写出其他程序，便不知道从何写起了。我们的脑袋还被框架禁锢住了。

渐渐地，我们知道了设计模式这玩意儿，听说有了它，便能化腐朽为神奇，不过打开书发现，基本上都是从面向对象讲起，为什么还是它？因为它是一切的基础，面向对象就是为了解决以往混乱编程所演化的思想。所以本文会列出面向对象的演化过程，各个阶段遇到的问题，已经是如何慢慢改进的。

最早我使用 Python 写爬虫程序，那里只有一个 py 文件，没有<类，继承，多态>。只有自上而下的变量，条件，循环，网页请求，正则匹配，然后输出到控制台。但问题也能被很好的解决了。

机器语言

计算机只可以解释用二进制数编写的机器语言。并且计算机不对机器语言检查，而是飞快的执行。二十世纪四十年代，还没有现在这么多通俗易懂的编程语言。程序员必须用机器语言编写，我们看看个简单的例子，这里只是简单的算术计算。

这玩意儿没人愿意看和写吧，致敬前辈们。😭

汇编语言

为了改善机器语言的编码方式，汇编语言出现了，它将无含义的机器语言用人类易懂的符号表达，我们再改写上面的代码

MOV AX, X
MOV DX, Y
ADD AX,DX
MOV Z, AX

这玩意儿大概猜一下，能看出 MOV 是信息传递，ADD 是加法运算吧，通过这种方式，编码方式变得轻松了许多，但逐个指定计算机的执行命令也很麻烦。

高级语言

随后的高级语言采用人类更容易理解的方式进行，改写上面的代码

Z=X+Y

可以看到程序的形式和数学计算公式非常相似，即使没有编程经验的人也能理解。

结构化编程

随着高级语言的出现，编程的效率和质量都在不断上升，再加上计算机的飞速发展和普及，人们对提高编程效率的需求从未止步，也就提出了各种新的思想和编程语言。

其中最受关注的是：结构化编程，核心思想是：为了编写正确运转的程序，采用简单易懂的结果是非常重要的。

而具体方式：

废除 GOTO 语句

在 Java 中我们都没听过 GOTO 语句，不过在 C 语音中还有，这是因为当年内存容量，硬件性能都很差，推崇哪怕减少一字节，或者一步也好，代码顺序执行混乱，导致维护性很差。

使用循序，选择，重复来表达逻辑

循序就是按顺序执行代码

选择就是条件判断，如 if,case

重复就是重复执行某个命令，如 for，while

这三种结构被称为三种基本结构，我们也可以看到现在的编程语言都遵循这样的结构。

提高子程序的独立性，强化维护性

我们都知道，如果一段代码经常重复出现，我们可以将它抽离为一个函数，进行统一调用，这样在未来修改时，也很方便。

而在当时为了强化程序的可维护性，还有另一种方法，就是提高子程序 (函数) 的独立性。

那该如何提高函数的独立性呢？

减少主程序与子程序共享信息，而多个子程序中共享的信息就是全局变量。所以就要尽可能减少全局变量。

为什么这么做呢？你想想这个变量谁的都能访问修改，出了问题我找谁啊！现在有了 IDE 开发工具，我们还算能方便点儿，但在以前的时候，编译先等着，获取执行结果再等着，再去成百上千个代码中查找问题就更费时间了。

为了解决这样的问题，人们设计了两种结构：局部变量，按值传递。

局部变量：在函数中使用的变量，函数执行开始创建，结束时消失。
按值传递：在传参时，不直接使用调用端引用的变量，而是复制值进行传递，这样即使函数内部进行了修改，也不会影响外界的变量。

这两种结构能将全局变量的使用控制到最小范围，减少子程序共享的信息，以此提高函数的独立性。

在结构化语言中最有名的就是 C 语言，它完全支持结构化编程的功能，并且能高效的操作内存，不过另一个特征就是：函数库，编程需要的功能不仅是语言规范提供，还有函数库，比如输出字符串 printf。这样就能不用修改编译器，也能增加新的功能

进化方向演化为重视可维护性和可重用性

我们来一总结编程语言的进化历史吧

分为两条线：

从机器语言->汇编语言->高级语言，编程语言发展的更符合人类语言的方式来描述计算机执行操作，代表作：FORTRAN，COBOL。但遗憾的是仍无法满足需求
接下来的结构化语言就需要改变方向，即提高可维护性，无 GOTO 编程和提高子程序独立性都是为了程序便于理解和修改。

程序的寿命也越来越长，老的代码要被一直维护，那能看的懂，并能进行修改，就很重要了。

没有解决的问题

全局变量问题
可重用性差问题

全局变量问题是指：虽然引入了局部变量和按值传递，但当我们要将计算结构保存下来时，局部变量在函数结束时消失，所以要将结果保存到函数外部，也就又变成全局变量了。

可重用性差是指：虽然使用函数库来重用，但随着需求越来越大，仅靠函数是不够的。

面向对象编程

OOP 的三种结构

这三种结构为：类 (封装)，多态，继承。也被称为 OOP 的三要素。

而在前面的结构化语言中我们没有解决的问题，就可以被这三种结构解决

OOP 具有不使用全局变量的结构
OOP 具有除公用子程序之外的可重用结构

需要注意虽然现在大部分语言都属于 OOP，但根据编程语言的设计不同，语法差异也会不同，比如：Java 和 Ruby，Java 中没有全局变量的概念，而 Ruby 中仍有保留，而且两个语言的差异也很大。

类

类的功能总结为：

汇总子程序和变量
隐藏类内部的子程序和变量
一个类可以创建多个实例

汇总

我们举个文件访问的例子，代码：

int fileName;
char readChar;

void openFile(String pathName) {省略};

void closeFile(){省略};

char readFile(){省略};

程序由子程序和全局变量构成，而如果使用面向对象的方式进行管理就变成：

class TextFileReader{
    int fileName;
    char readChar;

    void open(String pathName) {省略};

    void close(){省略};

    char read(){省略};
}

可以看到这里将子程序和全局变量都汇总到一个类里了，好像没什么区别，但是汇总本身就是有意义的，就好比将散乱的东西分门别类，这样当再去寻找时，就有个范围。而且通过类的汇总，我们可以将子函数的名称变得更简洁，并且避免了命名冲突的问题。当别的类也有：open, close, read 方法时，双方并不会影响。

隐藏

比如上面的代码，我们只希望类内部的方法能访问类中实例变量，外部不让动，这样就能解决全局变量的问题了

class TextFileReader{
    private int fileName;
    public void open() {};
    public void close() {};
    public char read() {};
    private void someMethod() {};
}

通过访问修饰符来控制变量与子函数的访问权限，可以选择公开或者隐藏。

创建多个实例

通过 C 语言也可以实现上面的汇总和隐藏功能，而创建多个实例则很难实现这种结构。比如上面的文件访问例子，如果只访问一个文件没有问题，那如果访问多个文件，并比较区别该怎么操作？

这里我们不需要再改成数组，来轮询访问，通过创建多个实例就可以解决这种问题。不过按照我们以前访问函数和变量的方式，当有多个实例时，该怎么区分哪个实例变量才是要处理的对象，用 OOP 的方式就得改为：实例名称 . 方法名(参数)，代码如下：

TextFileReader reader1 = new TextFileReader();
TextFileReader reader2 = new TextFileReader();

reader1.open("a.txt");
reader2.open("b.txt");

char ch1 = reader1.read();
char ch2 = reader2.read();

reader1.close();
reader2.close();

这里我们创建了两个实例，并分别处理不同的文件，而每个方法都会访问当前实例内的变量。这样在类定义的一端，就不用担心多个实例同时运行的情况了。

实例变量是限定访问范围的全局变量

实例变量的特性：

能被隐藏，其他类的方法无法访问到
实例创建后一直保存到内存中，直到不再需要

这样就既解决了全局变量都能访问，又解决了局部变量信息无法妥善保存的问题

多态

多态是创建公用主程序的结构，与公用子程序相对应，公用子程序将被调用端的逻辑汇总为一个逻辑，而多态则相反，统一了调用端的逻辑

说的简单点儿：我创建了一个公共函数 (公共子程序)，不管是谁调用这个函数，函数内不变。而多态是，不管被调用的东西内部怎么变，我都不用修改调用的代码。

我们用代码来说明一下：

class TextReader {
    void open() {};
    void close() {};
    char read() {};
}

我们创建一个公共的接口，或者说是规范，当后面读取不同东西时，统一走这里的逻辑就行

class NetworkReader extends TextReader {
    // 网络文件读取
    void open() {};
    void close() {};
    char read() {};
}

class TextFileReader extends TextReader {
    // 网络文件读取
    void open() {};
    void close() {};
    char read() {};
}

这里我们定义了网络文件读取和文件文件读取，当用户最初是使用网络文件读取时：

TextReader reader = new NetworkReader();
reader.open();
reader.read();

当想再换成文本文件读取时：

TextReader reader = new TextFileReader();  // 只有这里修改了，其他地方完全一样！！！

这样当需求变化时，只需要简单的调整，就能实现另外一套完全不同的操作

继承

继承将类的共同部分汇总到其他类中的结构。

需要注意声明继承也就声明使用多态，因此在声明继承的子类中，为了统一方法调用，继承的方法参数和返回值类型必须与超类一致。

这里可以引申出：里氏替换原则：派生类（子类）对象可以在程序中代替其基类（超类）对象。

通过这一原则，才可以实现对扩展开放，多修改关闭，当子类对父类方法进行扩展时，保证程序的兼容性，降低代码出错的可能。

上面我们介绍了 OOP 的三大要素：类，多态，继承。不过例如 Java，Ruby，Python 等比较新的编程语言提供了更先进的结构，典型的有：包，异常，垃圾回收。设计这种结构就是为了促进重用，减少错误等。我们简单介绍一下

包

说到了具有汇总功能的类结构，而包是进一步对类的汇总的结构。

不同于类，包不能定义方法和变量，但通过这种结构，也就是类似文件系统中的目录，我们可以更加轻松的组织管理。我们假设如果没有包，所有的类文件都放到根目录，一方面是命名冲突，一方面是要在大量的类中，找到具体那个，也很麻烦。

异常

在我们代码运行时，总会有各种问题出现，数组越界，空指针等等。

在没有异常时，我们可以通过返回码来表示系统运行的不同状态，比如返回 200 表示正常，返回 -200 表示数组越界，返回 -300 表示空指针，但这有一个问题，调用端需要根据不同的状态处理不同的情况，大量的 if-else，异常处理混杂在代码中间。而且当调用端无法处理某种情况时，就必须将异常值再返回到上层，同样的异常处理在上层再写一遍。

问题：

必须在应用程序中执行所有的错误码判断
错误码的判断逻辑在多个子程序中连锁

public void doSomething() {
    Integer result = reader.read();
    if (result == null) {
        // 对应处理
    } else if (result == -200) {
        // 对应处理
    } else if (result == -300) {
        // 对应处理
    } else if (result == -400) {
        // 对应处理
    } else {
        // 正常逻辑
    }
}

异常就是用于解决以上问题的结构。

异常结构会在方法中声明可能返回的特殊错误，这种特殊错误的返回方式就是异常，其语法不同于子程序的返回值。

在声明异常的方法的调用端，如果编写异常处理逻辑不正确，程序会发生错误，这就解决了第一个问题。

public void doSomething() {
    try {
        Integer result = reader.read();
        // 正常逻辑
    } catch(NullError e) {
        // 执行
    } catch(OutOfIndexError e) {
        // 执行
    }
}

有时在发生错误时不执行特殊处理，而是将错误传递给上位方法，这种情况只需要在方法中声明异常，而不必编写错误处理，就解决了第二个问题。

public void doSomething() throws NullError,OutOfIndexError {
    // 正常逻辑
}

需要注意 Java 这种静态类型语言会发生编译错误提醒，而 Ruby 这种动态语言则是在运行时错误提醒。

垃圾回收

在说到创建多个实例时，只谈到了如何创建，但没有说如何删除，每当创建一个实例，就会为之分配内存，如果不能及时清理就会导致 OOM(内存溢出)

在 C 和 C++ 等之前的语言，需要显示的删除不需要的内存区域，但是就怕误删操作，或者忘了删了，需要一种机制能自动化管理，

在Java，C#等很多OOP中采用由系统自动进行删除实例的处理结构，也就是垃圾回收。这里有很多策略，比如引用计数法，标记清除法，标记整理法，推荐去看：深入理解Java虚拟机

OOP 与设计模式

从历史上来说，先利用 OOP 创建可重用架构群，然后提取可重用构建群中的设计思想，形成设计模式，最后再利用设计模式，进一步创建可重用架构群。

设计模式原则

原则是一种抽象的概念，最初接触时很难深入理解，所以往往大家会着重于学习具体的设计模式，看代码是如何组织的。但当多观察几种设计模式后，就会发现一些通用点和策略

对修改关闭对扩展开放。开放闭合原则
高层模块不应该依赖于底层模块，两者都应该依赖抽象。依赖反转原则
尽量使用组合和聚合关系，而不是继承关系。合成复用原则

等等，而这些就是设计模式原则，我们这里侧重于从 OOP 的发展历程角度来看待这些设计模式原则，看思想上是否是一致的。

单一职责原则

定义：就一个类而言，应该仅有一个引起它变化的原因

我们之前提到 OOP 结构解决的一个问题就是可重用性结构。

而 OOP 提供的类结构在设计时，就是为了将不同职责的变量和函数进行划分，这样在进行维护时，只需要找到特定的类即可。如果一个类承担的职责过多，这些职责就会耦合，当职责发证变化时，其他职责也会发生影响，这就导致的设计的脆弱性。

就好像赤壁之战中，铁索练船，一个船着火了，其他的船也被影响。

开放 - 封闭原则

定义： 软件实体 (类，模块，函数等) 应该可以扩展，但是不可修改。

有一句经典名言：拥抱变化。随着业务需求的变化，我们不得不对代码进行调整，但如果直接上手修改原有代码，在没有完整测试的情况下，很容易引入 Bug。

而 OOP 提供的多态，继承结构就是为了解决这一问题，通过实现接口类或继承重写某些方法。这样在不修改原有功能的前提下，扩展新的功能。而通过多态，让客户端察觉不到发生的变化。

依赖倒转原则

定义：

高层模块不应该依赖底层模块，二者都应该依赖抽象
抽象不应该依赖细节，细节应该依赖抽象

我们观察一下 SpringBoot 在写 MVC 结构时，Service 层是有一个接口层和实现层，Mapper 层是有一个接口层和实现层。为什么需要这层接口呢？

这里一方面的原因是 AOP 所需的动态代理，而另一方面是 SpringBoot 这样设计是基于依赖反转原则的，当 Controller 层调用 Service 层时，指向的是 Service 接口，但具体的实现是通过 ServiceImpl 来做。这样双方都不需要知道具体的实现，Service 层调用 Mapper 层也是同理的。假如我们原先是使用 Mysql 数据库，现在使用 Oracle 数据库，那我们只需要新增一个 MapperImpleByOracle 实现类即可。通过 Spring 容器的依赖注入，将代码修改范围降到最低。

里氏替换原则

定义：子类型必须能替换他们的父类型

只有当子类可以替换掉父类，软件单位的功能不受到影响时，父类才能真正被复用，而子类也能在父类的基础上增加新的行为，而这一点才使得开放 - 封闭原则称为可能。

而里氏替换原则是在 OOP 多态的基础上提出的，是对多态的一种规范。

迪米特法则 (最少知识原则)

定义：如果两个类不必彼此直接通信，那么这两个类就不应该发生直接的相互作用，如果其中一个类需要调用另一个类的某个一个方法的话，可以通过第三者转发调用。

OOP 中提供的类结构一个特点就是隐藏 (封装)，每个类都应当尽量降低成员的访问权限。

这里举一个例子：租客，房东，中介。当去掉中介这层当然没问题，但房东与租客直接沟通的话，成本大，且一旦一方失信或者违约，再去调整双方都要花费更多的时间，而通过引入中介，双方只需要和中介对接，如果出现问题，由中介进行调整，双方的损失也就降低了。

总结

通过面相对象的演化过程，我们能看到面向对象不是全新的概念，而是以之前技术为基础，对缺点进行补充，其中引入了新的结构来解决问题。

本文学习自：

如何在 application.js 中使用 Rails 的配置变量信息

qinsicheng — Sat, 04 Nov 2023 18:23:42 +0800

背景描述

我在使用 Rails7 开发，其中通过config/settings.yml来做一些配置，通过gem: 'config'管理，现在希望在 js 文件中，也能获取使用这部分内容，但发现 .js.erb 好像不再支持，这里该怎么操作，还是说通过 js 来读取配置文件？

菜鸡的单词卡片

qinsicheng — Sun, 01 Oct 2023 19:00:27 +0800

地址：GitHub

线上 demo(加载有点儿慢)：http://121.37.186.74:4000/ Ai 生成部分禁用了

项目介绍

功能：英译词典，相比中文解释，英译解释会费脑一点儿，但你可以通过描述来学习一个单词，而不是一个中文符号来记忆。数据爬虫于朗文但会更简洁，清晰一些。只提供必要的信息：拼写 (点击跳转到朗文，查看更详细信息)，音标 (点击可直接播放声音，没必要整个喇叭)，解释，例句。并通过 openAi，将你搜索过的单词，生成一个段落文章，来学习如何在实际中应用这些词汇，可以选择再次生成，或者退出。熟悉的单词也可通过 ✔️ 删除。

项目待修正

使用 stream 来流式输出内容，现在这个太慢了
是否加入单词本的概念，当你搜索一个单词时，代表该单词肯定是不太熟悉，也就是默认应该复习
是否引入记忆曲线，来定期回顾，而不是直接删除单词
需要加入分页

项目使用 Ruby On Rails 全栈做的，参考了我之前翻译的教程，不过模型简化的多，只有一个，更多的功夫用在样式实现和 Stimulus 使用，我感觉操作看着还是挺丝滑的

页面展示

无法监听到 turbo:render 事件

qinsicheng — Sun, 24 Sep 2023 14:07:49 +0800

这是我的 Turbo Stream 操作：

<%= turbo_stream.prepend "words", @word %>

我希望通过监听turbo:render事件，在此从 DOM 来获取新加入的 @word 渲染的节点，并对其样式进行修改。但是发现监听不到该事件，但是页面上已经成功显示了新加的数据

我目前可以监听到的事件有：

turbo:load
turbo:before-cache
before-stream-render

有什么办法能在 Turbo Stream 返回数据并修改 dom 后，进行某些操作？

我在 app/javascript/application.js 中写的：

document.addEventListener("turbo:render", function (event) {
    console.log("turbo:render")
});

如何进行测试驱动开发

qinsicheng — Sun, 10 Sep 2023 16:56:11 +0800

前言

最近在读《匠艺整洁之道 - 程序员的职业修养》这本书，作者鲍勃大叔开篇就用了大量的示例来讨论与演示为什么需要和如何操作测试驱动开发。我是之前写过测试，但从不知道测试如何驱动开发，大部分情况下也只是先写生产代码，写好后再测试，看看是否能调通，再修改代码中隐藏的问题。

而测试驱动开发会扭转这种思维方式，是先写测试，再写对应的生产代码。这一开始让人会觉得很奇怪，感觉并且很麻烦，但当你尝试一下，就会发现这事儿挺有趣，且神奇。

温馨提示：Clean Craftsmanship: Disciplines, Standards, and Ethics (Companion Videos)，这个是该书示例操作的视频说明，非常非常非常有用！！！ 第一篇是讲述如何通过测试驱动开发来写一个栈结构。我严重怀疑大叔是不是一边写代码一边喝啤酒。整个过程伴随大叔魔性的笑声和宛如魔法般的操作，就好像他在不停调戏编译器。你会通过这个视频感受到如何从零开始，进行测试驱动开发。下面将讲讲一些基础知识。

TDD 纪律

创建测试集，方便重构，并且其可信程度达到系统可部署的水平，也就是说测试集通过，系统就可以部署。
1. 我不知道有多少人像我一样，由于老系统没有测试，导致每次上线都很害怕，担心修改引入新的问题。
创建足够解耦，可测试，可重构的代码
创建极短的反馈循环周期
创建相互解耦的测试代码和生产代码

上面的纪律需要下面展示的法则作为基础，如果没有一些技巧和知识就很难遵守这些法则。

TDD 三法则

第一法则：在编写因为缺少生产代码而必然会失败的测试之前，绝不编写生产代码 第二法则：只写刚好导致失败或者通不过编译的测试，编写生产代码来解决失败的问题 第三法则: 只写刚好能解决当前测试失败问题的生产代码。测试通过后，立即写其他测试代码整个过程看起来好像是：

写一行测试代码，无法通过编译
写一行生产代码，编译成功
写另一行测试代码，无法通过编译
再写生产代码，编译成功
再写测试代码，编译能成功，但断言失败
写一两行生产代码，满足断言

如此循环，贯穿始终

遵守上述法则后，有以下好处

提高效率，减少调试的时间
将产出一套低层次文档
好玩
将产出一套测试集，让你有信息部署系统
将创建较少耦合的代码

简单示例

栈

这里建议先看我上面提供的链接，作者是用 Java 写的，我这里用 Ruby(核心思想是一致的)

require 'minitest/autorun'
class StackTest < Minitest::Test
  def test_nothing

  end
end

这里我们一开始写一个什么都不做的测试，然后保证这个测试通过，这至少能说明你的环境没问题

规则 1：先编写测试，逼着自己写将要写的代码

我们知道我们需要一个栈

# stack_test.rb
require 'minitest/autorun'
class StackTest < Minitest::Test
  # ...

  def test_canCreateStack
    stack = Stack.new
  end
end

这里的测试一定会失败，因为现在根本没有Stack这个类结构，所以我们写两行生产代码来通过测试

# stack.rb
class Stack

end

这次我们在stack_test.rb引入一下，就可以通过测试了。

规则 2：让测试失败，让测试通过，清理代码

这时候我们发现我们还没有断言行为呢，比如当刚创建一个栈时，这个栈应该是空的。

# stack_test.rb

require 'minitest/autorun'
require_relative 'stack'
class StackTest < Minitest::Test
  def test_nothing
  end

  def test_canCreateStack
    stack = Stack.new
    assert(stack.isEmpty?)
  end
end
# => 报错：NoMethodError: undefined method `isEmpty?'

我们迅速补上生产代码，来解决这个问题

# stack.rb

class Stack
  def isEmpty?
    false 
  end
end

这样改后，方法可以找到了，但断言失败了，这里我们是故意的，为什么这么做呢？第一法则：测试必须失败，为啥呢？因为当测试应该失败时，我们就能看到它失败，我们测试了自己的测试。当我们将上面的方法返回 true 时，就能测试另一半了。

# stack.rb

class Stack
  def isEmpty?
    true 
  end
end

这时候执行测试，测试通过，万事大吉，你一定会骂这不是作弊吗，但等等，至少我们只用几秒就能测出该通过时通过，该失败时失败。

下一个要测的是，栈需要能 push 吧

# stack_test.rb

require 'minitest/autorun'
require_relative 'stack'
class StackTest < Minitest::Test
  # ...

  def test_canPush
    stack = Stack.new
    stack.push(0)
  end
end

这里会报错，因为找不到方法，我们就跟着改改生产代码

# stack.rb

class Stack
  def isEmpty?
    true
  end

  def push(ele)
  end
end

执行测试，测试通过，但这里我们没有断言啊，那既然 push 了，栈就不应为空吧

require 'minitest/autorun'
require_relative 'stack'
class StackTest < Minitest::Test
  # ...

  def test_canPush
    stack = Stack.new
    stack.push(0)
    refute(stack.isEmpty?)
  end
end

执行测试，断言失败，因为我们返回的一直是 true，那改改代码吧

class Stack
  attr_accessor :empty

  def initialize
    @empty = true
  end

  def isEmpty?
    empty
  end

  def push(ele)
    @empty = false
  end
end

我们抽离出一个实例变量来保存是否为空，并在 push 后直接暴力设置为 false。这时候测试又能通过了我们发现没写一个测试方法，都要创建一个栈，太麻烦了，于是我们重构一下，使用setup方法

require 'minitest/autorun'
require_relative 'stack'

class StackTest < Minitest::Test
  def setup
    @stack = Stack.new
  end

  def test_nothing
  end

  def test_canCreateStack
    assert(@stack.isEmpty?)
  end

  def test_canPush
    @stack.push(0)
    refute(@stack.isEmpty?)
  end
end

测试依然能通过，不过 canPush 这个测试名不太好，我们改改（test_操作_结果）

def test_afterOnePush_isEmpty
    @stack.push(0)
    refute(@stack.isEmpty?)
end

当然测试还是能通过

这时候我们测试，栈 push 一次，也能 pop 一次吧，并且这时候栈应该为空

def test_afterOnePushAndOnePop_isEmpty
    @stack.push(0)
    @stack.pop
    assert(@stack.isEmpty?)
end

测试失败，因为没有这个方法

class Stack
  # ...

  def pop
    @empty = true
  end
end

现在测试又通过了，现在我们测试两次 push 之后，栈的尺寸应该是 2

def test_afterTwoPushs_sizeIsTwo
    @stack.push(0)
    @stack.push(0)
    assert_equal(2,@stack.size)
end

测试失败，因为没有这个方法，我们修改生产代码

class Stack
  attr_accessor :empty,:size

  def initialize
    @empty = true
    @size = 0
  end

  def isEmpty?
    empty
  end

  def push(ele)
    @size += 1
    @empty = false
  end

  def pop
    @empty = true
  end
end

我们定义 size 实例变量来保存状态，并在每次 push 时，size+1，这样断言通过。为了测试完整，我们再加一个测试

def test_afterOnePush_isNotEmpty
    @stack.push(0)
    refute(@stack.isEmpty?)
    assert_equal(1,@stack.size)
end

测试通过。回到第一法则，如果对空栈执行 pop 操作，应该会有个异常吧

def test_poppingEmptyStack_raisesUnderflow
    assert_raises do
      @stack.pop
    end
end

测试失败，我们还没定义这个异常类

class Underflow < StandardError
end

断言失败，我们再修改生产代码

require_relative 'underflow'
class Stack
  # ...

  def pop
    raise Underflow if isEmpty?
    @empty = true
  end
end

测试通过，再测试：当栈 push 一个数据时，也应该 pop 出相同的数据吧

def test_afterPushingX_willPopX
    @stack.push(1)
    assert_equal(1,@stack.pop)
end

测试失败，调整生产代码，我们加一个实例变量保存信息

require_relative 'underflow'
class Stack
  attr_accessor :empty,:size,:element

  def initialize
    @empty = true
    @size = 0
  end

  def isEmpty?
    empty
  end

  def push(ele)
    @size += 1
    @empty = false
    @element = ele
  end

  def pop
    raise Underflow if isEmpty?
    @empty = true
    @element
  end
end

测试通过，已经写了这么多代码，你看的都崩溃了，觉得直接写一个栈不就完了嘛

规则 3：别挖金子

在最开始尝试 TDD 时，你会急于解决较难或有趣的问题，你可能先写 FILO 行为，这个就是挖金子，我们有意避免测试与栈行为有关的东西，专注与周边行为。例如栈是否为空或栈大小。为什么避免挖金子，因为如果过早挖金子，可能忽略周边所有细节。现在我们根据第一法子，编写 FILO 测试

def test_afterPushingXAndY_willPopYThenX
    @stack.push(1)
    @stack.push(2)
    assert_equal(2,@stack.pop)
    assert_equal(1,@stack.pop)
  end

测试失败，我们发现抛出了Underflow,我们修改一下isEmpty?方法

require_relative 'underflow'
class Stack
  # ...

  def isEmpty?
    size == 0
  end
end

测试失败，test_afterOnePushAndOnePop_isEmpty这个测试中报错，好吧，我们在 pop 时没有 size-1

require_relative 'underflow'
class Stack
  # ...

  def pop
    raise Underflow if isEmpty?
    @size -= 1
    @empty = true
    @element
  end
end

就剩下最后一个断言失败了，FILO 行为，我们开始修改

require_relative 'underflow'
class Stack
  attr_accessor :empty,:size,:elements

  def initialize
    @empty = true
    @size = 0
    @elements = []
  end

  def isEmpty?
    size == 0
  end

  def push(ele)
    @size += 1
    @empty = false
    @elements << ele
  end

  def pop
    raise Underflow if isEmpty?
    ele = @elements[size-1]
    @size -= 1
    @empty = true
    ele
  end
end

测试全部通过，我们已经完成了一个栈的基础行为啦，你会发现一个栈在我们不断测试中渐渐成型，虽然现在并不完善，但我们已经能感受到测试驱动开发的整个过程了。

也许你可以花点儿时间，利用测试驱动开发自己写一个队列结构。

类变量与实例变量中遇到的问题

qinsicheng — Tue, 29 Aug 2023 21:58:53 +0800

当我想实现一个 (暂不考虑并发性) 单例模式的类时：

class Singleton
  private_class_method :new,:dup,:clone
  def self.instance
    @@single ||= new
  end
end

这时候我再用两个类去继承

class Config < Singleton
end
class Database < Singleton
end
p Config.instance        # => #<Config:0x0000000102a9eef0>
p Database.instance      # => #<Config:0x0000000102a9eef0>
p Config.instance.equal? Database.instance  # => true

当我执行两个继承类各自的.instance方法时，返回了同一个对象，这里我的理解是：

当执行Config.instance时，找的Singleton.instance并首次初始化类变量@@single，这里的类变量归属Singleton，而@@single是Config的一个实例。
当执行Database.instance时，也执行到了Singleton.instance，由于@@single已经被赋值了，所以返回。

但这里我希望的是Config.instance和Database.instance各自返回的是各自的实例，所以将@@single改为@single,最终结果确实没问题：

class Singleton
  private_class_method :new,:dup,:clone
  def self.instance
    @single ||= new
  end
end
class Config < Singleton
end
class Database < Singleton
end
p Config.instance          # => #<Config:0x0000000100c8d5b0>
p Database.instance        # => #<Database:0x0000000100c8cae8>
p Config.instance.equal? Database.instance  # => false

但是我搞不明白，为什么变为实例变量@single时，结果发生了变化，@single是Singleton这个对象的实例变量，而这个Singleton这个类对象应该是唯一的，但结果是不同的？想请教一下

qinsicheng (秦晨)

show history for selection lines in Zed

效果展示：

Fish 代码

Zed 配置

西安垚海 有大佬在里面吗？求问怎么样

利用 Delegated Types 与 Self Joins 设计高扩展性系统

基础模型关联

高级模型关联

Polymorphic Associations

Self Joins

Single Table Inheritance 单表继承

Delegated Types 委托类型

从业务场景看设计选择

传统设计

WriteBook 源码查看

37Signals 的核心设计思想

Recording（记录外壳）

Recordable（记录内核）

Event（事件）

树形结构设计：Self Joins 的应用

总结

kamal 加速

举例项目

dockerfile syntax 卡住

docker login 卡住

docker pull 卡主

debain 卡主

bundle install 卡住

其他小问题

healthy check

数据库登录错误

kamal-proxy 显示已经有一个服务了

总结

西安还有在使用 Ruby 的公司吗？

omarchy 体验分享

是什么？

怎么安装？

使用虚拟机

本机装系统

使用体验

注意事项：

Rails 层级设计演化（笔记）

最初的样子

引入 Service/Command

管理 Concern

拆分的目录结构：

拆分后 Concern 模块

拆分后的 User 模型

面向资源思考

为什么需要它

如何用资源思维重构？

重构前 - 传统方式

重构后 - 资源方式

总结

Lazyapi 通过终端管理你的 API，尽可能减少双手离开键盘的次数😂

Lazyapi

是什么？

示例

使用

注意

在 Zed 编辑器中使用 Telescope 风格进行查询定位文件

window 使用 docker 开发 ruby 有坑吗？

如何在文本编辑器中快速找到变量定义位置

SublimeText Web 开发在 2024

Plugins

编辑器的发展趋势？

编程语言学习与人文语言学习是否有共同之处

面向对象的演化过程和解决问题

面向对象的演化过程和解决问题

机器语言

汇编语言

高级语言

结构化编程

提高子程序的独立性，强化维护性

进化方向演化为重视可维护性和可重用性

没有解决的问题

面向对象编程

OOP 的三种结构

类

西安垚海有大佬在里面吗？求问怎么样