AixCoder (hongnian.liu)

Ruby 小白，做了个女性友好的诗歌 web app

AixCoder — Mon, 23 Mar 2026 14:45:29 +0800

📱：https://pomes.petercat.life/

起初的想法

去年冬天的时候就想着设计一款女性友好的诗歌 app

落地实现

2026 年开春了，借着当下 AI 编程的浪潮

选择用 Ruby 技术展现出这么个诗歌网站

这么个诗歌的小屋，用到的不过是那一点点技术几行 Ruby 代码，一个 SQLite3，再加上让文字呼吸顺畅的 CSS 间距。

在古法编程的时代来看一个小白要做出一个 app 并部署上线，要学习比较长时间的如今来看这么个 app 并没有什么傲人的地方，门槛也比较低

但是有的时候也常常想，如果更多女性来学这一点点技，多一些这样的港湾也蛮好

ps：想问问群里的一些深耕 Ruby 领域多年的“老员工”

Ruby 在国内的就业市场相比几年前下滑？

几年前就听说 Ruby 在国内用人招人不好招 😂

不过呢，学习 Ruby 倒不是说一味的奔着找工作去的

目前以兴趣在驱动着学习，能够把自己的一些想法借助 AI coding 落地（以兴趣为主）

给旧电脑整容，配置好干净的开发环境

AixCoder — Tue, 10 Feb 2026 20:41:02 +0800

物尽其用

十几年前的苹果💻还能用

已经配置了很清爽的开发环境

稳定版 Ruby 3.3.10
Rails 7.2.3

对于我这个新手来说感觉良好呢

虽然有了 M 芯片的电脑但是感觉这老电脑用来外出学习也够用了

得感谢大模型 gemini3 生产的前端代码利用率极高

用来学学 web app 开发效率很高呢

Ruby 新手，准备买点纸质书，大佬们看看这个清单是否合理。

AixCoder — Fri, 16 Jan 2026 12:44:52 +0800

大家好目前 Ruby 新手阶段已经开发了轻量级 web app，部署到了云服务器上，有一部分代码是 AI 生成的，想进一步了解 web app 的开发。

从官网https://www.ruby-lang.org/zh_cn/documentation/ 了解到了一些初学者入门的建议。

《Why’s (Poignant) Guide to Ruby》这本非常有趣的书

《Learn to Program》非常棒的小教程

除了上面的两本入门的电子书，想购入一点纸质书来学习，达到边学边练习。

计划购入《Rails 5 敏捷开发》这本书虽然技术方案老旧了，现在的学习和开发环境是 Mac+rails7.2.3+Ruby3.x AI 提示：可以学习书里介绍的 MVC 思想

AI 时代的好处就是不用死记 Ruby 的语法了，希望群里拥有成熟商业项目开发经验的靓仔们推荐一些书单，让新手学习的过程中有些路径可寻

Ruby Girl-web 项目传统部署流程分享，自学 web app 开发并已经上线💐

AixCoder — Wed, 10 Dec 2025 14:11:11 +0800

Ubuntu 25.10 上部署 Rails 应用：从零到生产环境

概述

本文介绍在 Ubuntu 25.10 上使用 sqlite3 + Puma + Nginx 部署 Rails 应用的完整流程。本文以学习为目的，不使用现代化的自动部署工具，而是直接在 Linux 宿主机上从零搭建生产环境。

这种方式稳定可靠，足以应对多年的使用需求。尽管当前 AI 工具辅助开发已成为常态，但亲自动手实践仍是掌握技能的关键。

####本地开发环境

操作系统: macOS
Ruby 版本: 3.2.9
Rails 版本: 7.2.3

参考文章: Ruby China 上的相关教程

由于原文章发布时间较早，本文结合当前技术环境优化了部署流程

前言

近期自学了 Rails 开发，借助 AI 辅助实现了应用的部署上线。作为服务端开发的新手，初次部署应用时确实遇到了一些挑战，但成功发布第一个 Web 应用是全栈开发道路上的一大步。

希望通过本文的分享，能够帮助更多 Ruby/Rails 初学者。亲手将自己开发的应用部署上线，这种创造带来的成就感远超刷手机的短暂快乐，也是持续学习的重要动力。

