去年秋季已经参加过一次训练营，完成了第一阶段和第二阶段的一半，因此这次训练营的第一阶段完成得很快，只用了两三天左右，感知到的最显著的变化是后面算法题的加入：

• 单向链表的合并：涉及 NonNull
• 双向链表的反序
• 排序算法的实现
• 二叉查找树的插入、搜索
• 图的广度及深度优先搜索算法实现
• 使用栈来检测括号是否配对
• 使用队列实现栈
• 实现二叉堆的插入、遍历
• 实现图

在尝试解决这些问题的过程中，我查阅了许多资料，了解到了很多未曾听说过的概念，希望在第二阶段里也能跟上进度，一路披荆斩棘。

2024春夏季开源操作系统训练营第一阶段总结报告

我对于操作系统有一定兴趣，在被同学推荐了这个OS训练营后，便按步骤开始了训练，现在我将第一阶段任务完成，汇总为这篇第一阶段总结报告。

虽然以前用过其他编程语言，但由于之前从未接触过rust语言，在完成前100道题时几乎每一道题都被编译器疯狂拷打，实属让我回想起刚接触编程时的痛苦回忆了，但在历经100题的磨练后，我才能发现rust如此设计都是有一定理由的（虽然不是全部的特性都能理解到），后10道算法题在有rust基础后其实实现是比较简单的，虽然还会被编译器拷打。

总而言之，第一阶段是基础，便于我们后续阶段的展开，希望后续我能继续保持这份热情，完成后续阶段。

南京大学  吴奕胜

初见 Rust

训练营第一阶段的学习过程中，我初步掌握了一门新的编程语言 rust。这是我第一次接触到一门比较”新鲜”的编程语言，相较于课堂上学习的 C/C++，这无疑是一门更加现代也更加复杂的编程语言，拥有不少闻所未闻的新概念，新特性，当然，这也导致 rust 的学习并没有那么轻松。

余观夫 rust 之难，在”所有权”之义。入门阶段所以为惑者，所有权占十之八九。

我如何理解所有权？

C/C++ 中，一个变量名被映射到唯一一个内存中有实际含义的内容，反之不成立，我们可以使用指针很轻松地做到这一点。rust 所做的，正是保证这个”反之”的成立，将一块内容唯一对应于一个所有者，当所有者生命周期结束时，内存也被回收，这就保证了内存安全。

这样做的好处很明显，我们可以断言在满足所有权规则的前提下，内存的使用总是安全的；但是坏处也很明显，由于所有权机制的存在，不少在 C/C++ 中可以很简单地实现的数据结构或者函数，在 rust 可能需要费一番功夫。

把我们所学的 rust 的新特性做个分类，大致也就是两类：

• 为了实现特定功能而实现的特性
• 为了补充所有权机制的灵活性而存在的特性

这一点很好地体现在智能指针、unsafe rust 之类的概念里，虽然这可能造成很多麻烦，但长期来看终究是利大于弊，rust 严格得看起来有些偏执的编译器在教会我们，一个优秀的程序员应该在编程的过程中注意什么，不是吗？

令人耳目一新的枚举类型

初学 rust，其中的枚举类型让我赞叹不已。我之前只学习了 C/C++ 语言，并且实际上只是学习了 C 和部分的 C++，C 中的枚举类型让程序员可以赋予某些值以现实的语义，但是并不好用。

在某个课程中，我们被要求实现一个游戏，游戏要求实现一个可以在地图中上下左右移动的人物，人物还需要可以执行诸如放炸弹之类的功能，部分动作可能有附带的属性。对于每一个动作，我们当然可以实现一个类，用以表示指令，但是这样做显然是不够简洁的，而用 rust 中的枚举功能，则可以优雅地实现。

再比如编译原理课程中，我们要实现类型检查，那么很自然的就是要实现一个结构体，用以表示各种类型。在这个结构体中，一个枚举类型用以表示当前类型，一个 union 中保存了该种类型附加的信息。即使使用到了 union 这样的关键字减少冗余的部分，也并不优雅，如果换成 rust，则可以用一个枚举类型实现类型系统，相当简洁明了，且优雅。

说到底，枚举类型好用还是其成员可以附带一些信息，这是一般的枚举做不到的，并且即使用结构体或类等实现了类似的功能，也远不如 rust 中枚举的实现优雅。

