分类 软件开发 下的文章

在这一章中,在实例的帮助下,学习如何使用函数并从中返回值。

就跟任何现代编程语言一样,Rust 也有函数。

你已经熟悉的函数是 main 函数。这个函数在程序启动时被调用。

但是其他函数呢?在本文中,你将学习如何在 Rust 程序中使用函数。

函数的基本语法

你可能已经在我们声明 main 函数时知道了这一点,不管怎么样,还是让我们看一下声明函数的语法。

// 声明函数
fn function_name() {
    <statement(s)>;
}

// 调用函数
function_name();

来让我们看一个简单的函数,它将字符串 "Hi there!" 打印到标准输出。

fn main() {
    greet();
}

fn greet() {
    println!("Hi there!");
}
? 与 C 不一样的是,不管你是否要在声明或定义之前调用函数都没有关系。只要这个函数在 某个地方 被声明了,Rust 就会处理它。

正如预期,它的输出如下:

Hi there!

这挺简单的。让我们把它提升到下一个级别。让我们创建一个接受参数并返回值的函数。有没有参数和有没有返回值这两者之间无关。

使用函数接受参数

声明一个接受参数的函数的语法如下:

// 声明函数
fn function_name(variable_name: type) {
    <statement(s)>;
}

// 调用函数
function_name(value);

你可以把函数参数想象成一个传递给函数的 元组。它可以接受多种数据类型的参数,而且你可以接受任意多个参数。所以,你不必局限于接受相同类型的参数。

与某些语言不同的是,Rust 没有 默认参数在调用函数时填充所有参数是强制性的

示例:饥饿函数

来让我们看一个程序来更好地理解这个。

fn main() {
    food(2, 4);
}

fn food(theplas: i32, rotis: i32) {
    println!(
        "我饿了... 我需要 {} 个葫芦巴叶饼和 {} 个罗提!",
        theplas, rotis
    );
}

在第 5 行,我声明了一个名为 food 的函数。这个函数接受 2 个参数:theplasrotis(印度食物的名字)。然后我打印了这些变量的内容。

对于 main 函数,我使用参数 24 调用 food 函数。这意味着 theplas 被赋值为 2rotis 被赋值为 4

来让我们看一下程序的输出:

我饿了... 我需要 2 个葫芦巴叶饼和 4 个罗提!

我现在真的饿了... ?

从函数返回值

就像函数可以接受参数一样,函数也可以返回一个或多个值。这样的函数的语法如下:

// 声明函数
fn function_name() -> data_type {
    <statement(s)>;
}

// 调用函数
let x = function_name();

函数可以使用 return 关键字或者使用表达式而不是语句来返回一个值。

等等!什么是表达式?

在进一步之前:语句与表达式

在讲解 Rust 函数的例子中提起这个可能不太合适,但是你应该理解 Rust 和其他编程语言中语句和表达式的区别。

语句是以分号结尾且 不会计算出某个值 的代码行。另一方面,表达式是一行不以分号结尾且计算出某个值的代码行。

来让我们用一个例子来理解:

fn main() {
    let a = 873;
    let b = {
        // 语句
        println!("Assigning some value to b...");

        // 表达式
        a * 10
    };

    println!("b: {b}");
}

在第 3 行,我开始了一个代码块,在这个代码块中我有一个语句和一个表达式。注释标明了哪个是哪个。

在第 5 行的代码不会计算出某个值,因此需要以分号结尾。这是一个语句。

第 8 行的代码计算出了一个值。它是 a * 10873 * 10),并计算出了 8730。因为这一行没有以分号结尾,所以这是一个表达式。

? 使用表达式是从代码块中返回某些东西的一种方便的方法。因此,当返回一个值时,它是 return 关键字的替代方案。表达式不仅仅用于从函数中 “返回” 一个值。正如你刚刚看到的,a * 10 的值是从内部作用域 “返回” 到外部作用域,并赋值给变量 b。一个简单的作用域不是一个函数,但表达式的值仍然被 “返回” 了。

示例:购买腐烂的水果

来让我们看一个演示以理解函数如何返回一个值:

fn main() {
    println!(
        "如果我从水果摊买了 2 公斤苹果,我必须付给他们 {} 印度卢比。",
        retail_price(2.0)
    );
    println!(
        "但是,如果我从水果摊买了 30 公斤苹果,我就要付给他们 {} 印度卢比。",
        wholesale_price(30.0)
    );
}

fn retail_price(weight: f64) -> f64 {
    return weight * 500.0;
}

fn wholesale_price(weight: f64) -> f64 {
    weight * 400.0
}

我在上述代码中有两个函数:retail_pricewholesale_price。两个函数都接受一个参数并将值存储在 weight 变量中。这个变量的类型是 f64,函数签名表示最终函数返回一个 f64 值。

这两个函数都将购买的苹果的重量乘以一个数字。这个数字表示苹果的当前每公斤价格。由于批发商有大量订单,物流在某种程度上更容易,价格可以降低一点。

除了每公斤价格之外,这两个函数还有一个区别。那就是,retail_price 函数使用 return 关键字返回乘积。而 wholesale_price 函数使用表达式返回乘积。

如果我从水果摊买了 2 公斤苹果,我必须付给他们 1000 印度卢比。
但是,如果我从水果摊买了 30 公斤苹果,我就要付给他们 12000 印度卢比。

输出显示,从函数返回值的两种方法都按预期工作。

返回多个值

你可以有一个返回不同类型的多个值的函数。你有很多选择,但返回一个元组是最简单的。

接下来是一个示例:

