Rust 练习册 64：时钟与时间处理

原创 已于 2025-11-21 14:30:42 修改 · 428 阅读 · 13 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#rust #开发语言 #后端

于 2025-11-21 13:20:08 首次发布

在日常生活中，时钟是我们最常用的工具之一。数字时钟以24小时制显示时间，当时间超过24小时时会自动回到00:00。在 Exercism 的 “clock” 练习中，我们将实现一个数字时钟，这不仅能帮助我们掌握时间处理技巧，还能深入学习 Rust 中的运算符重载、显示格式化和模运算应用。

时钟的工作原理

数字时钟遵循以下规则：

  1. 时间格式：以 HH:MM 格式显示，小时和分钟都是两位数
  2. 24小时制：小时范围是 00-23，分钟范围是 00-59
  3. 自动回绕：当时间超过 23:59 时，自动回到 00:00
  4. 负数处理：支持负数时间的处理，例如 -1 小时等于 23 小时

让我们先看看练习提供的实现：

use std::fmt::Display;

const DAY_MINS: i32 = 1440;
const HOUR_MINS: i32 = 60;

#[derive(Debug, PartialEq)]
pub struct Clock {
    minutes: i32,
}

impl Clock {
    pub fn new(hours: i32, minutes: i32) -> Self {
        Self::build(hours * HOUR_MINS + minutes)
    }

    fn build(minutes: i32) -> Self {
        let mut minutes = minutes;
        while minutes < 0 {
            minutes += DAY_MINS;
        }

        Clock {
            minutes: minutes % DAY_MINS,
        }
    }

    pub fn add_minutes(&self, minutes: i32) -> Self {
        Self::build(self.minutes + minutes)
    }
}

impl Display for Clock {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let minutes = self.minutes;
        write!(f, "{:02}:{:02}", minutes / HOUR_MINS, minutes % HOUR_MINS)
    }
}

这个实现非常优雅，它将所有时间都转换为分钟数进行处理，然后通过模运算实现自动回绕。

算法解析

1. 核心设计思想

const DAY_MINS: i32 = 1440;  // 24 * 60
const HOUR_MINS: i32 = 60;   // 1 * 60

通过将所有时间都转换为分钟数，简化了时间计算。一天有1440分钟，一小时有60分钟。

2. 时间构造

pub fn new(hours: i32, minutes: i32) -> Self {
    Self::build(hours * HOUR_MINS + minutes)
}

将小时和分钟都转换为总分钟数，然后通过 [build](file:///Users/zacksleo/projects/github/zacksleo/exercism-rust/exercises/practice/dot-dsl/src/graph.rs#L22-L22) 方法处理负数和溢出。

3. 时间标准化

fn build(minutes: i32) -> Self {
    let mut minutes = minutes;
    while minutes < 0 {
        minutes += DAY_MINS;
    }

    Clock {
        minutes: minutes % DAY_MINS,
    }
}

这个方法处理了负数时间和超过一天的时间：

  • 对于负数时间，通过不断加一天的分钟数直到变为正数
  • 对于超过一天的时间，通过模运算将其限制在一天内

4. 显示格式化

impl Display for Clock {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let minutes = self.minutes;
        write!(f, "{:02}:{:02}", minutes / HOUR_MINS, minutes % HOUR_MINS)
    }
}

通过整数除法和模运算将总分钟数转换回小时和分钟格式，并使用 {:02} 确保两位数显示。

测试用例分析

通过查看测试用例，我们可以更好地理解需求：

#[test]
fn test_on_the_hour() {
    assert_eq!(Clock::new(8, 0).to_string(), "08:00");
}

整点时间的显示。

#[test]
fn test_hour_rolls_over() {
    assert_eq!(Clock::new(25, 0).to_string(), "01:00");
}

小时超过24时自动回绕。

#[test]
fn test_negative_hour() {
    assert_eq!(Clock::new(-1, 15).to_string(), "23:15");
}

负数小时的处理。

#[test]
fn test_add_across_midnight() {
    let clock = Clock::new(23, 59).add_minutes(2);
    assert_eq!(clock.to_string(), "00:01");
}

跨 midnight 的时间增加。

#[test]
fn test_compare_clocks_for_equality() {
    assert_eq!(Clock::new(15, 37), Clock::new(15, 37));
}

时钟相等性比较。

替代实现方法

1. 分别存储小时和分钟

use std::fmt::Display;

#[derive(Debug, PartialEq)]
pub struct Clock {
    hours: i32,
    minutes: i32,
}

