嘿，朋友！既然你点开了这篇教程，我猜你可能刚接触 TSR 语言，或者正打算入坑。别紧张，我也曾经对着满屏的代码发懵，觉得每个符号都像在嘲笑我。但相信我，TSR 其实是一门逻辑清晰、表达力极强的语言，一旦你摸清了它的脾气，开发起来会非常爽快。
今天，我们不搞那些枯燥的教科书式定义，而是像老朋友聊天一样，带你从零开始认识 TSR。我会把核心语法、实战技巧以及新手最容易踩的“雷区”都摊开来讲，确保你不仅能看懂，还能真正上手写出可用的代码。
准备好了吗？让我们开始这段旅程。
一、 初识 TSR：它到底是什么？
在深入代码之前，我们先搞清楚 TSR 的定位。TSR 是一门 静态类型、编译型 的系统级编程语言，旨在提供极高的运行性能和内存安全性，同时保持相对简洁的语法。它有点像 C++ 和 Rust 的混血儿，但更强调开发者的体验。
为什么选择 TSR？
- 性能强劲：TSR 编译为机器码，执行效率接近 C++，没有虚拟机开销。
- 内存安全：通过所有权系统（Ownership System），在编译期杜绝空指针解引用和内存泄漏。
- 并发友好：内置协程（Coroutine）和异步模型，写高并发服务变得简单。
- 零成本抽象：许多高级特性（如泛型、模式匹配）在运行时开销为零。
第一个 TSR 程序
让我们从一个经典的“Hello, World!”开始，看看 TSR 的代码长什么样。
// 导入标准库的 IO 模块
import std.io;
// 主函数，程序入口
fn main() {
// 打印消息到控制台
std.io.println("Hello, TSR!");
// 定义一个不可变变量
let name = "初学者";
// 使用插值字符串
std.io.println("你好，{}！欢迎来到 TSR 的世界。", name);
}
代码解析：
import std.io;：TSR 使用模块系统，std是标准库，io是其中的输入输出模块。fn main() { ... }：程序从这里开始执行。let name = "初学者";：定义一个不可变变量name。注意，TSR 默认变量是不可变的，这能避免许多意外修改数据的问题。如果需要可变，要用let mut。std.io.println(...)：标准库中的打印函数，支持类似 Python 的字符串插值。
编译并运行这个程序，你应该能看到控制台输出两行欢迎信息。简单吧？
二、 核心语法：掌握 TSR 的骨架
语法是语言的骨架。理解 TSR 的核心语法，你就能自由地组织代码逻辑。我们分几个关键部分来讲。
2.1 变量与数据类型
TSR 是强类型语言，所有变量在编译时必须有明确的类型。不过，TSR 有强大的类型推断能力，你经常不需要显式写出类型。
基本数据类型
// 整数
let age: i32 = 25; // 32位有符号整数
let count: u64 = 1000000; // 64位无符号整数（用于计数、内存地址等）
// 浮点数
let price: f64 = 19.99; // 双精度浮点数
// 布尔值
let is_active: bool = true;
// 字符
let letter: char = 'A';
// 字符串（不可变）
let greeting = "Hello, TSR";
注意点：
i32、u64、f64等类型后缀表示位宽和有无符号。选择合适的类型可以避免溢出错误，提升性能。- 字符串是 UTF-8 编码，且不可变。修改字符串会生成新的字符串。
可变变量
如果你需要改变变量的值，必须用 let mut。
let mut score = 0;
score = 10; // 正确，score 是可变
score += 5; // 正确
// let score = 0; // 错误，默认不可变，不能重新赋值
2.2 控制流：让代码做出决策
TSR 提供了常见的 if、while、for 和 match 语句。其中，match 是 TSR 的亮点，比 C/C++ 的 switch 强大得多。
If 表达式
let temperature = 35;
if temperature > 30 {
std.io.println("天气很热！");
} else if temperature > 20 {
std.io.println("天气舒适。");
} else {
std.io.println("天气较冷。");
}
技巧： if 在 TSR 中是表达式，可以返回值。
let status = if temperature > 30 { "hot" } else { "cold" };
Loop 循环
// While 循环
let mut counter = 0;
while counter < 5 {
std.io.println("Counter: {}", counter);
counter += 1;
}
// For 循环（遍历范围）
for i in 0..5 { // 0 到 4
std.io.println("For loop: {}", i);
}
// 遍历集合
let fruits = std::collections::Vec::new();
fruits.push("apple");
fruits.push("banana");
fruits.push("cherry");
for fruit in &fruits {
std.io.println("I like {}", fruit);
}
Match 模式匹配
match 是 TSR 的核心特性，用于精确匹配值的模式。它能替代复杂的 if-else 链，使代码更清晰。
let dice_roll = 3;
match dice_roll {
1 => std.io.println!("非常低！"),
2 | 3 => std.io.println!("中等偏低。"),
4..=6 => std.io.println!("中等偏高。"), // 范围匹配
_ => std.io.println!("未知结果。"), // 通配符，必须处理所有情况
}
重要规则： match 必须是穷尽的，即必须处理所有可能的值，否则编译报错。
2.3 函数：代码的模块化
函数是 TSR 代码的基本单元。定义函数使用 fn 关键字。
// 定义函数
fn greet(name: &str) -> String {
// 函数体
let message = format!("Hello, {}!", name);
message // 最后一行表达式的值会自动返回
}
fn main() {
let result = greet("Alice");
std.io.println!("{}", result);
}
关键点：
- 参数类型和返回类型必须显式声明。
- 函数体最后一行表达式（不以分号结尾）的值就是返回值。如果以分号结尾，则返回空单元类型
()。 format!宏用于格式化字符串，类似于printf但返回String。
2.4 结构体与枚举：组合数据
TSR 用结构体（struct）和枚举（enum）来定义复杂数据类型。
结构体
struct User {
username: String,
email: String,
active: bool,
age: u32,
}
fn main() {
// 创建结构体实例
let user = User {
username: String::from("alice"),
email: String::from("alice@example.com"),
active: true,
age: 28,
};
// 访问字段
std.io.println!("User: {}, Age: {}", user.username, user.age);
}
枚举
枚举可以拥有关联数据，非常强大。
enum Shape {
Circle(f64), // 关联一个 f64（半径）
Rectangle(f64, f64), // 关联两个 f64（长和宽）
Triangle(f64, f64), // 关联两个 f64（底和高）
}
fn get_area(shape: &Shape) -> f64 {
match shape {
Shape::Circle(radius) => std::f64::consts::PI * radius * radius,
Shape::Rectangle(width, height) => width * height,
Shape::Triangle(base, height) => 0.5 * base * height,
}
}
三、 所有权系统：TSR 的灵魂
如果 TSR 只讲语法，那它只是另一门语言。真正让 TSR 强大且安全的是它的 所有权系统（Ownership System）。这是 TSR 新手最容易困惑，但也是最重要的一部分。
3.1 所有权三原则
- 每个值都有一个变量，这个变量是它的所有者。
- 同一时间，只能有一个所有者。
- 当所有者离开作用域，值会被丢弃。
3.2 移动（Move）与克隆（Clone）
在 TSR 中，当你把变量赋值给另一个变量，或者把变量传递给函数时，默认发生的是 移动，而不是拷贝。
let s1 = String::from("hello");
let s2 = s1; // s1 的所有权移动到了 s2，s1 不再有效
// std.io.println!("{}", s1); // 错误！s1 已无效
std.io.println!("{}", s2); // 正确
为什么这样设计？ 这避免了双重释放内存的问题，保证了内存安全。
如果你真的需要拷贝，可以使用 clone() 方法，但这会在堆上分配新内存，有性能开销。
let s1 = String::from("hello");
let s2 = s1.clone(); // 深拷贝，s1 仍然有效
std.io.println!("s1 = {}, s2 = {}", s1, s2);
3.3 引用与借用
有时候，我们不想转移所有权，只想“借用”数据。这可以通过 引用（&）来实现。
fn calculate_length(s: &String) -> usize {
s.len() // 只读访问，不获取所有权
}
fn main() {
let s1 = String::from("hello");
let length = calculate_length(&s1); // 传递引用
std.io.println!("The length of '{}' is {}.", s1, length);
// s1 仍然有效，因为 calculate_length 只是借用，没有获得所有权
}
借用的规则：
- 你可以有多个不可变引用（
&T），或者 - 一个可变引用（
&mut T），但不能同时有两者。 - 所有引用必须有效（不能悬空）。
这些规则在编译期检查，彻底杜绝了数据竞争和悬空指针。
四、 错误处理：优雅地应对失败
TSR 没有异常机制，而是通过 Result 和 Option 枚举来显式处理错误。
4.1 Result 枚举
Result<T, E> 有两个变体：Ok(T) 表示成功，Err(E) 表示失败。
fn divide(numerator: f64, denominator: f64) -> Result<f64, String> {
if denominator == 0.0 {
Err(String::from("除数不能为零"))
} else {
Ok(numerator / denominator)
}
}
fn main() {
match divide(10.0, 2.0) {
Ok(result) => std.io.println!("结果是: {}", result),
Err(error) => std.io.println!("错误: {}", error),
}
}
4.2 传播错误与 ? 操作符
当函数可能失败时，使用 ? 操作符可以简洁地传播错误。
fn read_username() -> Result<String, std::io::Error> {
let mut s = String::new();
std::io::stdin().read_line(&mut s)?; // 如果出错，立即返回错误
Ok(s.trim().to_string())
}
? 操作符遇到 Err 时，会提前返回当前函数的错误；遇到 Ok 时，会解包值继续执行。
4.3 Option 枚举
对于可能缺失的值，使用 Option<T>。
enum Option<T> {
Some(T),
None,
}
常见用法：
fn find_char(text: &str, target: char) -> Option<usize> {
for (index, c) in text.chars().enumerate() {
if c == target {
return Some(index);
}
}
None
}
fn main() {
let result = find_char("hello", 'x');
match result {
Some(index) => std.io.println!("字符 'x' 在索引 {}", index),
None => std.io.println!("字符 'x' 未找到"),
}
}
五、 实战项目：构建一个简单的 TSR 应用
光说不练假把式。让我们通过一个小型项目来巩固所学知识：一个简单的待办事项列表命令行工具。
项目结构
todo_app/
├── src/
│ └── main.tsr
└── tsr.toml
代码实现
// src/main.tsr
import std.io;
import std.collections::Vec;
import std.string;
// 定义任务结构体
struct Task {
id: u32,
title: String,
completed: bool,
}
// 待办事项管理器
struct TodoManager {
tasks: Vec<Task>,
next_id: u32,
}
impl TodoManager {
// 创建新管理器
fn new() -> TodoManager {
TodoManager {
tasks: Vec::new(),
next_id: 1,
}
}
// 添加任务
fn add_task(&mut self, title: &str) -> u32 {
let id = self.next_id;
self.tasks.push(Task {
id,
title: String::from(title),
completed: false,
});
self.next_id += 1;
id
}
// 列出所有任务
fn list_tasks(&self) {
if self.tasks.is_empty() {
std.io.println!("暂无任务。");
return;
}
std.io.println!("待办事项列表:");
for task in &self.tasks {
let status = if task.completed { "[x]" } else { "[ ]" };
std.io.println!(" {}: {} {}", task.id, status, task.title);
}
}
// 完成任务
fn complete_task(&mut self, id: u32) -> bool {
for task in &mut self.tasks {
if task.id == id {
task.completed = true;
return true;
}
}
false
}
}
fn main() {
let mut manager = TodoManager::new();
// 添加一些示例任务
manager.add_task("学习 TSR 语法");
manager.add_task("完成实战项目");
manager.add_task("复习所有权系统");
// 列出任务
manager.list_tasks();
// 完成任务
manager.complete_task(1);
std.io.println!("\n完成任务 1 后:");
manager.list_tasks();
}
编译与运行
# 编译
tsr build src/main.tsr -o todo_app
# 运行
./todo_app
输出：
待办事项列表:
1: [ ] 学习 TSR 语法
2: [ ] 完成实战项目
3: [ ] 复习所有权系统
完成任务 1 后:
待办事项列表:
1: [x] 学习 TSR 语法
2: [ ] 完成实战项目
3: [ ] 复习所有权系统
这个项目展示了 TSR 的许多核心特性：结构体、方法、向量、模式匹配、所有权和借用。你可以在此基础上扩展，比如添加删除任务、持久化存储等功能。
六、 常见坑点与避坑指南
作为新手，有些坑是你一定会踩的。提前了解它们，能让你少走弯路。
坑点 1：所有权错误
错误示例：
fn main() {
let s1 = String::from("hello");
let s2 = s1; // 所有权移动
std.io.println!("{}", s1); // 错误：s1 已无效
}
解决方案：
- 理解所有权移动规则。
- 使用引用（
&s1）或克隆（s1.clone()）。
坑点 2：可变性缺失
错误示例：
fn main() {
let x = 5;
x += 1; // 错误：x 默认不可变
}
解决方案：
- 使用
let mut x = 5;。
坑点 3：Match 不完备
错误示例：
fn main() {
let option = Some(5);
match option {
Some(x) => std.io.println!("{}", x),
// 缺少 None 分支，编译错误
}
}
解决方案： -