fn main() {
    let (maths, english, science, sanskrit) = tuple_func();

    println!("数学考试得分: {maths}");
    println!("英语考试得分: {english}");
    println!("科学考试得分: {science}");
    println!("梵语考试得分: {sanskrit}");
}

fn tuple_func() -> (f64, f64, f64, f64) {
    // return marks for a student
    let maths = 84.50;
    let english = 85.00;
    let science = 75.00;
    let sanskrit = 67.25;

    (maths, english, science, sanskrit)
}

函数 tuple_func 返回 4 个封装在一个元组中的 f64 值。这些值是一个学生在四门科目(满分 100 分)中获得的分数。

当函数被调用时,这个元组被返回。我可以使用 tuple_name.0 方案打印这些值,但我认为最好先解构元组,这样可以帮助我们搞清楚值对应的是什么。然后我使用了包含被解构的元组的值的变量来打印分数。

这是我得到的输出:

数学考试得分: 84.5
英语考试得分: 85
科学考试得分: 75
梵语考试得分: 67.25

总结

本文介绍了 Rust 编程语言中的函数。这些是函数的 “类型”:

  • 不接受任何参数也不返回任何值的函数
  • 接收一个或多个参数的函数
  • 给调用者返回一个或多个值的函数

你知道接下来是什么吗?Rust 中的条件语句,也就是 if-else。请继续关注并享受学习 Rust 的过程。

(题图:MJ/5a07503b-c691-4276-83b2-bb42f5fda347)


via: https://itsfoss.com/rust-functions/

作者:Pratham Patel 选题:lkxed 译者:Cubik65536 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

Rust 和 Python 的优势互补。可以使用 Python 进行原型设计,然后将性能瓶颈转移到 Rust 上。

Python 和 Rust 是非常不同的语言,但它们实际上非常搭配。但在讨论如何将 Python 与 Rust 结合之前,我想先介绍一下 Rust 本身。你可能已经听说了这种语言,但可能还没有了解过它的细节。

什么是 Rust?

Rust 是一种低级语言,这意味着程序员所处理的东西接近于计算机的 “真实” 运行方式。

例如,整数类型由字节大小定义,与 CPU 支持的类型相对应。虽然我们很想简单地说 Rust 中的 a+b 对应于一条机器指令,但实际上并不完全是这样!

Rust 编译器链非常复杂。作为第一种近似的方法,将这样的语句视为 “有点” 真实是有用的。

Rust 旨在实现零成本抽象,这意味着许多语言级别可用的抽象在运行时环境中会被编译去掉。

例如,除非明确要求,对象会在堆栈上分配。结果是,在 Rust 中创建本地对象没有运行时成本(尽管可能需要进行初始化)。

最后,Rust 是一种内存安全的语言。也有其他内存安全的语言和其他支持零成本抽象的语言。但通常这些是两类不同的语言。

内存安全并不意味着不可能在 Rust 中出现内存违规。它确实意味着只有两种方式可能导致内存违规:

  • 编译器的错误。
  • 显式声明为不安全(unsafe)的代码。

Rust 标准库代码有很多被标记为不安全的代码,虽然比许多人预期的少。这并不意味着该语句无意义。除了需要自己编写不安全代码的(罕见的)情况外,内存违规通常是由基础设施造成的。

为什么会有 Rust 出现?

为什么人们要创建 Rust?是哪些问题没有被现有编程语言解决吗?

Rust 被设计成既能高效运行,又保证内存安全。在现代的联网世界中,这是一个越来越重要的问题。

Rust 的典型应用场景是协议的低级解析。待解析的数据通常来自不受信任的来源,并且需要通过高效的方式进行解析。

如果你认为这听起来像 Web 浏览器所做的事情,那不是巧合。Rust 最初起源于 Mozilla 基金会,它是为了改进 Firefox 浏览器而设计的。

如今,需要保证安全和速度的不仅仅是浏览器。即使是常见的微服务架构也必须能够快速解析不受信任的数据,同时保证安全。

现实示例:统计字符

为了理解 “封装 Rust” 的例子,需要解决一个问题。这个问题需要满足以下要求:

  • 足够容易解决。
  • 能够写高性能循环来优化。
  • 有一定的现实意义。

这个玩具问题的例子是判断一个字符在一个字符串中是否出现超过了 X 次。这个问题不容易通过高效的正则表达式解决。即使是专门的 Numpy 代码也可能不够快,因为通常没有必要扫描整个字符串。

你可以想象一些 Python 库和技巧的组合来解决这个问题。然而,如果在低级别的语言中实现直接的算法,它会非常快,并且更易于阅读。

为了使问题稍微有趣一些,以演示 Rust 的一些有趣部分,这个问题增加了一些变化。该算法支持在换行符处重置计数(意即:字符是否在一行中出现了超过 X 次?)或在空格处重置计数(意即:字符是否在单词中出现了超过 X 次?)。

这是唯一与 “现实性” 相关的部分。过多的现实性将使这个示例在教育上不再有用。

支持枚举

Rust 支持使用枚举(enum)。你可以使用枚举做很多有趣的事情。

目前,只使用了一个简单的三选一的枚举,并没有其他的变形。这个枚举编码了哪种字符重置计数。

#[derive(Copy)]
enum Reset {
    NewlinesReset,
    SpacesReset,
    NoReset,
}

支持结构

接下来的 Rust 组件更大一些:这是一个结构(struct)。Rust 的结构与 Python 的 dataclass 有些相似。同样,你可以用结构做更复杂的事情。

#[pyclass]
struct Counter {
    what: char,
    min_number: u64,
    reset: Reset, 
}

实现块

你可以在 Rust 中使用一个单独的块,称为实现(impl)块,为结构添加一个方法。但具体细节超出了本文的范围。

