虚拟货币LAT什么_币圈资讯_鼎鸿网

虚拟货币LAT什么

angula 0
fn main() {   println!("hello rust");}

随着 Facebook 的 Libra 项目出炉,Rust 一下子火了,这是 Rust 有史以来最大的项目,但随着全球数字货币的兴起,Rust 的旅程可能才刚刚开始。

虽然你可能还不太了解 Rust,但在开发者眼中,Rust 真香!

连续 4 年,在 Stack Overflow 开发者「最受喜爱编程语言」评选中,Rust 都是第一名。

连续 4 年成为“开发者最喜欢的语言”,这门编程语言你了解过吗

2015 年 5 月 15 日,Rust 正式发布了 1.0 版本。4 年来,它凭借着「安全」和「高并发」两个特性,受到了越来越多开发者的喜爱。

Rust 正以势如破竹之势占领区块链新兴项目市场,很多著名的老项目也在考虑转向使用 Rust 重写。

Rust 的语言特性(安全、高性能、并发编程)与区块链的特性(分布式、加密、安全敏感)天生契合,很多著名的区块链项目已经选择使用 Rust 作为其开发语言,包括:Parity、Polkadot、Substrate、Grin、Ethereum 经典、Holochain、Cardano-Rust、Exonum、Lighthouse、Nimiq、Nervos、Conflux-Rust、Codechain、Witnet 等,更不用说即将到来的 Libra。

相信,选择使用 Rust 作为第一开发语言的区块链项目也会越来越多,我们会迎来一波的 Rust 语言学习高潮,而区块链开发者的薪资有多高,相信大家都清楚。

实验楼上线了一门【免费】的 Rust 教程 —— 《通过例子学 Rust》。

课程改编自经典教材《Rust By Example》,并根据教材内容配置了线上实验环境,和挑战测试。

每一个知识点都有配套的实例和小练习,让大家轻松地掌握这门语言。

想要学习的朋友可以进入实验楼官网,搜索《通过例子学Rust》噢。

接下来,大家就跟着我熟悉一下 Rust 的一些基础语法吧,用 Rust 写出你的第一个小程序。

本文建议收藏,这样随时都可以拿出来巩固一下基础 Rust 知识。



以下是《通过例子学 Rust》第一节内容:

简介

Rust 是一门注重安全(safety)、速度(speed)和并发(concurrency)的现代系统编程语言。Rust 通过内存安全来实现以上目标,但不用垃圾回收机制(garbage collection, GC)。

本课程为《通过例子学 Rust》的在线实验版本,通过在线实验一系列程序例子,一步步完成 Rust 编程语言的入门。欢迎在课程仓库中参与修订和完善,仓库地址见 通过例子学 Rust - 在线实验版。所有文档内容版权跟随中文及英文原文档的版权(版权为 MIT 协议 或 Apache 协议)。

知识点

本节实验的主要内容包括以下知识点:

  • 课程介绍
  • 如何编写第一个程序
  • Hello World 程序详解
  • 注释
  • 格式化输出

Hello World

我们的第一个程序将打印传说中的 "Hello World" 消息,下面是完整的程序代码和编译运行过程。