模式匹配——优雅版本的 switch

说模式匹配是优雅版本的 switch 其实也有失偏颇，毕竟模式匹配的功能要比后者多多了，但更多的时候（至少在入门学习阶段），主要的用法还是这两种：

• 用于解构元组、枚举等等
• 用于匹配特定的分支

先来说说 switch 让我感觉最不舒服的地方，就是每个分支后面需要加上一个 break，在编译原理课程实验中，对语法树进行语义分析的过程中，时常需要根据产生式的类型实现不同的功能，由于某些稀奇古怪的原因，在写代码的时候会漏掉 break，这会导致比漏掉 break 的原因还稀奇古怪的结果。

相比之下，rust 中的模式匹配就避免了这个问题，同时也让逻辑一致的情况可以使用 | 合并到同一个分支，相较于 switch 中省略 break 的写法，可以消除很多潜在的问题。

Option<T> 和 Result<T, U>

在以往的编程经验中，我常常碰到需要表达”没有”的语义的情况，这时候可能会使用一个极大值或者 $0$ 等约定的值来表达。比如在我们在表示一个无权图中不存在的边时，可以使用 $0$ 来表示，但如果是一个有权图呢？根据我们要解决的问题不同，用 $0$ 或者极大值的情况都有，这就造成了一些潜在的麻烦。Option<T> 就很好地解决了这个问题。我知道，其实 C++ 中已经有类似的功能了，但是就使用方便程度来讲，模式匹配加上 Option<T> 可以称得上是一个大杀器了。

而错误处理也很自然地解决了需要调用者自行处理问题的情况。以往的编程经验中，遇到需要传递错误信息的情况往往是通过某些约定的值，这些值被假设不在函数返回值的域中，通过这些值来告诉调用者出现了什么问题。Result<T, U> 显然是更好的实现方法。

说到底，我们想要表达的”空”的语义和”幺元”的语义并不总是一致的，又或者在函数返回的域中并没有不会用到的值，这就导致了”空”的语义不好表达，这个情况下，带值的枚举真香。

我的收获

上面提到的内容，大体上就是所有 rust 给我带来最印象深刻的地方了，当然，rust 还有不少精心设计的语言特性，不过由于我的编程经验不够，并不能直接说出这些特性好在哪，也并没有被这些特性震撼到，不过，我心里也埋下了这样一颗种子，如果在将来的学习工作中遇到了什么问题，再回过头来看如今所学，或许就能有更深刻的理解了。

这是我第一次学习一门”课外语言”，这样的体验是很有价值的，不管是对我学习使用这门语言本身来说，还是对我更深入理解以前学习过的语言来说。前面所写的几节内容都是我在学习比较 rust 过程中的切身体会，比学习优秀的设计更重要的是，我知道了一个没那么优秀的设计不好在哪里。

无论怎样，第一阶段的学习落下帷幕，接下来需要进入第二阶段攻克更加困难的主题，这是十分激动人心的。祈祷中……

have done the orginal rustlings test before, try again and also get something to learn

not only the tech an trick experience , but also the design philosophy behind the language.

RoadBlock

0 variales

varaibles5.rs

• shadowing: use let

1 primitive_types

primitive_types3.rs

• shorthand to create an arry: [elment; times]

primitive_types4.rs

• Ownership, borrow, ref: &
• slice: [ .. ]

2 vector

vecs1.rs

• Vec::new()
• macro: vec![elements… ]

vecs2.rs

• two ways
  • direct: use *
  • map:
• used to do in the * way, now prefer the map way

3 move_semantics

move_semantics1.rs

• ownership, borrow: the new va. takes the ownership from the old, the old can not be accessible
• mutable

move_semantics2.rs

• clone()
• mutally borrow a reference to its argument: the next exec

move_semantics6.rs

• ownership

4 struct

structs3.rs

• self

5 enums

enums3.rs

• match

  1 2 3 4 5

  match expr1 { type1 => { expr2 }, type2(var) => { expr3 }, _ => {} }

• match allows us to compare a value to a series of patterns and execute the code based on the matching pattern

  • A pattern can consist of literal quantities, variables, wildcards, and many other things
  • bind partial values of matching patterns

• the return value of one branch is the return value of the whole match expection

6 strings