在这个示例中,该方法调用了一个外部函数。这主要是为了分解代码。更复杂的用例将指示 Rust 编译器内联该函数,以便在不产生任何运行时成本的情况下提高可读性。

#[pymethods]
impl Counter {
    #[new]
    fn new(what: char, min_number: u64, reset: Reset) -> Self {
        Counter{what: what, min_number: min_number, reset: reset}
    }
    
    fn has_count(
        &self,
        data: &str,
    ) -> bool {
        has_count(self, data.chars())
    }
}

函数

默认情况下,Rust 变量是常量。由于当前的计数(current_count)必须更改,因此它被声明为可变变量。

fn has_count(cntr: &Counter, chars: std::str::Chars) -> bool {
    let mut current_count : u64 = 0;
    for c in chars {
        if got_count(cntr, c, &mut current_count) {
            return true;
        }
    }
    false
}

该循环遍历字符并调用 got_count 函数。再次强调,这是为了将代码分解成幻灯片展示。它展示了如何向函数发送可变引用。

尽管 current_count 是可变的,但发送和接收站点都显式标记该引用为可变。这可以清楚地表明哪些函数可能修改一个值。

计数

got_count 函数重置计数器,将其递增,然后检查它。Rust 的冒号分隔的表达式序列评估最后一个表达式的结果,即是否达到了指定的阈值。

fn got_count(cntr: &Counter, c: char, current_count: &mut u64) -> bool {
    maybe_reset(cntr, c, current_count);
    maybe_incr(cntr, c, current_count);
    *current_count >= cntr.min_number
}

重置代码

reset 的代码展示了 Rust 中另一个有用的功能:模式匹配。对 Rust 中匹配的完整描述需要一个学期级别的课程,不适合在一个无关的演讲中讲解。这个示例匹配了该元组的两个选项之一。

fn maybe_reset(cntr: &Counter, c: char, current_count: &mut u64) -> () {
    match (c, cntr.reset) {
        ('\n', Reset::NewlinesReset) | (' ', Reset::SpacesReset)=> {
            *current_count = 0;
        }
        _ => {}
    };
}

增量支持

增量将字符与所需字符进行比较,并在匹配时增加计数。

fn maybe_incr(cntr: &Counter, c: char, current_count: &mut u64) -> (){
    if c == cntr.what {
        *current_count += 1;
    };
}

请注意,我在本文中优化了代码以适合幻灯片。这不一定是 Rust 代码的最佳实践示例,也不是如何设计良好的 API 的示例。

为 Python 封装 Rust 代码

为了将 Rust 代码封装到 Python 中,你可以使用 PyO3。PyO3 Rust “crate”(即库)允许内联提示将 Rust 代码包装为 Python,使得修改两者更容易。

包含 PyO3 crate 原语

首先,你必须包含 PyO3 crate 原语。

use pyo3::prelude::*;

封装枚举

枚举需要被封装。derive 从句对于将枚举封装为 PyO3 是必需的,因为它们允许类被复制和克隆,使它们更容易在 Python 中使用。

#[pyclass]
#[derive(Clone)]
#[derive(Copy)]
enum Reset {
    /* ... */
}

封装结构

结构同样需要被封装。在 Rust 中,这些被称为 “宏”,它们会生成所需的接口位。

#[pyclass]
struct Counter {
    /* ... */
}

封装实现

封装实现(impl)更有趣。增加了另一个名为 new 的宏。此方法被标记为 #[new],让 PyO3 知道如何为内置对象公开构造函数。

#[pymethods]
impl Counter {
    #[new]
    fn new(what: char, min_number: u64,
          reset: Reset) -> Self {
        Counter{what: what,
          min_number: min_number, reset: reset}
    }
    /* ... */
}

定义模块

最后,定义一个初始化模块的函数。此函数具有特定的签名,必须与模块同名,并用 #[pymodule] 修饰。

#[pymodule]
fn counter(_py: Python, m: &PyModule
) -> PyResult<()> {
    m.add_class::<Counter>()?;
    m.add_class::<Reset>()?;
    Ok(())
}

? 显示此函数可能失败(例如,如果类没有正确配置)。 PyResult 在导入时转换为 Python 异常。

Maturin 开发

为了快速检查,用 maturin develop 构建并将库安装到当前虚拟环境中。这有助于快速迭代。

$ maturin develop

Maturin 构建

maturin build 命令构建一个 manylinux 轮子,它可以上传到 PyPI。轮子是特定于 CPU 架构的。

Python 库

从 Python 中使用库是最简单的部分。没有任何东西表明这与在 Python 中编写代码有什么区别。这其中的一个有用方面是,如果你优化了已经有单元测试的 Python 中的现有库,你可以使用 Python 单元测试来测试 Rust 库。

导入

无论你是使用 maturin develop 还是 pip install 来安装它,导入库都是使用 import 完成的。

import counter

构造函数

构造函数的定义正好使对象可以从 Python 构建。这并不总是如此。有时仅从更复杂的函数返回对象。

cntr = counter.Counter(
    'c',
    3,
    counter.Reset.NewlinesReset,
)

调用函数

最终的收益终于来了。检查这个字符串是否至少有三个 “c” 字符:

>>> cntr.has_count("hello-c-c-c-goodbye")
True

添加一个换行符会触发剩余操作,这里没有插入换行符的三个 “c” 字符:

>>> cntr.has_count("hello-c-c-\nc-goodbye")
False

使用 Rust 和 Python 很容易

我的目标是让你相信将 Rust 和 Python 结合起来很简单。我编写了一些“粘合剂”代码。Rust 和 Python 具有互补的优点和缺点。