部署架构总览

请求流向

用户浏览器 → Nginx (80/443 端口) → Unix Socket/端口 → Puma (应用服务器) → Rails 应用

部署流程图（Google Cloud VM，1GB 内存）

┌─────────────────────────────────────────────────────────────────┐
│                     Rails 应用部署完整流程                          │
│                    (1GB Google Cloud VM)                        │
└─────────────────────────────────────────────────────────────────┘
                              开始
                               │
                               ▼
┌──────────────────────────────────────────────────────────────────┐
│  阶段 1: 本地准备工作                                               │
│  ┌────────────────────────────────────────────────────────┐      │
│  │ 1.1 确保代码已提交到 Git                                  │      │
│  │     git add . && git commit -m "Ready to deploy"        │      │
│  │                                                         │      │
│  │ 1.2 推送到 GitHub/GitLab                                │      │
│  │     git push origin main                                │      │
│  │                                                         │      │
│  │ 1.3 准备环境变量清单                                      │      │
│  │     - SECRET_KEY_BASE                                   │      │
│  │     - DATABASE_PASSWORD                                 │      │
│  │     - 其他敏感信息                                        │      │
│  └────────────────────────────────────────────────────────┘      │
└──────────────────────────────────────────────────────────────────┘
                               │
                               ▼
┌──────────────────────────────────────────────────────────────────┐
│  阶段 2: 连接到 Google Cloud VM                                   │
│  ┌────────────────────────────────────────────────────────┐      │
│  │ 2.1 获取 VM 外部 IP 地址                                  │      │
│  │     GCP 控制台 → Compute Engine → VM 实例                │      │
│  │     记录: 外部 IP = XXX.XXX.XXX.XXX                      │      │
│  │                                                         │      │
│  │ 2.2 通过 SSH 连接                                         │      │
│  │     ssh username@XXX.XXX.XXX.XXX                        │      │
│  │     或使用 GCP 控制台的 SSH 按钮                           │      │
│  └────────────────────────────────────────────────────────┘      │
└──────────────────────────────────────────────────────────────────┘
                               │
                               ▼
┌──────────────────────────────────────────────────────────────────┐
│  阶段 3: 配置服务器环境 (首次需要)                                   │
│  ┌────────────────────────────────────────────────────────┐      │
│  │ 3.1 更新系统                                             │      │
│  │     sudo apt update && sudo apt upgrade -y              │      │
│  │                                                         │      │
│  │ 3.2 安装基础工具                                          │      │
│  │     sudo apt install -y curl git build-essential        │      │
│  │                                                         │      │
│  │ 3.3 创建 Swap (重要!)                                     │      │
│  │     sudo fallocate -l 1G /swapfile                      │      │
│  │     sudo chmod 600 /swapfile                            │      │
│  │     sudo mkswap /swapfile && sudo swapon /swapfile      │      │
│  │                                                         │      │
│  │ 3.4 安装 Ruby (rbenv)                                    │      │
│  │     git clone https://github.com/rbenv/rbenv.git        │      │
│  │     # ... (详细步骤见下方)                                 │      │
│  │                                                         │      │
│  │ 3.5 安装数据库 (PostgreSQL 或 SQLite)                    │      │
│  │     sudo apt install -y postgresql libpq-dev            │      │
│  │                                                         │      │
│  │ 3.6 安装 Nginx                                           │      │
│  │     sudo apt install -y nginx                           │      │
│  └────────────────────────────────────────────────────────┘      │
└──────────────────────────────────────────────────────────────────┘
                               │
                               ▼