这是传统的 Hello World 程序的源码。首先,在实验楼 WebIDE 中 /home/project 目录下新建 hello.rs 文件,编写以下代码(以 // 开头的注释内容可以不必输入):

// 这是注释内容,将会被编译器忽略掉// 可以单击那边的按钮 "Run" 来测试这段代码 ->// 若想用键盘操作,可以使用快捷键 "Ctrl + Enter" 来运行// 这段代码支持编辑,你可以自由地修改代码!// 通过单击 "Reset" 按钮可以使代码恢复到初始状态 ->// 这是主函数fn main() {    // 调用编译生成的可执行文件时,这里的语句将被运行。    // 将文本打印到控制台    println!("Hello World!");}

println! 是一个 宏(macros),可以将文本输出到控制台(console)。

在实验楼 WebIDE 终端中执行以下命令,使用 Rust 的编译器 rustc 从源程序生成可执行文件:

$ cd /home/project$ rustc hello.rs

使用 rustc 编译后将得到可执行文件 hello,使用以下命令来运行生成的文件 hello:

$ ./hello

执行后的结果如下所示:

连续 4 年成为“开发者最喜欢的语言”,这门编程语言你了解过吗

动手试一试

请尝试下在你的 hello.rs 程序中增加一行代码,再一次使用宏 println!,得到下面结果:

Hello World!I'm a Rustacean!

注释

注释对任何程序都不可缺少,同样 Rust 支持几种不同的注释方式。

  • 普通注释,其内容将被编译器忽略掉:
  • // 单行注释,注释内容直到行尾。
  • /* 块注释, 注释内容一直到结束分隔符。*/
  • 文档注释,其内容将被解析成 HTML 帮助文档:
  • /// 为接下来的项生成帮助文档。
  • //! 为注释所属于的项(译注:如 crate、模块或函数)生成帮助文档。
fn main() {    // 这是行注释的例子    // 注意有两个斜线在本行的开头    // 在这里面的所有内容都不会被编译器读取    // println!("Hello, world!");    // 请运行一下,你看到结果了吗?现在请将上述语句的两条斜线删掉,并重新运行。    /*     * 这是另外一种注释——块注释。一般而言,行注释是推荐的注释格式,     * 不过块注释在临时注释大块代码特别有用。/* 块注释可以 /* 嵌套, */ */     * 所以只需很少按键就可注释掉这些 main() 函数中的行。/*/*/* 自己试试!*/*/*/     */     /*      注意,上面的例子中纵向都有 `*`,这只是一种风格,实际上这并不是必须的。      */     // 观察块注释是如何简单地对表达式进行修改的,行注释则不能这样。     // 删除注释分隔符将会改变结果。     let x = 5 + /* 90 + */ 5;     println!("Is `x` 10 or 100? x = {}", x);}

格式化输出

打印操作由 std::fmt 里面所定义的一系列 宏 来处理,包括:

  • format!:将格式化文本写到 字符串(String)。译注:字符串 是返回值不是参数。
  • print!:与 format! 类似,但将文本输出到控制台(io::stdout)。
  • println!: 与 print! 类似,但输出结果追加一个换行符。
  • eprint!:与 format! 类似,但将文本输出到标准错误(io::stderr)。
  • eprintln!:与 eprint! 类似,但输出结果追加一个换行符。

这些宏都以相同的做法解析(parse)文本。另外有个优点是格式化的正确性会在编译时检查。

新建 format.rs 文件,编写代码如下。

fn main() {    // 通常情况下,`{}` 会被任意变量内容所替换。    // 变量内容会转化成字符串。    println!("{} days", 31);    // 不加后缀的话,31 就自动成为 i32 类型。    // 你可以添加后缀来改变 31 的类型。    // 用变量替换字符串有多种写法。    // 比如可以使用位置参数。    println!("{0}, this is {1}. {1}, this is {0}", "Alice", "Bob");    // 可以使用命名参数。    println!("{subject} {verb} {object}",             object="the lazy dog",             subject="the quick brown fox",             verb="jumps over");    // 可以在 `:` 后面指定特殊的格式。    println!("{} of {:b} people know binary, the other half don't", 1, 2);    // 你可以按指定宽度来右对齐文本。    // 下面语句输出 "     1",5 个空格后面连着 1。    println!("{number:>width$}", number=1, width=6);    // 你可以在数字左边补 0。下面语句输出 "000001"。    println!("{number:>0width$}", number=1, width=6);    // println! 会检查使用到的参数数量是否正确。    println!("My name is {0}, {1} {0}", "Bond");    // 改正 ^ 补上漏掉的参数:"James"    // 创建一个包含单个 `i32` 的结构体(structure)。命名为 `Structure`。    #[allow(dead_code)]    struct Structure(i32);    // 但是像结构体这样的自定义类型需要更复杂的方式来处理。    // 下面语句无法运行。    println!("This struct `{}` won't print...", Structure(3));    // 改正 ^ 注释掉此行。}

std::fmt 包含多种 traits(trait 有「特征,特性」等意思)来控制文字显示,其中重要的两种 trait 的基本形式如下:

  • fmt::Debug:使用 {:?} 标记。格式化文本以供调试使用。
  • fmt::Display:使用 {} 标记。以更优雅和友好的风格来格式化文本。

上例使用了 fmt::Display,因为标准库提供了那些类型的实现。若要打印自定义类型的文本,需要更多的步骤。

动手试一试

  • 改正上面代码中的两个错误(见代码注释中的「改正」),使它可以没有错误地运行。
  • 再用一个 println! 宏,通过控制显示的小数位数来打印:Pi is roughly 3.142 (Pi 约等于 3.142)。为了达到练习目的,使用 let pi = 3.141592 作为 Pi 的近似 值。

提示:设置小数位的显示格式可以参考文档 std::fmt。

调试(Debug)

所有的类型,若想用 std::fmt 的格式化 trait 打印出来,都要求实现这个 trait。自动的实现只为一些类型提供,比如 std 库中的类型。所有其他类型都必须手动实现。

fmt::Debug 这个 trait 使这项工作变得相当简单。所有类型都能推导(derive,即自动创建)fmt::Debug 的实现。但是 fmt::Display 需要手动实现。

// 这个结构体不能使用 `fmt::Display` 或 `fmt::Debug` 来进行打印。struct UnPrintable(i32);// `derive` 属性会自动创建所需的实现,使这个 `struct` 能使用 `fmt::Debug` 打印。#[derive(Debug)]struct DebugPrintable(i32);

所有 std 库类型都天生可以使用 {:?} 来打印。新建 format1.rs 文件,编写代码如下:

// 推导 `Structure` 的 `fmt::Debug` 实现。// `Structure` 是一个包含单个 `i32` 的结构体。#[derive(Debug)]struct Structure(i32);// 将 `Structure` 放到结构体 `Deep` 中。然后使 `Deep` 也能够打印。#[derive(Debug)]struct Deep(Structure);fn main() {    // 使用 `{:?}` 打印和使用 `{}` 类似。    println!("{:?} months in a year.", 12);    println!("{1:?} {0:?} is the {actor:?} name.",             "Slater",             "Christian",             actor="actor's");    // `Structure` 也可以打印!    println!("Now {:?} will print!", Structure(3));    // 使用 `derive` 的一个问题是不能控制输出的形式。    // 假如我只想展示一个 `7` 怎么办?    println!("Now {:?} will print!", Deep(Structure(7)));}

在实验楼 WebIDE 终端中编译并运行程序。

$ rustc format1.rs$ ./format1

执行结果如下所示:

连续 4 年成为“开发者最喜欢的语言”,这门编程语言你了解过吗

所以 fmt::Debug 确实使这些内容可以打印,但是牺牲了一些美感。Rust 也通过 {:#?} 提供了「美化打印」的功能:

#[derive(Debug)]struct Person<'a> {    name: &'a str,    age: u8}fn main() {    let name = "Peter";    let age = 27;    let peter = Person { name, age };    // 美化打印    println!("{:#?}", peter);}

将上面代码添加到 format1.rs 中后,编译并运行的结果如下所示:

连续 4 年成为“开发者最喜欢的语言”,这门编程语言你了解过吗

你可以通过手动实现 fmt::Display 来控制显示效果。

显示(Display)

fmt::Debug 通常看起来不太简洁,因此自定义输出的外观经常是更可取的。这需要通过手动实现 fmt::Display 来做到。fmt::Display 采用 {} 标记。实现方式看起来像这样:

// (使用 `use`)导入 `fmt` 模块使 `fmt::Display` 可用use std::fmt;// 定义一个结构体,咱们会为它实现 `fmt::Display`。以下是个简单的元组结构体// `Structure`,包含一个 `i32` 元素。struct Structure(i32);// 为了使用 `{}` 标记,必须手动为类型实现 `fmt::Display` trait。impl fmt::Display for Structure {    // 这个 trait 要求 `fmt` 使用与下面的函数完全一致的函数签名    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {        // 仅将 self 的第一个元素写入到给定的输出流 `f`。返回 `fmt:Result`,此        // 结果表明操作成功或失败。注意 `write!` 的用法和 `println!` 很相似。        write!(f, "{}", self.0)    }}

fmt::Display 的效果可能比 fmt::Debug 简洁,但对于 std 库来说,这就有一个问题。模棱两可的类型该如何显示呢?举个例子,假设标准库对所有的 Vec<T> 都实现了同一种输出样式,那么它应该是哪种样式?下面两种中的一种吗?

  • Vec<path>:/:/etc:/home/username:/bin(使用 : 分割)
  • Vec<number>:1,2,3(使用 , 分割)

我们没有这样做,因为没有一种合适的样式适用于所有类型,标准库也并不擅自规定一种样式。对于 Vec<T> 或其他任意泛型容器(generic container),fmt::Display 都没有实现。因此在这些泛型的情况下要用 fmt::Debug。

这并不是一个问题,因为对于任何非泛型的容器类型, fmt::Display 都能够实现。新建 display.rs 文件,编写代码如下:

use std::fmt; // (使用 `use`)导入 `fmt` 模块使 `fmt::Display` 可用// 带有两个数字的结构体。推导出 `Debug`,以便与 `Display` 的输出进行比较。#[derive(Debug)]struct MinMax(i64, i64);// 实现 `MinMax` 的 `Display`。impl fmt::Display for MinMax {    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {        // 使用 `self.number` 来表示各个数据。        write!(f, "({}, {})", self.0, self.1)    }}// 为了比较,定义一个含有具名字段的结构体。#[derive(Debug)]struct Point2D {    x: f64,    y: f64,}// 类似地对 `Point2D` 实现 `Display`impl fmt::Display for Point2D {    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {        // 自定义格式,使得仅显示 `x` 和 `y` 的值。        write!(f, "x: {}, y: {}", self.x, self.y)    }}fn main() {    let minmax = MinMax(0, 14);    println!("Compare structures:");    println!("Display: {}", minmax);    println!("Debug: {:?}", minmax);    let big_range =   MinMax(-300, 300);    let small_range = MinMax(-3, 3);    println!("The big range is {big} and the small is {small}",             small = small_range,             big = big_range);    let point = Point2D { x: 3.3, y: 7.2 };    println!("Compare points:");    println!("Display: {}", point);    println!("Debug: {:?}", point);    // 报错。`Debug` 和 `Display` 都被实现了,但 `{:b}` 需要 `fmt::Binary`    // 得到实现。这语句不能运行。    // println!("What does Point2D look like in binary: {:b}?", point);}

程序运行的结果如下所示:

连续 4 年成为“开发者最喜欢的语言”,这门编程语言你了解过吗

fmt::Display 被实现了,而 fmt::Binary 没有,因此 fmt::Binary 不能使用。 std::fmt 有很多这样的 trait,它们都要求有各自的实现。这些内容将在 后面的 std::fmt 章节中详细介绍。

动手试一试

检验上面例子的输出,然后在示例程序中,仿照 Point2D 结构体增加一个复数结构体。使用一样的方式打印,输出结果要求是这个样子:

Display: 3.3 + 7.2iDebug: Complex { real: 3.3, imag: 7.2 }

测试实例:List

对一个结构体实现 fmt::Display,其中的元素需要一个接一个地处理到,这可能会很麻烦。问题在于每个 write! 都要生成一个 fmt::Result。正确的实现需要处理所有的 Result。Rust 专门为解决这个问题提供了 ? 操作符。

在 write! 上使用 ? 会像是这样:

// 对 `write!` 进行尝试(try),观察是否出错。若发生错误,返回相应的错误。// 否则(没有出错)继续执行后面的语句。write!(f, "{}", value)?;

另外,你也可以使用 try! 宏,它和 ? 是一样的。这种写法比较罗嗦,故不再推荐, 但在老一些的 Rust 代码中仍会看到。使用 try! 看起来像这样:

try!(write!(f, "{}", value));

有了 ?,对一个 Vec 实现 fmt::Display 就很简单了。新建 vector.rs 文件,编写代码如下:

use std::fmt; // 导入 `fmt` 模块。// 定义一个包含单个 `Vec` 的结构体 `List`。struct List(Vec<i32>);impl fmt::Display for List {    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {        // 使用元组的下标获取值,并创建一个 `vec` 的引用。        let vec = &self.0;        write!(f, "[")?;        // 使用 `v` 对 `vec` 进行迭代,并用 `count` 记录迭代次数。        for (count, v) in vec.iter().enumerate() {            // 对每个元素(第一个元素除外)加上逗号。            // 使用 `?` 或 `try!` 来返回错误。            if count != 0 { write!(f, ", ")?; }            write!(f, "{}", v)?;        }        // 加上配对中括号,并返回一个 fmt::Result 值。        write!(f, "]")    }}fn main() {    let v = List(vec![1, 2, 3]);    println!("{}", v);}

程序运行的结果如下:

连续 4 年成为“开发者最喜欢的语言”,这门编程语言你了解过吗

动手试一试:

更改程序使 vector 里面每个元素的下标也能够打印出来。新的结果如下:

[0: 1, 1: 2, 2: 3]

格式化

我们已经看到,格式化的方式是通过格式字符串来指定的:

  • format!("{}", foo) -> "3735928559"
  • format!("0x{:X}", foo) -> "0xDEADBEEF"
  • format!("0o{:o}", foo) -> "0o33653337357"

根据使用的参数类型是 X、o 还是未指定,同样的变量(foo)能够格式化成不同的形式。

这个格式化的功能是通过 trait 实现的,每种参数类型都对应一种 trait。最常见的格式化 trait 就是 Display,它可以处理参数类型为未指定的情况,比如 {}。

新建 format2.rs 文件,编写代码如下:

use std::fmt::{self, Formatter, Display};struct City {    name: &'static str,    // 纬度    lat: f32,    // 经度    lon: f32,}impl Display for City {    // `f` 是一个缓冲区(buffer),此方法必须将格式化后的字符串写入其中    fn fmt(&self, f: &mut Formatter) -> fmt::Result {        let lat_c = if self.lat >= 0.0 { 'N' } else { 'S' };        let lon_c = if self.lon >= 0.0 { 'E' } else { 'W' };        // `write!` 和 `format!` 类似,但它会将格式化后的字符串写入        // 一个缓冲区(即第一个参数f)中。        write!(f, "{}: {:.3}°{} {:.3}°{}",               self.name, self.lat.abs(), lat_c, self.lon.abs(), lon_c)    }}#[derive(Debug)]struct Color {    red: u8,    green: u8,    blue: u8,}fn main() {    for city in [        City { name: "Dublin", lat: 53.347778, lon: -6.259722 },        City { name: "Oslo", lat: 59.95, lon: 10.75 },        City { name: "Vancouver", lat: 49.25, lon: -123.1 },    ].iter() {        println!("{}", *city);    }    for color in [        Color { red: 128, green: 255, blue: 90 },        Color { red: 0, green: 3, blue: 254 },        Color { red: 0, green: 0, blue: 0 },    ].iter() {        // 在添加了针对 fmt::Display 的实现后,请改用 {} 检验效果。        println!("{:?}", *color)    }}

程序运行的结果如下:

连续 4 年成为“开发者最喜欢的语言”,这门编程语言你了解过吗

在 fmt::fmt 文档中可以查看格式化 traits 一览表和它们的参数类型。

动手试一试

为上面的 Color 结构体实现 fmt::Display,应得到如下的输出结果:

RGB (128, 255, 90) 0x80FF5ARGB (0, 3, 254) 0x0003FERGB (0, 0, 0) 0x000000

如果感到疑惑,可看下面两条提示:

  • 你可能需要多次列出每个颜色,
  • 你可以使用 :02 补零使位数为 2 位。

实验总结

本节实验中我们学习了以下的内容:

  • 课程介绍
  • 如何编写第一个程序
  • Hello World 程序详解
  • 注释
  • 格式化输出



还想继续学习的小伙伴,记得登录实验楼,搜索《通过例子学 Rust》哦,本课免费学!

虚拟货币LAT什么文档下载: PDF DOC TXT