impl Clock {
    pub fn new(hours: i32, minutes: i32) -> Self {
        let total_minutes = hours * 60 + minutes;
        let normalized_minutes = ((total_minutes % 1440) + 1440) % 1440;
        
        let hours = normalized_minutes / 60;
        let minutes = normalized_minutes % 60;
        
        Clock { hours, minutes }
    }

    pub fn add_minutes(&self, minutes: i32) -> Self {
        Clock::new(self.hours, self.minutes + minutes)
    }
}

impl Display for Clock {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:02}:{:02}", self.hours, self.minutes)
    }
}

2. 使用 u32 存储分钟数

use std::fmt::Display;

const DAY_MINS: u32 = 1440;

#[derive(Debug, PartialEq)]
pub struct Clock {
    minutes: u32,
}

impl Clock {
    pub fn new(hours: i32, minutes: i32) -> Self {
        let total_minutes = hours * 60 + minutes;
        // 使用模运算处理负数
        let normalized_minutes = ((total_minutes % 1440 as i32) + 1440 as i32) % 1440 as i32;
        
        Clock {
            minutes: normalized_minutes as u32,
        }
    }

    pub fn add_minutes(&self, minutes: i32) -> Self {
        let total_minutes = self.minutes as i32 + minutes;
        let normalized_minutes = ((total_minutes % 1440 as i32) + 1440 as i32) % 1440 as i32;
        
        Clock {
            minutes: normalized_minutes as u32,
        }
    }
}

impl Display for Clock {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:02}:{:02}", self.minutes / 60, self.minutes % 60)
    }
}

运算符重载实现

为了使时钟更易于使用，我们可以实现运算符重载：

use std::fmt::Display;
use std::ops::{Add, AddAssign, Sub, SubAssign};

const DAY_MINS: i32 = 1440;
const HOUR_MINS: i32 = 60;

#[derive(Debug, PartialEq, Clone, Copy)]
pub struct Clock {
    minutes: i32,
}

impl Clock {
    pub fn new(hours: i32, minutes: i32) -> Self {
        Self::build(hours * HOUR_MINS + minutes)
    }

    fn build(minutes: i32) -> Self {
        let normalized_minutes = ((minutes % DAY_MINS) + DAY_MINS) % DAY_MINS;
        Clock {
            minutes: normalized_minutes,
        }
    }

    pub fn add_minutes(&self, minutes: i32) -> Self {
        Self::build(self.minutes + minutes)
    }
}

impl Display for Clock {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let minutes = self.minutes;
        write!(f, "{:02}:{:02}", minutes / HOUR_MINS, minutes % HOUR_MINS)
    }
}

// 实现加法运算符
impl Add<i32> for Clock {
    type Output = Clock;

    fn add(self, minutes: i32) -> Self::Output {
        self.add_minutes(minutes)
    }
}

// 实现加法赋值运算符
impl AddAssign<i32> for Clock {
    fn add_assign(&mut self, minutes: i32) {
        *self = self.add_minutes(minutes);
    }
}

// 实现减法运算符
impl Sub<i32> for Clock {
    type Output = Clock;

    fn sub(self, minutes: i32) -> Self::Output {
        self.add_minutes(-minutes)
    }
}

// 实现减法赋值运算符
impl SubAssign<i32> for Clock {
    fn sub_assign(&mut self, minutes: i32) {
        *self = self.add_minutes(-minutes);
    }
}

性能优化版本

考虑性能的优化实现：

use std::fmt::Display;

const DAY_MINS: i32 = 1440;
const HOUR_MINS: i32 = 60;

#[derive(Debug, PartialEq)]
pub struct Clock {
    minutes: i32,
}

impl Clock {
    pub fn new(hours: i32, minutes: i32) -> Self {
        Self::build(hours * HOUR_MINS + minutes)
    }

    #[inline]
    fn build(minutes: i32) -> Self {
        // 使用位运算优化模运算（当除数是2的幂时）
        // 但这里1440不是2的幂，所以我们使用标准模运算
        let normalized = ((minutes % DAY_MINS) + DAY_MINS) % DAY_MINS;
        Clock { minutes: normalized }
    }

    #[inline]
    pub fn add_minutes(&self, minutes: i32) -> Self {
        Self::build(self.minutes + minutes)
    }
    
    // 添加一些实用方法
    pub fn hours(&self) -> i32 {
        self.minutes / HOUR_MINS
    }
    
    pub fn minutes_only(&self) -> i32 {
        self.minutes % HOUR_MINS
    }
    
    pub fn total_minutes(&self) -> i32 {
        self.minutes
    }
}

impl Display for Clock {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:02}:{:02}", self.minutes / HOUR_MINS, self.minutes % HOUR_MINS)
    }
}