string1.rs

• lifetime
• to_string()
• From

strings3.rs

• RTFD(RTFM): Read the fxxxx document(mannul)
• STFW

string4.rs

• std

7 modules

modules1.rs

• private default
• pub

modules2.rs

• use xx as xxx

modules3.rs

• use xx :: {yy, zz}

8 HashMap

hashmap1.rs

• <key, value>
• Hash::new()
• insert()

hashmap2.rs

• entry() and or_insert()

hashmap3.rs

• well, read the answer I wrote last time
• have ideas, but stuck on &mut T

quiz2.rs

• stuck on modules and strings for a while

9 Options

options1.rs

• Option, Some(), None
• unwrap() or match
• read the answer of match way

options2.rs

• if let statement and while let statement
• read the answer: think in the reverse way, .unwrap() – Some()

options3.rs

• Bind by reference during pattern matching.
  ref annotates pattern bindings to make them borrow rather than move.
  It is not a part of the pattern as far as matching is concerned: it does not affect whether a value is matched,
  only how it is matched.

10 error_handling

error1.rs

• Result<T, E>
  • Ok(T)
  • Err(E)

error2.rs

• ? – match

• If the value of Result is OK, the expression will return the value in OK and the program will continue.
  If the value is Err, Err is used as the return value for the entire function,
  as if the return keyword were used, so that the error value is propagated to the caller.

error3.rs

• the ? is valid only in function that -> Result<T, E>
• in main function, use () to present nothing needed

error4.rs

• kind of read the answer

error5.rs

• trait
• Box<T>: A pointer type that uniquely owns a heap allocation of type T.
• dyn

error6.rs

• stuck, read the answer; .map_err()

11 generics

generics2.rs

• <T>
  • functions: fn func_name(arg: T) -> T
  • structs: struct StructName
  • traits: trait TraitName
  • impl StructName { … }

12 traits

traits1.rs

• trait: A trait defines a set of behaviors that can be shared, and once the train is implemented,
• you can use that set of behaviors.
  • similar to interface
• trait trait_name { … }
  • impl trait_name for StructName { … }

traits4.rs

• traits as parameters

traits5.rs

• multiple traits: impl Trait1 + Trait2 + Trait3 for StructName { … }

quiz3.rs

• stuck, but according to the compiler info, fix it

13 lifetimes

lifetimes1.rs

• lifetime: When returning a reference from a function,the lifetime parameter for the return type needs
• to match the lifetime parameter for one of the parameters
  • follow the compiler
  • ‘a: fn funcName<’a>(x : ‘a i32) -> &’a str

lifetimes2.rs

• same mark, same lifetime
• paths:
  • make y live longer
  • make println! inner

lifetimes3.rs

• lifetime in struct: struct StructName<'a> { field: 'a type1 }

14 tests

tests1.rs

• assert!(condition, “{}”, message)

tests4.rs

• attribute should_panic

15 iterators

iterators1.rs

• iter(), next ()

iterators3.rs

• .map(), collect()

iterator4.rs

• into_iter() and fold(): e.g. iterator.fold(initial_value, |acc, x | { acc + x })

• The fold() method is similar to the iterator’s forEach() method, but it returns a value.

• Folds every element into an accumulator by applying an operation, returning the final result.

  fold() takes two arguments: an initial value, and a closure with two arguments: an ‘accumulator’, and an element.
  The closure returns the value that the accumulator should have for the next iteration.

  The initial value is the value the accumulator will have on the first call.

  After applying this closure to every element of the iterator, fold() returns the accumulator.

  This operation is sometimes called ‘reduce’ or ‘inject’.

iterators5.rs

• more familiar with the iter(), map() and fold()

16 smart_pointers

box1.rs

• compile time
• Box: a smart pointer used to store data on the heap, which also allows us to wrap a recursive type.

rc1.rs

• Rc<T>: used for multiple owners
• clone(), Rc::clone() and drop()

arc1.rs

• Arc: used for multiple owners, but it is thread-safe
• clone()

cow1.rs

• Cow(Copy-On-Write type): It can enclose and provide immutable access to borrowed data,
  
  and clone the data lazily when mutation or ownership is required.
  
  The type is designed to work with general borrowed data via the Borrow trait.
