发麻玩rust吧_陈一发儿吧_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0可签7级以上的吧50个
本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：27,797贴子：
发麻玩rust吧
盖房子、画画、钓鱼、打猎、特别有意思的一个游戏
你是否向往大自然的住宅，揭秘小区种植屋面的雨水管理！
最重要的里边的人都不穿衣服
发姐说66喜欢玩这种她还是玩动作的
贴吧热议榜
使用签名档&&
保存至快速回贴RUST空白名字怎么打？是不是复制一段名字然后不显示，求高手支招_rust吧_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0可签7级以上的吧50个
本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：43,690贴子：
RUST空白名字怎么打？是不是复制一段名字然后不显示，求高手支招
你是否向往大自然的住宅，揭秘小区种植屋面的雨水管理！
补充，是正版，steam
来高手啊，求教
来高手，求教啊，空白名字
速度来人啊
啊啊啊啊啊啊啊啊
这些不良的东西还是少搞
贴吧热议榜
使用签名档&&
保存至快速回贴当前位置： &
求翻译：利用EBRUST软件比较本次分离到的ST-4821克隆群与全球其他分离到的ST-4821克隆群的菌株比较，发现主要成4个谱系，st3200为主的谱系为我国台湾地区主要流行株，以ST-4821为核心的ST-4821克隆群，现已发现68个不同ST型，是什么意思？
利用EBRUST软件比较本次分离到的ST-4821克隆群与全球其他分离到的ST-4821克隆群的菌株比较，发现主要成4个谱系，st3200为主的谱系为我国台湾地区主要流行株，以ST-4821为核心的ST-4821克隆群，现已发现68个不同ST型，
问题补充：
Use ebrust software compares the isolated st-4 821 clone groups and global isolated st-4821 clone group strains found epidemic strains mainly into four lineages, st3200 main lineages in Taiwan, China, st-4 821-core st-4 821 clone groups has been found that the 68 st type
正在翻译，请等待...
The ST-4821 clone group strain compares which using the EBRUST software this time separates the ST-4821 clone group and global other which separates to compare, discovered mainly becomes 4 evolutions, the st3200 primarily evolution for our country Taiwan area main popular, take ST-4821 as the core S
With this separation of the EBRUST software to ST-4821 clone ST-4821 clone group of a group and global isolation to other strains of, found mainly into 4 lineages, consisting mainly of st3200 pedigree for the main epidemic strains in Taiwan, with ST-4821 as the core ST-4821 of clone groups, have now
正在翻译，请等待...
我来回答：
参考资料：
* 验证码：
登录后回答可以获得积分奖励，并可以查看和管理所有的回答。 |
我要翻译和提问
请输入您需要翻译的文本！Rust入门篇
声明： 本文是在参考
写的。 个人学习用
再PS. 目录这东东果然是必须的... 找个时间生成个
Hello World
使用 cargo new projectName --bin 创建一个工程cargo build 和 cargo run命令cargo配置文件: 工程下的 Cargo.toml 文件
变量绑定有它们所绑定的的值的所有权。这意味着当一个绑定离开作用域，它们绑定的资源就会被释放。
let a = vec![21];
a.push(90);
let a = 'x';
拓展：Rust是一门静态隐式类型的语言。
类型在编译时推导， 类似也c++11的auto特性
Rust确保了对于任何给定的资源都只有一个绑定与之对应。
let a = vec![1, 2];
println!(&{}&, a[0]);
同其他C-style语言一样， Rust的基本类型具有copy语义
let a = 32;
println!(&{}&, a);
借用(Borrowing)
fn main() {
fn fn1(arg: Vec&i32&) -& u32 {
let a = vec![21, 32];
println!(&{}&, a[0]);
如何解决这个问题？
1. 使用 borrowing
fn main() {
fn fn1(arg: &Vec&i32&) -& u32 {
let a = vec![21, 32];
println!(&{}&, a[0]);
上述的借用都是immutable借用类型， 还有&mut类型。
Rust的借用有一些必须遵守的规则:
在同一作用域中
一个或者多个对资源的引用 &T只有一个mutable引用 &mut
原因: 在编译时避免数据竞争...
let mut x = 5;
let y = &mut
*y += 1;
println!(&{}&, x);
不过，解决这个问题的方法是... 缩小y的作用范围：
let mut x = 5;
let y = &mut
*y += 1;
println!(&{}&, x);
2. 对象克隆
fn main() {
fn fn1(arg: Vec&i32&) -& u32 {
let a = vec![21, 32];
fn1(a.clone());
println!(&{}&, a[0]);
在Rust中，引用必须与它引用的资源存活得一样长！
　　如下两例子:
let r : &i32;
let a = 32;
println!(&{}&, r);
let r : &i32;
let x = 78;
注意在Rust中 生命周期 这概念是与引用/借用紧密关联的它定义了引用有效的作用域。
前面见过的有一个引用类型作为参数的函数，之所以没有看到声明周期这东东。 是因为声明周期省略造成的错觉。
我们可以以 implicit 或者 explicit 的方式来定义一个函数：
fn foo(x: &i32) -& &i32{
fn bar&'a&(x: &'a i32) -& &'a i32{
此外，结构体(struct)也拥有生命周期。
接下来解决struct后再继续...
一个简单的struct：
struct Point {
fn main() {
let origin = Point { x: 0, y: 0 };
println!(&The origin is at ({}, {})&, origin.x, origin.y);
应当注意的地方：
struct不支持字段可变性。因此不能在字段上添加 mut修饰可变性是绑定的一个属性， 让变量在一段时间内可变
为啥这样设计， 举个例子：
struct Point {
fn main() {
let mut point = Point { x: 0, y: 0 };
point.x = 5;
let point =
point.y = 6;
生命周期 · 续
当结构体中具有引用类型的属性时， 结构体就需要使用显示的生命周期。
错误示例：
// error: missing lifetime specifier
正确的写法：
struct Foo&'a& {
x: &'a i32,
fn main() {
let y = &5;
let f = Foo { x: y };
println!(&{}&, f.x);
为什么Foo需要一个生命周期？ 因为我们需要确保Foo中的任何引用不能比它包含的 i32 的引用活的更久。
使用impl在Foo中定义一个方法：
fn main() {
let y = &5;
let f = Foo { x: y };
println!(&{}&, f.x());
struct Foo&'a& {
x: &'a i32,
impl&'a& Foo&'a& {
fn x(&self) -& &'a i32 { self.x }
'a 就是用来赋予作用域一个名字。
下面介绍一个特殊的命名作用域：
在Rust中最常见的： let x: &'static str = &Hello, world.&;
FOO: i32 = 10;
let x: &'static i32 = &FOO;
println!(&{}&, *x);
struct Circle {
radius: f64,
impl Circle {
fn area(&self) -& f64 {
std::f64::consts::PI * (self.radius * self.radius)
fn main() {
let c = Circle { x: 0.0, y: 0.0, radius: 2.0 };
println!(&{}&, c.area());
方法的第一个参数比较特殊。它有3种变体： `self`， `&self` 和 `&mut self`。 通常使用后两种！ 当方法只是读取struct中的数据时使用`&self`。 若要修改数据则使用`&mut self`。
不带self参数的方法就是关联函数。 这是一个Rust代码中非常常见的模式。
impl Circle {
fn new(x: f64, y: f64, radius: f64) -& Circle {
radius: radius,
关联函数的调用： `let c = Circle::new(0.0, 0.0, 2.0);
创建者模式 Builder Pattern
跟C不同，Rust的枚举可携带数据.... 看个例子
enum Message {
ChangeColor(i32, i32, i32),
Move {x: i32, y: i32},
Write(String),
fn process_message(msg: Message) -& i32{
match msg {
Message::Quit =& 32,
Message::ChangeColor(r,g,b) =& r+g+b,
Message::Move{x: x1, y: y1} =& x1 + y1,
Message::Write(s) =& s.trim().parse().ok().expect(&parse error!&),
fn main() {
let a = Message::Q
let b = Message::ChangeColor(1, 2, 3);
let c = Message::Move{x: 32, y: -32};
let d = Message::Write(&88&.to_string());
println!(&{}&, process_message(a));
println!(&{}&, process_message(b));
println!(&{}&, process_message(c));
println!(&{}&, process_message(d));
匹配和模式
let x = 5;
1 =& println!(&one&),
2 =& println!(&two&),
3 =& println!(&three&),
4 =& println!(&four&),
5 =& println!(&five&),
_ =& println!(&something else&),
Rust编译器检查穷尽性，要求对每一个枚举的变量都有一个匹配分支。如果你忽略了一个，除非你用_否则它会给你一个编译时错误。
在匹配语句中使用到：
let my_number = 8;
match my_number {
=& println!(&zero&),
1 | 2 =& println!(&one or two&),
3 ... 10 =& println!(&three to ten&),
=& println!(&something else&)
解构： 对于复合数据类型， 可以在模式中进行解析
struct Point {
let origin = Point { x: -9, y: 0=77 };
match origin {
Point { x, y } =& println!(&({},{})&, x, y),
match origin {
Point { x, .. } =& println!(&x is {}&, x),
fn fn1() -& (i32, i32) {
let (i, _ ) = fn1();
println!(&{}&, i);
模式在Rust中非常强大，以上只介绍了它的几种用法。
类型 Vec&T&， vector总是在堆上分配数据！ 可以使用vec!宏来创建。
let v = vec![1, 2, 3, 4, 5];
let v = vec![0; 10];
let v = vec![32, 43];
println!(&{:?}&, v[3]);
let mut v = vec![1, 2, 3, 4, 5];
for i in &v {
println!(&A reference to {}&, i);
let v = vec![43, 54, 65];
println!(&{:?}&, v.len());
Rust有两种主要的字符串类型：&str和String。
同 C-style 系， let greeting = &Hello there.&; // greeting: &'static str &str编译后存储在程序中， 在运行期间一直存在。
String则不同，是一个在堆上分配的字符串。这个字符串可以增长，并且也保证是UTF-8编码的。
let mut s = &Hello&.to_string();
println!(&{}&, s);
s.push_str(&, world.&);
println!(&{}&, s);
String可以通过一个&强制转换为&str：
let tmp = &鬼&.to_string();
let s = &什么&.to_string() + &
println!(&{:?}&, s);
题外话： 被恶心到了... str + str 和 String + String 是不被允许的
不懂为啥这样设计
Note : 由于let s = &hello&;中&hello&是一个UTF-8编码的字符串，故不能直接用索引来访问字符串的元素。
关于Rust的字符串(如&hello&)， 就好像你在ipython中输入：
注意这里使用的是 python2.7
& a = '严'
& '\xe4\xb8\xa5'
在python中你可以使用a[2]来访问a指向的str。 但这在Rust中是不允许的
---恢复内容结束---
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：722928次
积分：10841
积分：10841
排名：第1213名
原创：100篇
转载：1560篇
译文：25篇
评论：18条
(49)(8)(58)(86)(53)(33)(108)(37)(62)(14)(1)(45)(16)(2)(2)(2)(4)(37)(5)(13)(4)(40)(10)(1)(9)(21)(2)(7)(10)(20)(57)(39)(30)(11)(18)(20)(33)(41)(7)(10)(36)(24)(60)(39)(49)(66)(53)(57)(41)(28)(26)(55)(17)(5)(20)(62)(44)