错误处理和边界情况

考虑更多边界情况的实现：

use std::fmt::Display;

const DAY_MINS: i32 = 1440;
const HOUR_MINS: i32 = 60;

#[derive(Debug, PartialEq)]
pub struct Clock {
    minutes: i32,
}

impl Clock {
    pub fn new(hours: i32, minutes: i32) -> Self {
        Self::build(hours * HOUR_MINS + minutes)
    }

    fn build(minutes: i32) -> Self {
        // 处理整数溢出
        let normalized = minutes.rem_euclid(DAY_MINS);
        Clock { minutes: normalized }
    }

    pub fn add_minutes(&self, minutes: i32) -> Self {
        Self::build(self.minutes.saturating_add(minutes))
    }
    
    // 添加一些实用方法
    pub fn hours(&self) -> i32 {
        self.minutes / HOUR_MINS
    }
    
    pub fn minutes_only(&self) -> i32 {
        self.minutes % HOUR_MINS
    }
}

impl Display for Clock {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:02}:{:02}", self.hours(), self.minutes_only())
    }
}

实际应用场景

时钟类在实际开发中有以下应用：

  1. 时间处理库：作为时间处理库的基础组件
  2. 游戏开发：游戏中的计时器和倒计时功能
  3. 任务调度：定时任务的时间计算
  4. 日历应用：时间显示和计算
  5. 嵌入式系统：设备的时间显示

与其他时间处理方式的比较

// 使用 chrono 库的实现
use chrono::{NaiveTime, Duration};

pub struct ClockChrono {
    time: NaiveTime,
}

impl ClockChrono {
    pub fn new(hours: i32, minutes: i32) -> Self {
        let time = NaiveTime::from_hms_opt(
            (hours.rem_euclid(24)) as u32,
            (minutes.rem_euclid(60)) as u32,
            0,
        ).unwrap_or_else(|| NaiveTime::from_hms_opt(0, 0, 0).unwrap());
        
        ClockChrono { time }
    }

    pub fn add_minutes(&self, minutes: i32) -> Self {
        let duration = Duration::minutes(minutes as i64);
        let new_time = self.time + duration;
        ClockChrono { time: new_time }
    }
}

// 使用标准库 Duration 的实现
use std::time::Duration as StdDuration;
use std::fmt::Display;

pub struct ClockDuration {
    duration: StdDuration,
}

impl ClockDuration {
    pub fn new(hours: i32, minutes: i32) -> Self {
        let total_secs = ((hours * 3600 + minutes * 60) % 86400 + 86400) % 86400;
        ClockDuration {
            duration: StdDuration::from_secs(total_secs as u64),
        }
    }

    pub fn add_minutes(&self, minutes: i32) -> Self {
        let secs_to_add = (minutes * 60) as u64;
        let total_secs = (self.duration.as_secs() + secs_to_add) % 86400;
        ClockDuration {
            duration: StdDuration::from_secs(total_secs),
        }
    }
}

总结

通过 clock 练习，我们学到了：

  1. 时间处理：掌握了时间计算和格式化技巧
  2. 模运算应用：学会了使用模运算处理循环数据
  3. 显示格式化：熟练使用 Display trait 和格式化字符串
  4. 运算符重载：了解了如何为自定义类型实现运算符
  5. 边界处理：理解了如何处理负数和溢出情况
  6. 性能优化：学习了内联函数等优化技巧

这些技能在实际开发中非常有用，特别是在处理时间相关功能、实现循环数据结构和进行数学计算时。时钟虽然看起来简单，但它涉及到了模运算、数据标准化和显示格式化等许多核心概念，是学习 Rust 数据处理的良好起点。

通过这个练习，我们也看到了 Rust 在处理数学运算和数据格式化方面的强大能力，以及如何用简洁且高效的方式实现复杂逻辑。这种结合了安全性和性能的语言特性正是 Rust 的魅力所在。