Rust 非常适合高性能、安全的代码。Rust 具有陡峭的学习曲线,对于快速原型解决方案而言可能有些笨拙。

Python 很容易入手,并支持非常紧密的迭代循环。Python 确实有一个“速度上限”。超过一定程度后,从 Python 中获得更好的性能就更难了。

将它们结合起来完美无缝。在 Python 中进行原型设计,并将性能瓶颈移至 Rust 中。

使用 Maturin,你的开发和部署流程更容易进行。开发、构建并享受这一组合吧!


via: https://opensource.com/article/23/3/python-loves-rust

作者:Moshe Zadka 选题:lkxed 译者:ChatGPT 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

使用一个简单的计数程序比较古老的 C 语言和现代的 Go 语言。

Go 是一种现代编程语言,它很大程度上源自于 C 编程语言。因此,对于写 C 程序的程序员来说,Go 应该会感觉很熟悉。Go 让编写新程序变得容易,同时让 C 程序员感觉熟悉,但避免了 C 编程语言的许多常见陷阱。

本文比较了一个简单的 C 和 Go 程序,该程序将数字从一相加到十。由于这个程序只使用了小的数值,所以结果不会变得太大,因此只使用了普通的整数变量。像这样的循环在编程中非常常见,所以这个简单的程序很容易比较 C 和 Go。

如何在 C 中执行循环

C 语言中最基本的循环是 for 循环,它允许你对一组值进行迭代。for 循环的基本语法是:

for (起始条件 ; 结束条件 ; 每次迭代后执行的操作) { 循环内要执行的内容 ; }

你可以编写一个 for 循环,以打印从 1 到 10 的数字,将起始条件设置为 count = 1,将结束条件设置为 count <= 10。这样就以 count 变量等于 1 时开始循环。结束条件意味着只要 count 变量小于或等于 10 ,循环就会继续。

每次迭代之后,你使用 count = count + 1count 变量的值增加 1。在循环内部,你可以使用 printf 打印 count 变量的值:

for (count = 1; count <= 10; count = count + 1) {
  printf("%d\n", count);
}

C 程序中常见的惯例是 ++,它表示 “将某个值加一”。如果你写 count++,那就相当于 count = count + 1。大多数 C 程序员会使用 count++ 来编写 for 循环中每次迭代后要执行的操作,像这样:

for (count = 1; count <= 10; count++) {
  printf("%d\n", count);
}

这是一个示例程序,将从 1 到 10 的数字相加,然后打印结果。使用 for 循环对数字进行迭代,但不要打印数字,而是将数字添加到 sum 变量中:

#include <stdio.h>