• Cow::Owned() and Cow::Borrowed()
• well, this is a little confusing, got stuck; solved by simulating the code above TODOs and the answer wrote before

17 threads

threads1.rs

• thread::spawn(): create a new thread and run the closure in it; -> JoinHandle
• move: move the value into the closure
• join(): wait for the thread to finish, return the result

threads2.rs

• Mutex<T>: A mutex is a mutual exclusion primitive that can be used to protect shared data
  
  • lock() : -> LockResult<MutexGuard<’_, T>>
• Arc<T>:

threads3.rs

• std::sync::mpsc: multi-producer, single-consumer channel, sending end and receiving end
• clone()
• well, I did get stuck on this one last time, this time go smoothly.

18 macros

The term macro refers to a family of features in Rust:

• declarative macros with macro_rules! and
• three kinds of procedural macros:
  • Custom #\[derive\] macros that specify code added with the derive attribute used on structs and enums
  • Attribute-like macros that define custom attributes usable on any item
  • Function-like macros that look like function calls but operate on the tokens specified as their argument

macros2.rs

• the order of definition and use matters

macros3.rs

• [macro_use]

macros4.rs

• use ; to separate the macro arms

19 clippy

clippy1.rs

• constant s

clippy2.rs

• let Some(x) = option
• there was a bug, solved

clippy3.rs

• std::mem::swap, vec.clear()

20 conversions

using_as.rs

• as operator: type casting and renaming imports

from_into.rs

• The From trait is used for value-to-value conversions. If From is implemented correctly for a type,
  
  the Into trait should work conversely.
• copilot this time; I dit get stuck on this last time for a while, solved eventually
• impl From\<T\> for U

from_str.rs

• copilot this time; did get stuck on this last time for a while, solved eventually
• iterators: next(), last()
• parse::\<T\>()

try_from_into.rs

• TryFrom and TryInto traits are provided by the standard library to support this conversion.
  • impl TryFrom\<From\> for To and -> Result\<T, E\>
• tuple and array will be checked at compile time, struct will be checked at runtime,
• slice implementation needs to check the slice length,

as_ref.rs

• trait bound: AsRef\<T\> and AsMut\<T\>

21 tests-II

tests5.rs

• unsafe: item declaration and code block
• The unsafe keyword has two uses:
  • to declare the existence of contracts the compiler can’t check (unsafe fn and unsafe trait),
  • and to declare that a programmer has checked that these contracts have been upheld (unsafe {} and unsafe impl,
    
    but also unsafe fn – see below).
• confusing

tests6.rs

• Box: Box::into_raw() and Box::from_raw()

tests7.rs || build.rs || tests8.rs

• build.rs
  • Building a bundled C library.
  • Finding a C library on the host system.
  • Generating a Rust module from a specification.
  • Performing any platform-specific configuration needed for the crate.

test9.rs

• ABI
• extern
  • “C” for C-like ABI, “stdcall” for Windows ABI, “C++” for C++ ABI,
    
    “Rust” for Rust ABI, “system” for system ABI”
  • #[linkname = “..”]
  • export symbol to the linking environment, e.g. extern "C" fn funcName()