┌──────────────────────────────────────────────────────────────────┐
│  阶段 4: 部署应用代码                                              │
│  ┌────────────────────────────────────────────────────────┐      │
│  │ 4.1 创建项目目录                                          │      │
│  │     sudo mkdir -p /var/www                              │      │
│  │     sudo chown $USER:$USER /var/www                     │      │
│  │                                                         │      │
│  │ 4.2 克隆项目                                              │      │
│  │     cd /var/www                                         │      │
│  │     git clone https://github.com/你的项目.git            │      │
│  │     cd 你的项目名                                         │      │
│  │                                                         │      │
│  │ 4.3 安装 Gem 依赖                                         │      │
│  │     bundle config set --local deployment 'true'         │      │
│  │     bundle install                                      │      │
│  │                                                         │      │
│  │ 4.4 配置环境变量                                          │      │
│  │     nano .env                                           │      │
│  │     # 填入 SECRET_KEY_BASE 等                            │      │
│  │                                                         │      │
│  │ 4.5 设置数据库                                            │      │
│  │     RAILS_ENV=production rails db:create                │      │
│  │     RAILS_ENV=production rails db:migrate               │      │
│  │                                                         │      │
│  │ 4.6 预编译资源                                            │      │
│  │     RAILS_ENV=production rails assets:precompile        │      │
│  └────────────────────────────────────────────────────────┘      │
└──────────────────────────────────────────────────────────────────┘
                               │
                               ▼
┌──────────────────────────────────────────────────────────────────┐
│  阶段 5: 配置 Puma 服务                                            │
│  ┌────────────────────────────────────────────────────────┐      │
│  │ 5.1 创建 Systemd 服务文件                                 │      │
│  │     sudo nano /etc/systemd/system/rails.service         │      │
│  │                                                         │      │
│  │ 5.2 启动服务                                              │      │
│  │     sudo systemctl daemon-reload                        │      │
│  │     sudo systemctl enable rails                         │      │
│  │     sudo systemctl start rails                          │      │
│  │                                                         │      │
│  │ 5.3 检查状态                                              │      │
│  │     sudo systemctl status rails                         │      │
│  └────────────────────────────────────────────────────────┘      │
└──────────────────────────────────────────────────────────────────┘
                               │
                               ▼
┌──────────────────────────────────────────────────────────────────┐
│  阶段 6: 配置 Nginx 反向代理                                       │
│  ┌────────────────────────────────────────────────────────┐      │
│  │ 6.1 创建 Nginx 配置                                       │      │
│  │     sudo nano /etc/nginx/sites-available/rails          │      │
│  │                                                         │      │
│  │ 6.2 启用配置                                              │      │
│  │     sudo ln -s /etc/nginx/sites-available/rails \       │      │
│  │                /etc/nginx/sites-enabled/                │      │
│  │     sudo rm /etc/nginx/sites-enabled/default            │      │
│  │                                                         │      │
│  │ 6.3 测试并重启 Nginx                                      │      │
│  │     sudo nginx -t                                       │      │
│  │     sudo systemctl restart nginx                        │      │
│  └────────────────────────────────────────────────────────┘      │
└──────────────────────────────────────────────────────────────────┘
                               │
                               ▼
┌──────────────────────────────────────────────────────────────────┐
│  阶段 7: 配置防火墙                                                │
│  ┌────────────────────────────────────────────────────────┐      │
│  │ 7.1 在 GCP 控制台配置防火墙规则                            │      │
│  │     VPC 网络 → 防火墙 → 创建防火墙规则                     │      │
│  │     - 允许 tcp:80 (HTTP)                                │      │
│  │     - 允许 tcp:443 (HTTPS)                              │      │
|  | 其实在创建虚拟机的时候，把https和http流量入口都打开，应该就可以了
│  └────────────────────────────────────────────────────────┘      │
└──────────────────────────────────────────────────────────────────┘
                               │
                               ▼
┌──────────────────────────────────────────────────────────────────┐
│  阶段 8: 测试访问                                                  │
│  ┌────────────────────────────────────────────────────────┐      │
│  │ 8.1 在浏览器中访问                                         │      │
│  │     http://你的云服务器外部IP                                   │      │
│  │                                                         │      │
│  │ 8.2 验证网站正常显示│  └───────────────────
─────────────────────────────────────┘      │
└──────────────────────────────────────────────────────────────────┘
                               │
                               ▼
                          部署完成! 🎉

详细部署步骤

阶段 1: 本地准备工作

1.1 修改生产环境配置在项目中的 /config/environments/production.rb 文件中，临时允许 HTTP 访问： config.force_ssl = false