int main() {
  int sum;
  int count;
  puts("adding 1 to 10 ..");
  sum = 0;

  for (count = 1; count <= 10; count++) {
    sum = sum + count;
  }

这个程序使用了两个不同的 C 函数来向用户打印结果。puts 函数打印引号中的字符串。如果你需要打印纯文本,使用 puts 是个不错的选择。

printf 函数 使用特殊字符在格式字符串中打印格式化的输出。printf 函数可以打印许多不同种类的值。关键字 %d 打印十进制(整数)值。

如果你编译并运行这个程序,你会看到这个输出:

adding 1 to 10 ..
The sum is 55

如何在 Go 中执行循环

Go 提供了与 C 中非常相似的 for 循环。C 程序中的 for 循环可以直接转换为 Go 的 for 循环,并具有相似的表示形式:

for count = 1; count <= 10; count++ {
  fmt.Printf("%d\n", count)
}

使用这个循环,你可以直接转换为 Go 的示例程序:

package main
import "fmt"

func main() {
  var sum, count int
  fmt.Println("adding 1 to 10 ..")

  for count = 1; count <= 10; count++ {
    sum = sum + count
  }
  fmt.Printf("The sum is %d\n", sum)
}

虽然上述方式在 Go 中是正确的,但它并不是最常用的 Go 写法。采用惯例是“使用与本地语言为人所知的表达方式”。任何语言的目标都是高效的沟通,编程语言也不例外。在不同的编程语言之间进行转换时,重要的是意识到尽管物似而意不同,一种编程语言中的典型写法在另一种编程语言中可能不完全相同。

为使用更符合惯例的 Go,你可以进行几个小修改:

  • 通过使用 += 操作符来将 sum = sum + count 更简洁地表达为 sum += count
  • 通过使用 分配并推断类型运算符 来表达 count := 1 而不是 var count int 跟着 count = 1:= 语法同时定义并初始化 count 变量。
  • count 的声明移到 for 循环的头中。这减少了一些认知负担,也通过减少程序员在任何时候都必须心里记着的变量数目来提高可读性。这个更改还通过在最接近其使用的地方和最小的范围中声明变量来增加安全性,从而减少了在代码不断演进的过程中对变量进行意外操作的可能性。

上述改动的组合将产生以下代码:

package main
import "fmt"

func main() {
  fmt.Println("adding 1 to 10 ..")
  var sum int
  for count := 1; count <= 10; count++ {
    sum += count
  }

  fmt.Printf("The sum is %d\n", sum)
}

你可以使用这个 Go.dev 的 链接 在 Go 试验场中尝试这个示例程序。

C 和 Go 相似但不同

通过在两种编程语言中编写相同的程序,你可以看到 C 和 Go 这两种语言虽然相似但仍然不同。将从 C 转换到 Go 时需要注意以下几点:

  • 在 C 中,每个程序指令都必须以分号结尾。这告诉编译器一个语句在哪里结束,下一个在哪里开始。在 Go 中,分号是有效的,但几乎总是可以推断出来。
  • 虽然大多数现代 C 编译器会为你将变量初始化为零值,但 C 语言规范指出,变量得到的是内存中的任意值。Go 值总是初始化为其零值。这有助于使 Go 成为一种更具内存安全的语言。这种差异在使用指针时变得更加有趣。
  • 注意 Go 程序包对导入标识符的使用方式。例如,fmt 是一个实现格式化输入和输出的函数,类似于 C 中的 stdio.h 中的 printfscanffmt 程序包在 pkg.go.dev/fmt 中有文档描述。
  • 在 Go 中,main 函数总是以退出代码 0 返回。如果你希望返回其他值,你必须调用 os.Exit(n),其中 n 通常为 1 以表示错误。这可以从任何地方调用,不仅仅是 main 函数,来终止程序。你可以在 C 中使用在 stdlib.h 中定义的 exit(n) 函数来实现相同的效果。

(题图:MJ/8f731484-2dc3-4bac-b895-cbc92a63b48b)


via: https://opensource.com/article/23/4/c-vs-go-programming-languages

作者:Jim Hall 选题:lkxed 译者:ChatGPT 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

在 Rust 系列的第四篇中,学习复合数据类型、数组和元组。

在上一篇文章中,你学习到了 Rust 中的 标量数据类型。它们是整型、浮点数、字符和布尔值。

在本文中,我们将会看看 Rust 编程语言中的复合数据类型。

Rust 中的复合数据类型是什么?

复合数据类型可以在一个变量中存储多个值。这些值可以是相同的标量数据类型,也可以是不同的标量数据类型。

Rust 编程语言中有两种这样的数据类型:

  • 数组 Array :存储相同类型的多个值。
  • 元组 Tuple :存储多个值,可以是相同的类型,也可以是不同的类型。

让我们了解一下它们吧!

Rust 中的数组

Rust 编程语言中的数组具有以下特性:

  • 每一个元素都必须是相同的类型
  • 数组有一个固定的长度
  • 数组存储在堆栈中,即其中存储的数据可以被 迅速 访问

创建数组的语法如下:

// 无类型声明
let variable_name = [element1, element2, ..., elementn];

// 有类型声明
let variable_name: [data_type; array_length] = [element1, element2, ..., elementn];

数组中的元素是在方括号中声明的。要访问数组的元素,需要在方括号中指定要访问的索引。

来让我们看一个例子来更好地理解这个。

fn main() {
    // 无类型声明
    let greeting = ['H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '!'];

    // 有类型声明
    let pi: [i32; 10] = [1, 4, 1, 5, 9, 2, 6, 5, 3, 5];

    for character in greeting {
        print!("{}", character);
    }

    println!("\nPi: 3.1{}{}{}{}", pi[0], pi[1], pi[2], pi[3]);
}

这里,我定义了一个字符数组和另一个存储 i32 类型的值的数组。greeting 数组以单独字符的形式存储了字符串 "Hello world!" 的字符。pi 数组以单独数字的形式存储了圆周率小数点后的前 10 位数字。

然后,我使用 for 循环打印了 greeting 数组的每个字符。(我很快就会讲到循环。)然后,我打印了 pi 数组的前 4 个值。

Hello world!
Pi: 3.11415

如果你想创建一个数组,其中每个元素都是 y,并且出现 x 次,你可以使用以下快捷方式在 Rust 中实现:

let variable_name = [y; x];

来看一个演示……

fn main() {
    let a = [10; 5];

    for i in a {
        print!("{i} ");
    }
    println!("");
}

我创建了一个变量 a,它的长度为 5。数组中的每个元素都是 '10'。我通过使用 for 循环打印数组的每个元素来验证这一点。

它的输出如下:

10 10 10 10 10
? 作为练习,尝试创建一个长度为 x 的数组,然后尝试访问数组的第 x+1 个元素。看看会发生什么。

Rust 中的元组

Rust 中的元组具有以下特性:

  • 就像数组一样,元组的长度是固定的
  • 元素可以是相同的/不同的标量数据类型
  • 元组存储在堆栈中,所以访问速度更快

创建元组的语法如下:

// 无类型声明
let variable_name = (element1, element2, ..., element3);

// 有类型声明
let variable_name: (data_type, ..., data_type) = (element1, element2, ..., element3);

元组的元素写在圆括号中。要访问元素,使用点运算符,后跟该元素的索引。

fn main() {
    let a = (38, 923.329, true);
    let b: (char, i32, f64, bool) = ('r', 43, 3.14, false);

    println!("a.0: {}, a.1: {}, a.2: {}", a.0, a.1, a.2);
    println!("b.0: {}, b.1: {}, b.2: {}, b.3: {}", b.0, b.1, b.2, b.3);

    // 元组解构
    let pixel = (50, 0, 200);
    let (red, green, blue) = pixel;
    println!("red: {}, green: {}, blue: {}", red, green, blue);
}

在上面的代码中,我在第 2 行和第 3 行声明了两个元组。它们只包含我当时想到的随机值。但是仔细看,两个元组中每个元素的数据类型都不同。然后,在第 5 行和第 6 行,我打印了两个元组的每个元素。

在第 9 行,我声明了一个名为 pixel 的元组,它有 3 个元素。每个元素都是组成像素的颜色红色、绿色和蓝色的亮度值。这个范围是从 0 到 255。所以,理想情况下,我会声明类型为 (u8, u8, u8),但是在学习代码时不需要这样优化 ; )

然后,在第 10 行,我“解构”了 pixel 元组的每个值,并将其存储在单独的变量 redgreenblue 中。然后,我打印了 redgreenblue 变量的值,而不是 pixel 元组的值。

让我们看看输出……

a.0: 38, a.1: 923.329, a.2: true
b.0: r, b.1: 43, b.2: 3.14, b.3: false
red: 50, green: 0, blue: 200

看起来不错 : )