Rust嵌入式功耗优化：时钟门控技术.pdf
05-05
文档内所有文字、图表、函数、目录等元素均显示正常，无任何异常情况，敬请您放心查阅与使用。文档仅供学习参考，请勿用作商业用途。 Rust 以内存安全、零成本抽象和并发高效的特性，重塑编程体验。无需垃圾回收，却...
Rust嵌入式实时时钟：RTC驱动与时间同步.pdf
05-04
文档内所有文字、图表、函数、目录等元素均显示正常，无任何异常情况，敬请您放心查阅与使用。文档仅供学习参考，请勿用作商业用途。 Rust 以内存安全、零成本抽象和并发高效的特性，重塑编程体验。无需垃圾回收，却...
Rust 练习册：时钟与时间处理
echohelloworld11的博客
11-07 740
本文介绍了数字时钟的实现原理及Rust编程实践。数字时钟遵循24小时制，自动处理时间回绕（如23:59后变为00:00）和负数时间。核心实现将所有时间转换为分钟数，利用模运算简化计算。文章分析了将小时/分钟统一存储为分钟数的算法设计，包括时间标准化处理（负数修正和溢出控制）以及格式化显示的实现。同时提供了两种替代实现方案（分别存储小时/分钟或使用无符号整数），并建议可扩展运算符重载功能。通过测试用例展示了时钟的各种边界情况处理，如整点显示、跨午夜时间计算等。
（转载）《HelloGitHub》第 82 期
shaozheng0503的博客
02-25 479
该库提供了 100 多个实用的函数，包括常用的 map、filter、reduce、invoke 以及更专业的辅助函数，比如函数绑定、JavaScript 模板功能、创建快速索引等，让我们可以更加方便地在 JavaScript 中实现函数式编程。这是一个生产级别的物联网平台，它可以将物联网(IoT)设备，封装成 K8s 的最小的可部署的计算单元(pod)，直接将设备的能力和数据通过 API 开放出来，让物联网应用的开发变得更加简单。这是一份教你如何在不依赖 IDE 的情况下，进行单片机开发的教程。
红旗Linux中文教程
kutekute的专栏
12-11 1万+
——红旗Linux授权培训中心指定用书—— 红旗Linux指定培训教材 红旗Linux用户基础教程 中科红旗软件技术有限公司编著 红旗Linux授权培训管理中心监制 Publishing House of Electronics Industry 北京BEIJING内容简介 本书属于“红旗Linux指定培训教材”系列，是红旗Linux授权培训中心指定用书。 本书从最基本的红
英语词根词缀记忆法
dangerous_fire的专栏
02-06 3万+
英语词根词缀记忆法（全集）  前言          英语单词的构词规律也是有规可寻的。单词是由词素构成的，词素派生出词义。单词的数量虽然浩瀚，但构成其的词素的数量却是有限的。如果掌握了词素，懂得基本的构词方法，就能容易地识记单词，突破记忆单词这一难关。 词素又是由词根和词缀两部分组成的，而词缀又分为前缀和后缀。常用的252个词根和289个词缀，掌握了这些词素便可掌握绝大
用C语言写一个查单词的小demo
m0_47068593的博客
07-03 5万+
用C语言写一个查单词的小demo #include <stdio.h> #include <string.h> #include <stdlib.h> int main(int argc, const char *argv[]) { // 用只读的方式打开我们的单词库 FILE *fp = fopen("dict.txt","r"); if (NULL == fp){ perror("fopen"); return -1
网络编程_8(项目附件)
weixin_38717634的博客
01-13 3万+
dict.txt abandonment n.放弃 abbreviation n.缩写 abeyance n.缓办，中止 abide v.遵守 ability n.能力 able adj.有能力的，能干的 abnormal adj.反常的，变态的 aboard adv.船(车)上 abolish v.废除，取消 abolition n.废除，取消 abortion n.流产 abortive adj.无效果的，失败的 about prep.关于，大约 ab
字典查询（部分）
myth_HG的专栏
05-28 14万+
#include #include #include using namespace std; const int enMax=46; const int chMax=256; const int attrMax = 66; const int spaceMax = 100; const int inputMax = 30; char atrrSum[13][attrMax]= {"n.","
简单英译汉SQL脚本
热门推荐
shencomd的专栏
10-19 19万+
create table t_dictionary(word varchar(200), trans varchar(1000)); insert into t_dictionary values('abandon','v.抛弃，放弃'); insert into t_dictionary values('abandonment','n.放弃'); insert into t_dictionary
系统编程语言：Rust：Rust的错误处理与panicPDF
08-22
1.2 Rust 中的错误类型:可恢复错误与不可恢复错误 Rust 中的错误大致可以分为两类:可恢复错误和不可恢复错误。 1.2.1可恢复错误 可恢复错误通常表示程序可以继续运行，但需要采取一些措施来处理当前的问题。在Rust中...
时间：Rust中的简单时间处理
02-05
在Rust编程语言中，处理时间是一个常见的任务，无论是在日志记录、计时操作还是在需要精确时间计算的应用程序中。本篇文章将深入探讨如何在Rust中进行简单的时间处理，包括获取当前时间、时间格式化以及进行时间计算...
Rust 练习册 63：循环缓冲区与数据结构实现
少湖说
11-20 646
本文介绍了循环缓冲区（Circular Buffer）的实现方法，这是一种固定大小的先进先出数据结构。文章详细讲解了其核心特性：固定内存占用、O(1)时间复杂度的读写操作，以及避免频繁内存分配的优势。通过Rust代码示例展示了如何实现循环缓冲区的基本功能，包括初始化、写入、读取、清空和覆盖操作。实现使用了Vec<Option<T>>存储元素，并通过索引追踪读写位置，当缓冲区满时会覆盖最旧数据。该数据结构在需要高效内存管理和连续数据处理的场景中非常实用。
RustFS：大模型时代的数据基石——千卡训练集群的存储解决方案
分布式存储与RustFS的博客
11-20 1089
2025年AI大模型训练面临存储瓶颈问题，RustFS存储系统成为关键解决方案。该系统通过内存安全设计、元数据分离架构和智能数据分片技术，在千卡GPU集群中实现4K随机读1,580KIOPS（比MinIO快42%），显著提升训练效率。RustFS的优化包括检查点存储、数据预热策略、RDMA网络支持和多级缓存体系，使GPU利用率从55%提升至92%，训练时间缩短30%。该系统兼容S3协议，支持Kubernetes部署，提供完整的监控运维体系，并计划进一步实现存储感知训练优化，成为大模型时代的关键基础设施。
Rust 练习册 56：阿姆斯特朗数与数学算法探索
少湖说
11-20 1499
本文介绍了阿姆斯特朗数的概念及其在Rust中的实现方法。阿姆斯特朗数是指一个n位数，其各位数字的n次幂之和等于该数本身。文章分析了两种主要实现方式：基于字符串转换的简洁实现和纯数学运算方法，并比较了它们的性能特点。此外，还探讨了边界情况处理、函数式编程风格的应用以及阿姆斯特朗数的数学特性。这种数字在算法教学中常作为典型例子，用于练习循环和数学运算。
Rust高性能Web后端服务开发与Actix-Web实战分享：零成本抽象、高并发处理与内存安全实践
最新发布
2501_94181083的博客
11-23 594
数据序列化使用bincode替代 JSON：节省 30% CPU对热点代码进行#[inline]展开Netty 式 Reactor 模型减少线程调度开销批量 DB 提交减少 IO 压力缓存热点业务路径到 Redis最终整个平台达成：单机 QPS：18 万P99 延迟 < 30msCPU 占用在可控范围内资源释放完全可预期，无内存泄漏风险高性能，无 GC 停顿编译期保证内存安全，避免线上事故Actix-Web 性能强劲，适合高并发系统适合对性能和稳定性要求极高的互联网生产环境。
使用chirp内网穿透工具联合rustdesk 实现远程操作安卓手机
a942242856的博客
11-21 571
本文介绍如何利用Chirp内网穿透工具配合RustDesk实现远程控制安卓手机。首先需要下载RustDesk安卓版和Chirp安卓版，并进行自启动和后台运行设置。在RustDesk中开启IP直连功能并启动服务，然后在Chirp中添加隧道映射，将RustDesk的内网IP和端口映射到远程端口。最后通过电脑端RustDesk输入远程IP和端口即可连接手机。文章还提示了可能出现的连接问题及解决方法，强调需要确保两个应用的后台运行权限。该方法无需自建服务器，简单易行。
Rust 练习册 65：考拉兹猜想与数学算法实现
少湖说
11-21 693
本文探讨了著名的考拉兹猜想（Collatz Conjecture），该猜想由德国数学家洛塔尔·考拉兹于1937年提出。文章详细介绍了该猜想的规则（偶数除2，奇数乘3加1）及其数学特性，并提供了多种Rust实现方案，包括迭代、递归和优化版本。重点分析了算法实现中的边界情况处理（如输入为0时返回None）、性能优化技巧（如记忆化、位运算）以及错误处理机制（防止整数溢出）。通过测试用例验证了不同实现的正确性，展示了从基础到高级的编程实践，帮助开发者掌握数值处理和算法优化的关键技能。
Rust在Web开发框架中的性能
2509_93937153的博客
11-23 301
另外Rust的并发模型也帮了大忙，它的async/await语法糖背后是Future轮询，配合多线程运行时能把CPU核心吃满，不像Python的GIL那样卡脖子。我测试时用wrk压测一个简单的JSON API，Rust版本在4核虚拟机上一秒能处理快8万请求，而同配置下Go的gin框架顶多跑到5万，Node.js的Express更是卡在2万出头。最近还有个叫axio的新框架，连中间件都用静态分派实现，性能直逼C++的drogon，实测延迟波动范围能控制在0.1毫秒内，这对金融级应用来说简直是刚需。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

少湖说

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值