1.2 代码提交到 GitHub

将代码提交到 GitHub（如不想公开代码，请选择私有仓库）
确保所有更改已提交并推送

1.3 生成生产环境密钥（非常重要！）

在本地 Rails 项目目录运行以下命令： rails secret

复制输出的密钥（示例：3a5b8c9d7e6f1a2b3c4d5e6f7a8b9c0d...），稍后会用到。

阶段 2: 创建并连接到 Google 云服务器

2.1 创建云服务器

区域选择：选择离您较近的区域（如香港）
操作系统：Ubuntu 25.10
网络配置：确保开启 HTTP 和 HTTPS 流量入口

2.2 通过 SSH 连接到服务器 ssh username@你的服务器 IP 地址提示：如果不熟悉 SSH 连接，可以使用 Google Cloud Console 的 SSH 按钮或咨询 AI 工具获取帮助。

阶段 3: 配置服务器环境（首次部署必需）

3.1 更新系统 sudo apt-get update
3.2 安装必要工具包这些软件包是编译和运行 Ruby on Rails 应用的基础依赖：

sudo apt-get install -y git curl zlib1g-dev build-essential libssl-dev libreadline-dev libyaml-dev libsqlite3-dev sqlite3 libxml2-dev libxslt1-dev libcurl4-openssl-dev libffi-dev libvips

比喻：连接上云服务器就像搬进新家，需要先完成通水通电等基础装修，后续的应用程序（家电）才能正常工作。
3.3 创建 Swap 虚拟内存（重要！）

# 创建 1GB Swap 文件（内存不足时可增加至 2GB）
sudo fallocate -l 1G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

# 验证 Swap 是否生效
free -h

3.4 安装 Ruby 方法一：快速安装（推荐新手） sudo apt-get install -y ruby-full 方法二：使用 rbenv（需要特定 Ruby 版本）

# 安装 rbenv
git clone https://github.com/rbenv/rbenv.git ~/.rbenv
echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bashrc
echo 'eval "$(rbenv init -)"' >> ~/.bashrc
source ~/.bashrc

# 安装 ruby-build 插件
git clone https://github.com/rbenv/ruby-build.git ~/.rbenv/plugins/ruby-build

# 安装指定 Ruby 版本（根据项目需要调整）
rbenv install 3.2.0
rbenv global 3.2.0

#验证安装：
ruby -v

3.5 安装 Bundler 和数据库

# 安装 Bundler（Ruby 依赖管理工具）
gem install bundler

# 安装 SQLite3（如项目使用）
sudo apt install -y sqlite3 libsqlite3-dev

# 或安装 PostgreSQL（如项目使用）
sudo apt install -y postgresql postgresql-contrib libpq-dev

3.6 安装 Nginx sudo apt install -y nginx Nginx 比喻：如同机场航站楼，负责验证请求、路由转发、SSL/压缩处理和负载均衡。

阶段 4: 部署应用代码

#4.1 创建项目目录
  sudo mkdir -p /var/www
  sudo chown $USER:$USER /var/www
#4.2 克隆项目
  cd /var/www
  git clone https://github.com/你的用户名/你的项目.git
  cd 你的项目名
#4.3 安装 Gem 依赖
  bundle config set --local deployment 'true'
  bundle config set --local without 'development test'
  bundle install
# 4.4 配置环境变量
# 创建 .env 文件：
  nano .env

.env 文件内容：

# Rails 环境
RAILS_ENV=production
RAILS_SERVE_STATIC_FILES=true

# 安全密钥（使用之前生成的）
SECRET_KEY_BASE=粘贴你生成的密钥

# 数据库配置（SQLite）
DATABASE_URL=sqlite3:db/production.sqlite3

# PostgreSQL 配置（如使用）
# DATABASE_URL=postgresql://用户名:密码@localhost/myapp_production

# Puma 配置（1GB 内存优化）
RAILS_MAX_THREADS=5
WEB_CONCURRENCY=2

# 日志级别
RAILS_LOG_LEVEL=info

# 允许的主机（重要！）
ALLOWED_HOSTS=你的VM外部IP