额外内容:切片

准确的来说, 切片 Slice 不是 Rust 中的复合数据类型。相反,切片是现有复合数据类型的 “切片”。

一个切片由三个元素组成:

  • 一个初始索引
  • 切片运算符(....=
  • 一个结束索引

接下来是数组切片的一个示例:

fn main() {
    let my_array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
    let my_slice = &my_array[0..4];

    for element in my_slice {
        println!("{element}");
    }
}

就像 C 和 C++ 一样,& 用于存储变量的引用(而不是原始指针)。所以 &my_array 意味着对变量 my_array 的引用。

然后,来看看切片。切片由 [0..4] 表示。这里,0 是切片开始的索引。而 4 是切片结束的索引。这里的 4 是一个非包含索引。

这是程序输出,以更好地理解正在发生的事情:

0
1
2
3

如果你想要一个 包含 范围,你可以使用 ..= 作为包含范围的切片运算符。

fn main() {
    let my_array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
    let my_slice = &my_array[0..=4];

    for element in my_slice {
        println!("{element}");
    }
}

现在,这个范围是从第 0 个元素到第 4 个元素,下面是输出来证明这一点:

0
1
2
3
4

总结

本文讲到了 Rust 编程语言中的复合数据类型。你学习了如何声明和访问存储在数组和元组类型中的值。此外,你还了解了切片“类型”,以及如何解构元组。

在下一章中,你将学习如何在 Rust 程序中使用函数。敬请关注。

(题图:MJ/22a0d143-2216-439f-8e1d-abd94cdfdbd0)


via: https://itsfoss.com/rust-arrays-tuples/

作者:Pratham Patel 选题:lkxed 译者:Cubik65536 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

在开发初期只对单个元素进行编码和测试,之后再拓展到多个元素上。

 title=

上一篇文章 中我已经解释了为什么把所有编程问题当作一群丧尸一次性处理是错误的。我也解释了 ZOMBIES 方法中的第一条:最简场景。本文中我将进一步介绍接下来的两条:单元素场景和多元素场景。

ZOMBIES 表示以下首字母缩写:

  • Z – 最简场景(Zero)
  • O – 单元素场景(One)
  • M – 多元素场景(Many or more complex)
  • B – 边界行为(Boundary behaviors)
  • I – 接口定义(Interface definition)
  • E – 处理特殊行为(Exercise exceptional behavior)
  • S – 简单场景用简单的解决方案(Simple scenarios, simple solutions)

在上一篇文章中,通过应用了最简场景,你在代码里构建了一条最简可行通路。这个代码里没有任何业务处理逻辑。现在是时候向系统中添加一个元素了。

最简场景表示系统中什么也没有,这是一个空的用例,我们什么也不用关心。单元素场景代表我们有一个元素需要关心考虑。这个单一元素可能是集合中的一个元素、一个访问着或者一个需要处理的事件。

对于多元素场景,我们需要处理更复杂的情况,比如两个或更多的集合元素或事件。

单元素场景

在上一篇文章的代码基础上,向虚拟购物筐里添加一些商品。首先,写一个伪测试:

[Fact]
public void Add1ItemBasketHas1Item() {
        var expectedNoOfItems = 1;
        var actualNoOfItems = 0;
        Assert.Equal(expectedNoOfItems, actualNoOfItems);
}

不出所料,这个测试失败了,因为硬编码了一个错误的值:

Starting test execution, please wait...

A total of 1 test files matched the specified pattern.
[xUnit.net 00:00:00.57] tests.UnitTest1.NewlyCreatedBasketHas0Items [FAIL]
  X tests.UnitTest1.NewlyCreatedBasketHas0Items [4ms]
  Error Message:
   Assert.Equal() Failure
Expected: 0
Actual: 1
[...]

现在是时候停止伪造了。现在你已经用 ArrayList 实现了购物筐。那么应该怎么实现商品呢?

简洁性应该一直是你的指导原则。在不了解商品的太多信息的情况下,你可以先用另一个集合来实现它。这个表示商品的集合应该包含些什么呢?由于你多半会关心计算购物筐中的商品总价,所以对商品的表示至少需要包含价格(可以是任意货币,为简单起见,不妨假设是人民币)。

(我们需要)一个简单的集合类型,它包含一个商品 ID(可以在系统中的其它地方使用 ID 来指向该商品)和这个商品的价格。

键值对类型的数据结构可以很容易满足这个需求。在 C# 中最先被想到的数据结构就是 Hashtable

在购物应用的代码中给 IShoppingAPI 增加一个新功能:

int AddItem(Hashtable item);

这个新功能以一个用 Hashtable 表示的商品为输入,返回购物筐中的商品数量。

将测试代码中硬编码的值提替换为对接口的调用:

[Fact]
public void Add1ItemBasketHas1Item() {            
    var expectedNoOfItems = 1;
    Hashtable item = [new][3] Hashtable();
    var actualNoOfItems = shoppingAPI.AddItem(item);
    Assert.Equal(expectedNoOfItems, actualNoOfItems);
}

在上面的代码中实例化了一个 Hashtable 并命名为 item,然后调用购物接口中的 AddItem(item) 方法,该方法会返回购物筐中实际的商品数量。

转到 ShoppingAPI 类中,实现这个方法:

public int AddItem(Hashtable item) {
    return 0;
}

这里再次通过写假代码来检验测试的效果(测试是业务代码的第一个调用者)。如果测试失败,将硬编码值换成实际的代码:

public int AddItem(Hashtable item) {
    basket.Add(item);
    return basket.Count;
}

在上面的代码中,向购物筐里添加了一件商品,然后返回购物筐中的商品数量:

Test Run Successful.
Total tests: 2
     Passed: 2
 Total time: 1.0633 Seconds

到目前为止,你通过了两个测试,同时也基本里解了 ZOMBIES 方法中的最简场景和单元素场景两部分。

反思总结

回顾前面所做的工作,你会发现通过将注意力集中到处理最简场景和单元素场景上,你在构建接口的同时也定义了一些业务逻辑边界!这不是很棒吗?现在你已经部分地实现了最关键的抽象逻辑,并且能够处理什么也没有和只有一个元素的的情况。因为你正在构建的是一个电子交易 API,所以你不能对顾客的购物行为预设其它限制。总而言之,虚拟购物筐应该是无限大的。

ZOMBIES 提供的逐步优化思路的另一个重要方面(虽然不是很明显)是从大概思路到具体实现的阻力。你也许已经注意到了,要具体实现某个东西总是困难重重。倒不如先用硬编码值来构造一个伪实现。只有看到接口与测试之间以一种合理的方式交互之后,你才会愿意开始完善实现代码。

即便如此,你也应该采用简单直接的代码结构,尽可能避免条件逻辑分支。

多元素场景

通过定义顾客向购物筐里添加两件商品时的期望来拓展应用程序。首先构造一个伪测试。它的期望值为 2,但是现在将实际值硬编码为 0,强制让测试失败:

[Fact]
public void Add2ItemsBasketHas2Items() {
        var expectedNoOfItems = 2;
        var actualNoOfItems = 0;
        Assert.Equal(expectedNoOfItems, actualNoOfItems);
}

执行测试,前两个测试用例通过了(针对最简场景和单元素场景的测试),而硬编码的测试不出所料地失败了:

A total of 1 test files matched the specified pattern.
[xUnit.net 00:00:00.57] tests.UnitTest1.Add2ItemsBasketHas2Items [FAIL]
  X tests.UnitTest1.Add2ItemsBasketHas2Items [2ms]
  Error Message:
   Assert.Equal() Failure
Expected: 2
Actual: 0

Test Run Failed.
Tatal tests: 3
     Passed: 2
     Failed: 1

将硬编码值替换为实际的代码调用:

[Fact]
public void Add2ItemsBasketHas2Items() {
        var expectedNoOfItems = 2;
        Hashtable item = [new][3] Hashtable();
        shoppingAPI.AddItem(item);
        var actualNoOfItems = shoppingAPI.AddItem(item);
        Assert.Equal(expectedNoOfItems, actualNoOfItems);
}

在这个测试中,你向购物筐中添加了两件商品(实际上是将同一件商品添加了两次),然后比较期望的商品数量和第二次添加商品后调用 shoppingAPI 返回的商品数量是否相等。

现在所有测试都能够通过!

敬请期待

现在你已经了解了最简场景、单元素场景和多元素场景。我将下一篇文章中介绍边界行为和接口定义。敬请期待!

(题图:MJ/e4679f1f-311a-4a41-80e8-8d2834b956f2)


via: https://opensource.com/article/21/2/build-expand-software

作者:Alex Bunardzic 选题:lujun9972 译者:toknow-gh 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

上一篇 关于 Rust 编程语言的文章中,我们提到了变量、常量和 遮蔽 shadowing

现在来讲解数据类型是再自然不过的了。

数据类型是什么?

将这个词汇展开些单词的顺序改变一下你就会得到答案了;“数据类型” -> “数据的类型”。

计算机使用 01 来存储数据,但是为了让数据在读取时有意义,我们使用数据类型来表示这些 01 的含义。

Rust 有两种数据类型:

  • 标量数据类型:只能存储单个值的类型。
  • 复合数据类型:可以存储多个值,甚至是不同类型的值。

在本文中,我将讲解标量数据类型。我将在下一篇文章中讲解第二类数据类型。

接下来是 Rust 中四种主要标量数据类型的简要概述:

  • 整型:存储整数。有每种特定情况下使用的子类型。
  • 浮点数:存储带有小数部分的数字。有两种基于大小的子类型。
  • 字符:使用 UTF-8 编码存储单个字符。(是的,你可以在字符中存储表情符号*。)
  • 布尔值: 存储 truefalse。(给那些无法就 0true 还是 0false 达成一致的开发者。)

整型

在编程语言中,整型指的是一个整数。Rust 中的整型要么是有符号的,要么是无符号的。无符号整型只能存储 0 和正数,而有符号整型可以存储负数、0 和正数。

? 一个有符号整型的范围从 -(2<sup> n-1</sup>) 开始,以 (2<sup> n-1</sup>)-1 结束。同样,无符号整型的范围从 0 开始,以 (2<sup> n</sup>)-1 结束。

这是根据符号和长度可用的整型:

Rust 中的整型数据类型

正如你所见,Rust 有 8、16、32、64 甚至 128 位的有符号和无符号整型!

使用 *size 的整型根据计算机的架构而变化。在 8 位微控制器上,它是 *8,在 32 位的旧计算机上,它是 *32,在现代 64 位系统上,它是 *64

使用 *size 是为了存储与内存(这与裸机相关)有关的数据,比如指针、偏移量等。

? 当你没有显式地指定整型的子类型时,Rust 编译器会默认推断为 i32。显然,如果值比 i32 能存储的值大或小,Rust 编译器会礼貌地报错并要求你手动指定类型。

Rust 不仅允许你以十进制形式存储整数,还允许你以二进制、八进制和十六进制形式存储整数。

为了更好的可读性,你可以使用下划线 _ 来代替逗号来书写/读取大数。

fn main() {
    let bin_value = 0b100_0101; // 使用前缀“0b”表示二进制
    let oct_value = 0o105; // 使用前缀“0o”表示八进制
    let hex_value = 0x45; // 使用前缀“0x”表示十六进制
    let dec_value = 1_00_00_000; // 和写一克若(1,00,00,000)一样

    println!("二进制值: {bin_value}");
    println!("八进制值: {oct_value}");
    println!("十六进制值: {hex_value}");
    println!("十进制值: {dec_value}");
}

我使用二进制、八进制和十六进制分别将十进制数 69 存储在变量 bin_valueoct_valuehex_value 中。在变量 dec_value 中,我存储了数字 1 克若 1 Crore (一千万),并且使用了下划线替代逗号,这是印度的书写系统。对于那些更熟悉国际计数系统的人来说,你可以将其写成 10_000_000

在编译并运行这个二进制文件后,我得到了如下输出:

二进制值: 69
八进制值: 69
十六进制值: 69
十进制值: 10000000

浮点数

浮点数是一种存储带有小数部分的数字的数据类型。

与 Rust 中的整型不同,浮点数只有两种子类型:

  • f32: 单精度浮点数类型
  • f64: 双精度浮点数类型

和 Rust 中的整型一样,当 Rust 推断一个变量的类型时,如果它看起来像一个浮点数,那么它就会被赋予 f64 类型。这是因为 f64 类型比 f32 类型有更高的精度,并且在大多数计算操作中几乎和 f32 类型一样快。请注意,浮点数据类型(f32f64)都是有符号

? Rust 编程语言按照 IEEE 754 二进制浮点数表示与算术标准存储浮点数。
fn main() {
    let pi: f32 = 3.1400; // f32
    let golden_ratio = 1.610000; // f64
    let five = 5.00; // 小数点表示它必须被推断为浮点数
    let six: f64 = 6.; // 尽管类型说明被显式的添加了,小数点也是**必须**的

    println!("pi: {pi}");
    println!("黄金比例: {golden_ratio}");
    println!("五: {five}");
    println!("六: {six}");
}

仔细看第 5 行。尽管我已经为变量 six 指定了类型,但我必须至少加上一个小数点。小数点之后有什么就由你决定了。

程序的输出是相当可预测的... 吗?

pi: 3.14
黄金比例: 1.61
五: 5
六: 6

在上面的输出中,你可能已经注意到,当显示变量 pigolden_ratiofive 中存储的值时,我在变量声明时在结尾增加的零已经消失了。

就算这些零没有被 移除,它们也会在通过 println 宏输出值时被省略。所以,不,Rust 没有篡改你的变量值。

字符

你可以在一个变量中存储一个字符,类型是 char。像 80 年代的传统编程语言一样,你可以存储一个 ASCII 字符。但是 Rust 还扩展了字符类型,以存储一个有效的 UTF-8 字符。这意味着你可以在一个字符中存储一个表情符号 ?

? 一些表情符号实际上是两个已有表情符号的组合。一个很好的例子是“燃烧的心”表情符号:❤️‍?。这个表情符号是通过使用 零宽度连接器 来组合两个表情符号构成的:❤️ + ? = ❤️‍?

Rust 的字符类型无法存储这样的表情符号。

fn main() {
    let a = 'a';
    let p: char = 'p'; // 带有显性类型说明
    let crab = '?';

    println!("Oh look, {} {}! :{}", a, crab, p);
}

正如你所见,我已经将 ASCII 字符 'a' 和 'p' 存储在变量 ap 中。我还在变量 crab 中存储了一个有效的 UTF-8 字符,即螃蟹表情符号。然后我打印了存储在每个变量中的字符。

这是输出:

Oh look, a ?! :p

布尔值

在 Rust 中,布尔值类型只存储两个可能的值之一:truefalse。如果你想显性指定类型,请使用 bool

fn main() {
    let val_t: bool = true;
    let val_f = false;

    println!("val_t: {val_t}");
    println!("val_f: {val_f}");
}

编译并执行上述代码后,结果如下:

val_t: true
val_f: false

额外内容:显性类型转换

在上一篇讲述 Rust 编程语言中的变量的文章中,我展示了一个非常基础的 温度转换程序。在那里,我提到 Rust 不允许隐式类型转换。

但这不代表 Rust 也不允许 显性 类型转换 ; )