• mangle symbol name: `#[no_mangle]
• confused, copilot; the attributes should be applied properly

22 algorithm

algorithm1.rs – merge linked list

• got stuck for a long time, not the fault of not understanding linked list, but those features
• impl<T: PartialOrd + Clone>: a trait bound that specifies requirements for the type T.

algorithm2.rs – reverse double linked list

• a little confused, but solved

algorithm3.rs – sort, bubble sort

• copilot for the trait Ord

algorithm4.rs – bst, the binary search tree

• glad it’s not avl tree
• recursion

algorithm5.rs – bfs, adjacency matrix

• VecDeque, bfs, visited, Adjacency matrix
• familiar with this one, with VecDeque, solved quickly

algorithm6.rs – dfs, adjacency matrix

• smooth

algorithm7.rs – stack, vec

• copilot when the match arm

algorithm8.rs – impl stack with queues

• with one queue
  • push: just push
  • pop: pop the pre and push them again, loop queue.size - 1 times
• with two queues – this way this time
  • make sure that the new element is in the front of the queue, and one queue is empty
  • use one empty queue q1 to store the new, move the rest of elements from the other queue q2 to the cur queue q1,
  • then use the other queue q2 to store the next new element, move the rest of elements from the cur queue q1 to the other queue q2,

algorithm9.rs – binary heap

• although aware of that heap keeps the smallest or the biggest element at the top, often used in the k-th min or max problem
• not so familiar with this one, stfw, gpt, copilot
• use vec to implement heap: the parent’s index (i - 1) / 2, the left child’s index 2 * i + 1, the right child’s index 2 * i + 2, start from 0
• add: after push, use heapify_up
• heapify_up: continuous swap until the parent is smaller(or greater, depending on the heap type) than the child
• smallest_child_idx: the smallest child idx
• next: iterate to get the smallest element

algorithm10.rs – graph: adjacency table, undirected graph

• copilot a little for programming quickly, like finding elem in hashmap, trying to insert new elem into hashmap

rCore 三周rust折磨记录

前言

本人是大三的菜鸡一枚, 因为突然一时兴起,想好好学习下操作系统,又同时看到了这个课程,于是跟着课程一起开始学习了rust.

rustlins 通关记录

说起来也比较惭愧, 学了三周的rust,我对一些东西感觉还是模模糊糊,没有掌握清楚,这可能跟我没有按时听课有关系,忙着找实习笔试和面试(悲).
前30道题比较入门, 我是跟着进度来的, 到前70道题也都还好. 结果70-110 真的把我绕晕了, 又是去官网看英文资料, 又是去查别人的博客,还有问群里的大佬.
我们3群给我的感觉还是很温馨的,很多愚蠢的问题,大佬们都细心的解答.

说到rust, 感触最深的就是它的安全性, 可变引用只能有一个,这条规则把我恶心了好久 呜呜呜. 还有所有权的转移问题. 要时时刻刻注意用clone或者borrow_mut来避免所有权转移.
其实刚开始学习的时候, 我觉得也没什么吗, 不就是cpp里的unique_point吗, 我也学过, 但实际写起来就是容易忘记. 还有各种生命周期的问题, 以及范型要注意trait的限制, 真是太安全了. 无奈的转向了 unsafe 大法().

总的来说, 我还是很喜欢rust的, 但还是有很多东西需要学习, 希望能在后续的学习中, 能有所进步. 期待第二阶段的学习!!!

前言

首先非常感谢陈渝老师和向勇老师提供开源操作系统训练营这个平台，在去年机缘巧合下知道了这个训练营，但当时只是报名了，作业都没领取。这次是第一次正式参加，算是一次挑战吧，push自己走出舒适区。

环境配置

安装rustlings之前要安装gcc编译器，用包管理器也安装不了，试过用aptitude解决依赖问题，最后是更新了系统软件包就装好了。

参考资料

Rust 程序设计语言

通过例子学 Rust

Rust语言圣经(Rust Course)

Pro Git 中文版 (第二版)

学习总结

Rust作为一种系统级编程语言，具有内存安全性、并发性和高性能的特点。在学习过程中，通过 Rustlings 这个练习题库，对 Rust 语言有了更深入的了解和掌握。

Rustlings 提供了一系列简单到复杂的练习题目，涵盖了 Rust 语言的各个方面，从基础的语法到高级的模式匹配、并发等。同时，Rustlings 的反馈机制非常及时和友好。这种及时的反馈可以快速纠正错误。前面100道题主要是熟悉语法，做一些小的改动就可以过了。后面10道题是算法，因为之前学习对算法掌握的不够扎实，花了几天时间去重新学习了一下。

虽然做完了rustlings的题目，但是感觉这只是入门，如果没有gpt估计要做好久。

艰难的开头

第一次参加训练营对rust也是零基础，刚开始还有点担心，而且开放第一天立马就有好几个大佬交了直接满分通过，真给我吓到了。

不过潜下心来认真做还是很快进入了高强度学习的状态。

每道题目给的提示和对应的rust文档都很有帮助，前面题目难度不算很大，主要是有一些rust的规则或者说特性有点难以理解，生命周期和特性确实是好一番折腾，到现在也不敢说弄明白了。那部分题边做边看着报错改稀里糊涂的就做过去了。

我做完rustlings也算比较早的，不过blog拖了这么久，一个是考试，一个是有些简单的规则感觉没必要特意写在笔记里，而复杂的例如生命周期和特性这部分还真没完全搞懂。还是得慢慢学慢慢练，rust基础还是差得远。

最后这几天还连续发高烧人差点烧傻了。

二阶段能做完一半就算胜利！

第一阶段练习总结

作为一名Cpper，我之前对Rust的了解可以说是毫无了解，这次受到朋友的邀请，第一次接触Rust，刚开始以为就是像C一样的过程语言。然而，当我真正开始深入学习和使用Rust时，我发现它远比我预想的要有趣和富有挑战性。特别是在进行Rustlings练习的过程中，我收获颇丰，也深刻体会到了Rust语言的强大和魅力。

Rustlings是一个设计精良的Rust语言练习项目，通过一系列由简到难的练习题，帮助开发者逐步掌握Rust的语法和特性。在练习的过程中，我遇到了许多看似简单但实则深奥的问题，这些问题让我不断思考和探索，也让我对Rust有了更深入的理解。

通过Rustlings的练习，我只能感叹面向编译器编程的魅力。

此外，Rustlings的练习还让我认识到了自己在编程思维方面的不足总的来说，Rustlings练习是我学习Rust过程中的一个重要环节。它不仅让我掌握了Rust的基本语法和特性，还锻炼了我的编程思维和解决问题的能力。我相信，在未来的学习和工作中，我会继续利用Rustlings等资源来深化对Rust的理解和应用，并不断提升自己的编程水平。同时，我也期待在未来的项目中能够充分发挥Rust的优势，写出更加健壮、高效的程序。

生命周期

Rust 的生命周期（lifetime）是一种编译时检查机制，它用来确保引用的有效性，防止悬垂指针和数据竞争等安全问题。生命周期在 Rust 中的作用非常关键，主要体现在以下几个方面：

生命周期注解：Rust 使用生命周期注解来标记引用的有效期。最常见的生命周期注解是 ‘a，这是一种显式标注，用来表明相关的引用必须至少与 ‘a 生存期一样长。
函数与方法中的生命周期：当函数或方法返回引用或使用引用作为参数时，必须显式指定生命周期。Rust 编译器（通过借用检查器）使用这些注解来确保数据的有效性。例如：

1
2
3

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

这里，’a 指明 x 和 y 的引用以及返回值的引用必须拥有相同的生命周期。
结构体中的生命周期：当结构体中含有引用时，也需要使用生命周期注解来确保引用不会在结构体实例存在时失效。例如：

1
2
3

struct Important<'a> {
    part: &'a str,
}

这个结构体表明 part 的生命周期 ‘a 必须至少与结构体 Important 的实例一样长。
生命周期省略规则（Lifetime Elision Rules）：Rust 有一套自动推导生命周期的规则，这可以在许多简单情况下省略显式的生命周期注解。例如，单个输入生命周期可以被自动推导，函数返回的引用通常被认为与某个输入引用具有相同的生命周期。
生命周期与泛型的结合：在泛型类型或函数中使用生命周期参数，可以使得类型或函数更加灵活与安全。例如：

1
2
3

struct Wrapper<'a, T> {
    value: &'a T,
}

这里 T 是泛型类型，而 ‘a 是生命周期参数，表示 value 的引用至少与 Wrapper 实例持续相同的时间。
总的来说，Rust 的生命周期特性是为了在编译时进行严格的内存安全检查，通过这种方式帮助开发者写出更安全的代码，避免运行时错误。

总结

很久之前就学会rust并用于工作，所以这次训练营的rust部分对我来说是比较简单的。
期待这次训练营的实操，Rust 会给我一个怎样的编程体验。

总结

之前写过一遍rustlings, 所以这次前 100 题刷得比较快. 虽然说之前写过, 但是这次基本没有之前的 repo, 从头自己写了一遍, 还是学到了很多很多, 对Rust的各种特性也更加熟悉了.

个人觉得后面助教加的algorithm还是很有意思的. 大部分的Rust教程只有语法还有特性, 很少有关于如何写算法的. 特别是关于unsafe的使用, 大家好像都对于unsafe如临大敌, 都不敢用. 事实上, 要写出性能好的底层代码, 感觉unsafe还是必不可少的. 后面的图论也挺有趣的, 让同学们在写算法的同时, 熟悉了Rust的各种容器的使用. 就是希望提示能够再清楚明确一些吧.