操作提示：保存按 Ctrl+O，退出按 Ctrl+X

4.5 数据库设置和资源预编译

# 创建数据库
RAILS_ENV=production bundle exec rails db:create

# 运行数据库迁移
RAILS_ENV=production bundle exec rails db:migrate

# 预编译静态资源
RAILS_ENV=production bundle exec rails assets:precompile

# 测试启动（可选）
RAILS_ENV=production bundle exec rails server -b 0.0.0.0 -p 3000
# 按 Ctrl+C 停止测试

阶段 5: 配置 Puma 服务

5.1 创建 Systemd 服务文件 sudo nano /etc/systemd/system/rails.service

粘贴以下内容（根据实际情况修改）：

[Unit]
Description=Rails Application (Puma)
After=network.target

[Service]
Type=simple
User=你的用户名
WorkingDirectory=/var/www/你的项目名
EnvironmentFile=/var/www/你的项目名/.env
ExecStart=/实际的bundle路径 exec puma -C config/puma.rb
Restart=always
RestartSec=10
StandardOutput=append:/var/www/你的项目名/log/puma.log
StandardError=append:/var/www/你的项目名/log/puma_error.log

[Install]
WantedBy=multi-user.target

需要替换的内容： 1.你的用户名：运行 whoami 查看 2.你的项目名：你的项目目录名 3./实际的bundle路径：运行 which bundle 获取

5.2 启动并启用服务

# 重新加载 systemd 配置
sudo systemctl daemon-reload

# 启用开机自启
sudo systemctl enable rails

# 启动服务
sudo systemctl start rails

# 查看服务状态
sudo systemctl status rails

# 如有错误，查看日志
sudo journalctl -u rails -n 50

阶段 6: 配置 Nginx 反向代理

6.1 创建 Nginx 配置 sudo nano /etc/nginx/sites-available/rails 粘贴以下配置：

upstream puma {
  server 127.0.0.1:3000 fail_timeout=0;
}

server {
  listen 80;
  server_name 你的云服务器外部IP;

  root /var/www/你的项目名/public;

  # 静态文件处理
  location ~ ^/(assets|packs)/ {
    gzip_static on;
    expires max;
    add_header Cache-Control public;
  }

  try_files $uri/index.html $uri @puma;

  location @puma {
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header Host $http_host;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_redirect off;
    proxy_pass http://puma;
  }

  error_page 500 502 503 504 /500.html;
  client_max_body_size 10M;
  keepalive_timeout 10;
}

6.2 启用配置并重启 Nginx

# 启用站点配置
sudo ln -s /etc/nginx/sites-available/rails /etc/nginx/sites-enabled/

# 删除默认配置
sudo rm /etc/nginx/sites-enabled/default

# 测试配置语法
sudo nginx -t

# 重启 Nginx
sudo systemctl restart nginx

# 查看 Nginx 状态
sudo systemctl status nginx

阶段 7: 配置云服务器防火墙

注意：在创建虚拟机时已开启 HTTP/HTTPS 流量入口的，此步骤应该可跳过。在 Google Cloud Console 中操作：

1.导航到 VPC 网络 → 防火墙
2.点击创建防火墙规则
3.配置 HTTP 规则：名称：allow-http 目标：网络中的所有实例来源 IP 范围：0.0.0.0/0 协议和端口：tcp:80

阶段 8: 测试访问

http://你的云服务器外部IP 如一切正常，您将看到您的 Rails 应用已成功上线！

希望你上线顺利中途需要注意的几个点：

1.环境变量配置完整准确
2.Systemd 服务文件路径一定要正确
3.Nginx 配置无误
4.防火墙规则正确设置
5.还有上线的时候一定要预编译 Rails 的资源文件，不然你的网页上图片会裂开（加载不了图片）hhh

如果你的项目没跑起来，也不要急。好好跟 AI 对话，把你查到的错误日志、或者查看到的状态码都发给 AI 分析，基本上都能通过。

小白学习 Ruby ,迈向全栈开发的第一步 | 环境安装 🎉

AixCoder — Mon, 10 Nov 2025 21:18:07 +0800