要进行显性类型转换,使用 as 关键字,后面跟着要转换的数据类型。

这是一个示例程序:

fn main() {
    let a = 3 as f64; // f64
    let b = 3.14159265359 as i32; // i32

    println!("a: {a}");
    println!("b: {b}");
}

在第二行,我没有使用 3.0,而是在 3 后面写上 as f64,以表示我希望编译器将 3(一个整数)转换为 64 位浮点数的类型转换。第三行也是一样。但是这里,类型转换是有损的。这意味着小数部分 完全消失。它不是存储为 3.14159265359,而是存储为简单的 3

程序的输出可以验证这一点:

a: 3
b: 3

总结

本文介绍了 Rust 中的原始/标量数据类型。主要有四种这样的数据类型:整型、浮点数、字符和布尔值。

整型用于存储整数,它们有几种子类型,基于它们是有符号还是无符号以及长度。浮点数用于存储带有小数的数字,根据长度有两种子类型。字符数据类型用于存储单个有效的 UTF-8 编码字符。最后,布尔值用于存储 truefalse 值。

在下一章中,我将讨论数组和元组等复合数据类型。敬请关注。

(题图:MJ/c0c49e15-cc9d-4eef-8e52-2f0d62294965)


via: https://itsfoss.com/rust-data-types/

作者:Pratham Patel 选题:lkxed 译者:Cubik65536 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出