对于新手来说挺苦的，倒腾了一天。

明天再写下过程中遇到的坑这次搭建环境遇到的问题 Google 上提供的答案都很少，苦逼了一天终于把 Rails 跑起来了

老手们不要笑话 hhh

Ruby Girl，小白学习 Ruby 第一弹尝试下载小宇宙播客节目

AixCoder — Fri, 24 Oct 2025 19:22:52 +0800

哈喽
作为新手，开始接触 Ruby 这门编程语言

看起来感觉跟 Py 差不多舒适

都是比较简洁的语法

比那隔壁的 Java 看起来感觉好多了

目前不算怎么会写，暂时 get 不到所谓像诗一样的 Ruby 到底有多优雅，但至少代码第一观感还行

这次练手的项目是写一个脚本来自动下载小宇宙的播客节目（蛮喜欢小宇宙这个播客平台）

开发环境：macOS 自带的 Ruby 2.6 版本附上代码仅供学习参考！

#!/usr/bin/env ruby
# 小宇宙播客下载脚本（支持备用地址重试）
# 仅使用 Ruby 系统内置库，无需额外安装

# 1. 引入 Ruby 标准库
require 'net/http'
require 'uri'
require 'timeout'
require 'json'
require 'fileutils'

# 2. 配置参数
TIMEOUT_SEC = 300  # 下载超时时间（秒）
NEXT_DATA_REGEX = /<script id="__NEXT_DATA__" type="application\/json">([\s\S]*?)<\/script>/
MEDIA_PATH = %w[props pageProps episode media]          # media字段路径
SOURCE_URL_PATH = %w[source url]                       # 主下载地址路径（media -> source -> url）
BACKUP_SOURCE_URL_PATH = %w[backupSource url]           # 备用下载地址路径（media -> backupSource -> url）
TITLE_PATH = %w[props pageProps episode title]          # 节目名称路径
CHUNK_SIZE = 4096  # 下载分块大小（字节）
INVALID_CHARS = /[\/\\:*?"<>|]/  # 文件名非法字符

# 3. 获取用户桌面路径（适配多系统）
def desktop_path
  case RbConfig::CONFIG['host_os']
  when /mswin|mingw|cygwin/  # Windows
    File.join(ENV['USERPROFILE'], 'Desktop')
  when /darwin/  # macOS
    File.join(ENV['HOME'], 'Desktop')
  else  # Linux 等类 Unix 系统
    File.join(ENV['HOME'], 'Desktop')
  end
rescue
  raise "无法获取桌面路径，请检查系统环境"
end

# 从下载链接提取文件扩展名
def extract_file_extension(url)
  uri = URI.parse(url)
  ext = File.extname(uri.path)
  ext.empty? ? '.m4a' : ext
rescue
  '.m4a'
end

# 清理文件名中的非法字符
def clean_filename(raw_name)
  cleaned = raw_name.gsub(INVALID_CHARS, '_')
  cleaned.strip.empty? ? "未命名节目" : cleaned.strip
end

# 处理文件重名
def resolve_save_path(desktop, base_name, ext)
  base_filename = "#{base_name}#{ext}"
  base_path = File.join(desktop, base_filename)
  return base_path unless File.exist?(base_path)

  counter = 1
  loop do
    new_filename = "#{base_name}_#{counter}#{ext}"
    new_path = File.join(desktop, new_filename)
    return new_path unless File.exist?(new_path)
    counter += 1
  end
end

# 下载文件（单独提取为方法，支持传入不同URL重试）
def download_with_url(url, save_path)
  uri = URI.parse(url)
  puts "\n📥 开始下载（地址：#{url.split('/')[-1]}）：#{File.basename(save_path)}"
  puts "📌 保存路径：#{save_path}"

  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = uri.scheme == 'https'
  http.open_timeout = TIMEOUT_SEC
  http.read_timeout = TIMEOUT_SEC

  total_size = nil
  begin
    head_response = http.request(Net::HTTP::Head.new(uri))
    total_size = head_response['Content-Length']&.to_i
  rescue
    puts "⚠️ 无法获取文件大小，将继续下载..."
  end

  downloaded_size = 0
  File.open(save_path, 'wb') do |file|
    http.request(Net::HTTP::Get.new(uri)) do |response|
      unless response.is_a?(Net::HTTPSuccess)
        raise "下载请求失败，状态码：#{response.code}"
      end

      response.read_body do |chunk|
        file.write(chunk)
        downloaded_size += chunk.size

        if total_size
          progress = (downloaded_size.to_f / total_size * 100).round(1)
          print "\r⏳ 下载进度：#{progress}% （#{format_size(downloaded_size)}/#{format_size(total_size)}）"
        else
          print "\r⏳ 已下载：#{format_size(downloaded_size)}"
        end
      end
    end
  end

  puts "\n✅ 下载完成！文件已保存到桌面"
rescue Timeout::Error
  FileUtils.rm_f(save_path)
  raise "下载超时（超过 #{TIMEOUT_SEC} 秒）"
rescue => e
  FileUtils.rm_f(save_path)
  raise "下载失败：#{e.message}"
end

# 格式化文件大小
def format_size(bytes)
  return "#{bytes} B" if bytes < 1024
  return "%.2f KB" % (bytes / 1024.0) if bytes < 1024**2
  "%.2f MB" % (bytes / (1024**2).to_f)
end

# 链接校验
def get_target_url
  loop do
    print "\n请输入小宇宙播客详情页链接（例如：https://www.xiaoyuzhoufm.com/episode/xxx）："
    url = gets.chomp

    if url.empty?
      puts "⚠️ 链接不能为空，请重新输入！"
      next
    end

    begin
      uri = URI.parse(url)
      unless uri.scheme && %w[http https].include?(uri.scheme) && uri.host&.include?('xiaoyuzhoufm.com')
        raise "格式错误"
      end
    rescue
      puts "⚠️ 链接格式无效（需包含 http/https 且为小宇宙域名），请重新输入！"
      next
    end

    return url
  end
end

# 请求页面HTML
def fetch_page_html(url)
  uri = URI.parse(url)
  puts "\n🔍 正在请求目标页面：#{url}"

  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = uri.scheme == 'https'
  http.open_timeout = 30
  http.read_timeout = 30

  request = Net::HTTP::Get.new(uri)
  request['User-Agent'] = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36'
  request['Accept'] = 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'
  request['Referer'] = 'https://www.xiaoyuzhoufm.com/'

  response = http.request(request)

  unless response.code.to_i == 200
    raise "页面请求失败，状态码：#{response.code}（可能链接无效或被拦截）"
  end

  response.body
rescue Timeout::Error
  raise "网络请求超时（超过 30 秒），请检查网络连接"
rescue => e
  raise "网络请求异常：#{e.message}"
end

# 提取__NEXT_DATA__
def extract_next_data(html)
  match_result = html.match(NEXT_DATA_REGEX)

  unless match_result && match_result[1]
    raise "未在页面中找到 __NEXT_DATA__ 字段（可能页面结构已变更）"
  end

  match_result[1].strip
end

# 提取节目名称
def extract_episode_title(next_data_json)
  begin
    next_data = JSON.parse(next_data_json)
  rescue JSON::ParserError => e
    raise "JSON 解析失败：#{e.message}（无法提取节目名称）"
  end

  current = next_data
  TITLE_PATH.each_with_index do |key, index|
    unless current.is_a?(Hash) && current.key?(key)
      missing_path = TITLE_PATH[0..index].join(' -> ')
      raise "未找到节目名称，缺失层级：#{missing_path}"
    end
    current = current[key]
  end

  unless current.is_a?(String) && !current.strip.empty?
    raise "提取的节目名称无效：#{current.inspect}"
  end

  current.strip
end

# 提取media字段
def extract_media_field(next_data_json)
  begin
    next_data = JSON.parse(next_data_json)
  rescue JSON::ParserError => e
    raise "JSON 解析失败：#{e.message}"
  end

  current = next_data
  MEDIA_PATH.each_with_index do |key, index|
    unless current.is_a?(Hash) && current.key?(key)
      missing_path = MEDIA_PATH[0..index].join(' -> ')
      raise "未找到media字段，缺失层级：#{missing_path}"
    end
    current = current[key]
  end

  current
end

# 提取主下载地址
def extract_download_url(media_data)
  unless media_data.is_a?(Hash)
    raise "media字段格式异常（不是哈希类型）"
  end

  current = media_data
  SOURCE_URL_PATH.each_with_index do |key, index|
    unless current.is_a?(Hash) && current.key?(key)
      full_missing_path = ["media"] + SOURCE_URL_PATH[0..index]
      raise "未找到主下载地址，缺失层级：#{full_missing_path.join(' -> ')}"
    end
    current = current[key]
  end

  validate_url(current)
  current
end

# 新增：提取备用下载地址（不抛出异常，不存在则返回nil）
def extract_backup_download_url(media_data)
  return nil unless media_data.is_a?(Hash)

  current = media_data
  BACKUP_SOURCE_URL_PATH.each_with_index do |key, index|
    # 备用地址缺失时不报错，直接返回nil
    unless current.is_a?(Hash) && current.key?(key)
      puts "ℹ️ 未找到备用下载地址（缺失层级：media -> #{BACKUP_SOURCE_URL_PATH[0..index].join(' -> ')}）"
      return nil
    end
    current = current[key]
  end

  begin
    validate_url(current)
    current
  rescue
    puts "ℹ️ 备用下载地址格式无效：#{current}"
    nil
  end
end

# 校验URL格式
def validate_url(url)
  return if url.is_a?(String) && !url.strip.empty?

  raise "URL格式无效（非字符串或为空）：#{url.inspect}"

  uri = URI.parse(url)
  unless uri.scheme && %w[http https].include?(uri.scheme)
    raise "URL协议错误（需http/https）：#{url}"
  end
rescue
  raise "URL解析失败：#{url}"
end

# 主执行流程
def main
  puts "======================================"
  puts "小宇宙播客下载脚本（支持备用地址重试）"
  puts "功能：主地址失败自动尝试备用地址 → 提取节目名称 → 下载到桌面"
  puts "主地址路径：media -> source -> url"
  puts "备用地址路径：media -> backupSource -> url"
  puts "======================================"

  begin
    target_url = get_target_url
    page_html = fetch_page_html(target_url)
    next_data_json = extract_next_data(page_html)
    episode_title = extract_episode_title(next_data_json)
    puts "\n📌 提取到节目名称：#{episode_title}"

    media_data = extract_media_field(next_data_json)
    main_url = extract_download_url(media_data)
    puts "📥 提取到主下载地址：#{main_url.split('/')[-1]}"

    # 提取备用地址（不中断流程）
    backup_url = extract_backup_download_url(media_data)
    puts "📥 提取到备用下载地址：#{backup_url.split('/')[-1]}" if backup_url

    # 处理文件名和路径
    cleaned_title = clean_filename(episode_title)
    file_ext = extract_file_extension(main_url) # 用主地址的扩展名（备用地址通常格式一致）
    desktop = desktop_path
    save_path = resolve_save_path(desktop, cleaned_title, file_ext)

    # 先尝试主地址下载
    begin
      download_with_url(main_url, save_path)
    rescue => e
      puts "⚠️ 主地址下载失败：#{e.message}"
      # 主地址失败且有备用地址时重试
      if backup_url
        puts "🔄 尝试使用备用地址下载..."
        download_with_url(backup_url, save_path)
      else
        raise "主地址下载失败，且无可用备用地址"
      end
    end

  rescue => e
    puts "\n❌ 执行失败：#{e.message}"
    exit 1
  end

  puts "\n🎉 操作完成！"
end

# 启动脚本
main

新人想学 Ruby，大家伙从业多年的来给些意见呢，谢谢

AixCoder — Fri, 20 Jun 2025 19:02:43 +0800

本人会一点 iOS 开发，有想法学习 Ruby 已经有多年 Ruby 开发经验的各位能否给出一些意见，劝学也好，劝退也好😁 还是很想听听已经在圈内的人士，问问大家如何看待新手入坑 Ruby 相信能给出一些更为实用的建议