Rust 和 porque aprenderlo 的 Primeros pasos

Rust是系统主要方面的编程语言：

• 安全
• 维洛西达德
• 并发

实际的实施过程中，我们会通过一些相关的文章、其他语言或技术来描述一些实际情况。不包括重新收集器、并行程序支持、使用记忆以及声明变量的最佳方式，以及引入所有权概念。

编译、支持多个操作系统（GNU/Linux、MacOS、Windows）和架构（x86、x86_64、ARM），并在文档中提供了章节。

Un soporte que ha mejorado mucho en los últimos años。根据 2016 年原则编写的初级版本的代码，我们将发布初级版本的公共版本。

对于 Raspberry Pi，您可以通过编译安装 Rust 来进行安装，您可以在官方站点上安装印度安装命令，并下载依赖于发行版的官方存储库，例如在 Arch Linux ARM 上。

将 Rust 的其他语言和技术集成到一个考虑因素中，以提高其外观和特性。 Node.js + Rust 与Neon一起创建 Node.js 的原生模块，Python + Rust 使用PyO3，并用于在 Web 应用程序和 escritorio 上开发后端。

该语言是 Mozilla、Atlassian、System76、Dropbox、Canonical、Cloudflare 等实际企业和组织的语言，也是生产中的常用语言，并且是世界各地的众多开发者的支持。

我们感兴趣的内容包括在墨西哥城、巴塞罗那举行的聚会、在美国举行的 RustConf 会议、以及在 dev.events 上咨询的其他活动。

一系列有趣的项目列表包括语言和快速的速度，以及Redox操作系统和Rocket网络框架的介绍。支持文本编辑器，包括Emacs、Nano、Visual Studio Code等。请参阅GitHub上的咨询列表。

这是 Steve Klabnik 和 Carol Nichols 的《Rust 编程语言》中存在的更多 Rust 库。您可以在Twitter上看到 Rust 官方的生态信息。

与Ferris 的吉祥物一样，在不同的宣传文章中，我们也能看到DevSwag中遇到的不同情况。

安装

要安装 Rust，请使用 GNU/Linux 和 MacOS 来安装终端命令：

$ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

前面的命令实现了rustup的安装(rustup 的安装) 和语言版本的安装，包括编译器 (rustc) 和货物 (gestor de paquetes)。

在其他操作系统中，Windows 会与生锈位置和指示的安装对应的部分进行下载。

赫拉门塔斯

生锈

rustup 是 Rust 的安装者，并且会根据 Rust 安装的不同版本进行管理。与 Firefox 类似的语言是新版本的公开版本。最终版本为 1.83.0。

Rust 存在三种实际情况：稳定版、测试版和夜间版。

突击队

安装

$ rustup install nightly

安装的
最新版本

$ rustup update

特定版本

$ rustup update nightly

叛逃的特定版本

$ rustup default stable

项目的特定版本

$ rustup override set nightly

rustc

Se trata del compilador del lenguaje。 Rust 的扩展内容的归档内容是 .rs，其结构如下：

fn main() {
      println!("Hello, world!");
  }

在 llamado hello_world.rs 存档中，前面的代码是 hello_world.rs 的名称，它是一个执行程序，在终端上记录了 siguientes comandos，其路径如下：

$ rustc main.rs
$ ./main
Hello, world!

在第一行中编译代码，将二进制文件与操作系统相关的扩展一起使用，并且在 GNU/Linux 中执行第二行中的操作，在第三行中使用程序。

使用 Rustc se puede comprobar la version que se tenga instalada de Rust：

$ rustc --version

que muestra lo siguiente en la 航站楼:

rustc 1.83.0 (90b35a623 2024-11-26)

货物

货物是 Rust 的构建和管理系统，允许创建和管理依赖项（板条箱）。

新项目

$ cargo new hello_world

El comando anterior crea un proyecto nuevo usando Cargo, hello_world es el nombre del proyecto y de la Carpeta que generic, la cual tiene la siguiente estructura:

~/hello_world$ ls -a
Cargo.toml  src  .git  .gitignore

Cargo.toml 是程序清单，包含项目的一般信息。该目录是 Rust 生成自动存档的连续目录。请注意，Git 存储库的缩写。

Cargo.toml
档案结构如下：

[package]
name = ”hello_world”
version = “0.1.0”
authors = [“mattdark”]
edition = ‘2021’

[dependencies]

En la sección [package] se teene información 一般项目，包括名称、版本、作者和版本。

El Campo 作者参考了 GNU/Linux 系统的作者和程序作者。 El Campo 版本是 Rust 1.31 的一部分，公开版本是第 6 版，并且是美国 Rust 版的最新版本并已发布。

Existen tres ediciones de Rust，2015、2018 和 2021。2015 参考了 Rust 1.0 和 1.30 的所有版本。 2018 年，兰扎米恩托 1.0 版本的重要公开内容已发布。与其他显着的特征和功能有关，在博客中描述公共文章，在2021 年版本中对应 1.56.0 版本，在博客中描述描述。

Cargo crea el archivo main.rs dentro deldirectio src y este contiene las siguientes lineas de código:

fn main() {
      println!("Hello, world!");
  }

有关货物的执行程序，请在终端上记录相关信息：

$ cargo build
$ cargo run

您可以通过入门指南实现编译、编译项目依赖项、下载和编译对应的书目。这是可选的。

第二次执行在编译过程中生成二进制文件并实现之前的编译过程。

鲁斯特的诗句

在前面的部分中，我们讨论了一些可能的情况，例如 Rust 中的“Hola mundo”：

fn main() {
      println!("Hello, world!");
  }

Rust 的主要功能是定义使用 palabra reservada fn。 Se usan llaves ({}) y punto y coma (;) como parte de la sintaxis, tal y como sucede en C/C++ or JavaScript。

Para imprimir texto se usa la Macro println como se muestra en la segunda linea. Rust 的函数定义与语言的语法和宏的语法相同，并且可以区分其他函数，并且具有令人惊叹的标志（！）。

打印文本

Para imprimir texto se usa la Macro println y su sintaxis es la siguiente:

println!(“string {} literal”, expressions);

打印宏观的美国信息，以印记文本，以“Hola mundo”的方式，使用它来印记操作的结果或变量的勇气。请参考以下参数：

println!("Hola, {}!", "mundo");

在前面的印刷版中，我们首先介绍了一些内容，但您可能会发现，在第二个参数中，您可能会遇到一些变量，或者是“世界”。

评论

Rust 的注释使用双对角线 (//)：

// This is a comment

变量

Para definir una Variable se usa la palabra reservada let seguida del nombre de la Variable y el valor asignado。

let name = expressions;

例句

let a = 7;
let b = 8;
println!(“La suma es: {}”, a+b);

El ejemplo anterior es de la suma de dos números, ayb, cuyo resultado se muestra en pantalla.

可以定义一个变量，Rust 推荐使用，并且与此相反。例如：

let a = 7;
let b = 8;
let c = a+b;
println(“La suma es {}”, a+b);

Se modifica el ejemplo anterior y se定义了一个变量c que almacena la suma de ay b。禁止使用打印参数，请注意执行程序：

warning: unused variable: `c`                                                   
 --> src/main.rs:4:9                                                            
  |                                                                             
4 |     let c = a+b;                                                            
  |         ^ help: consider using `_c` instead                                 
  |                                                                             
  = note: #[warn(unused_variables)] on by default

Rust también 推荐的变量名是多个变量，se debe usar guión bajo (_) para separarlas。例如：

let a = 7;
let b = 8;
let suma_ab = a+b;

康斯坦特斯

Una Constante se Define usando la palabra reservada const seguida del nombre en mayusculas, el Tipo de dato y el valor asignado。

const NAME: type = expression;

例句

const A: i32 = 7;
const B: i32 = 8;
println!("The sum is: {}", A + B);

易变性

Rust 中的变量具有可变性，因此您可以单独修改该变量，但相反，它是永久不变的。

例句

let x = 5;
println!("El valor de x es: {}", x);
x = 6;
println!("El valor de x is: {}", x);

在其他编程语言中，如果修改了变量的值，则将新的值指定为前面的值。在 Rust 执行程序时，出现错误：

error[E0384]: cannot assign twice to immutable variable `x`                     
 --> src/main.rs:4:5                                                            
  |                                                                             
2 |     let x = 5;                                                              
  |         - first assignment to `x`                                           
3 |     println!("The value of x is: {}", x);                                   
4 |     x = 6;                                                                  
  |     ^^^^^ cannot assign twice to immutable variable

Indica que no se puede asignar valor dos veces a una variable inmutable.如果需要修改勇气，则变量值是可变的，因此我们可以保留保留值。

let mut name = expression;

例句

let mut x = 5;
println!("The value of x is: {}", x);
x = 6;
println!("The value of x is: {}", x);

数据类型

Rust 相关数据的提示：

• i8、i16、i32、i64
• u8、u16、u32、u64
• isize、usize
• f32、f64

输入 (i) de 8 到 64 位，输入signo (u) de 8 到 64 位，大小取决于执行程序的结构，浮动 (f) de 32 y 64 位。

例句

let x = 42;
let y = 1.0;

Un Valor Entero es de tipo i32 por defeto y para tipo flantante es f64 el tipo de dato por defeto.

数字操作

Rust 的操作符包括其他语言中的计算、计算、乘法、除法和模数操作。

例句

let suma = 5 + 10;
let resta = 95.5 - 4.3;
let multiplicacion = 4 * 30;
let division = 56.7 / 32.2;
let modulo = 43 % 5;

字符

Rust 中的字符类型变量具有如下特征：

let x: char = ‘x’;

布尔值

布尔变量可以定义真、假的值：

let x = true;
let y: bool = false;

条件句

如果您还没有评估条件并执行代码块，则使用 Rust 进行操作。

if condition {
    expressions;
}
else {
    expressions;
}

例如
，存在变量，因此必须确定市长的勇气。

let a = 8;
let b = 12;
if a > b {
    println!("{} > {}", a, b);
}
else {
    println!("{} > {}", b, a);
}

在其他条件下评估第二或更多条件。

例如
，一个数字可以被 4 整除，3 o 2，o 不能被 4 整除。

let number = 6;
if number % 4 == 0 {
    println!("number is divisible by 4");
} else if number % 3 == 0 {
    println!("number is divisible by 3");
} else if number % 2 == 0 {
    println!("number is divisible by 2");
} else {
    println!("number is not divisible by 4, 3, or 2");
}

图普拉斯

Una de las estructuras de datos soportadas por Rust son las tuplas。定义使用保留的保留值、名称、提示（可选）、卡达价值和所有价值。 Una tupla tiene un tamaño fijo que no puede cambiar una vez definida.

例子：

let tup: (i32, f64, u8) = (500, 6.4, 1);

阿雷格洛斯

Para definir un arreglo en Rust se usa la palabra reservada let, seguido del nombre, el Tipo de dato y tamaño (可选), y los valores entre corchetes. Un arreglo puede ser mutable (mut)。

例子：

let a = [1, 2, 3];
let mut m = [1, 2, 3];

西克洛斯

Se dispone de los ciclos Loop, for y while。这是一个无限循环的开始，同时您还可以了解其他编程语言，并且可以继续进行下去。

循环无限循环
，以单独终止程序来执行程序。

loop {
    expressions;
}

例句

loop {
    println!(“¡Otra vez!”);
}

对于
La sintaxis General del ciclo for es la que se muestra a continuación。使用一个变量来分隔所要执行的任务的编号。这个变量不是预先定义的，也不是初始值，而是重复的数字，每个点都是分开的 (..)..

for i in x..n {
    expressions;
}

Ejemplo
Imprimir los elementos de un arreglo usando un ciclo for。

let a = [1, 2, 3, 4, 5];
for i in 0..5 {
    println!(“{}”, a[i]);
}

如果您想使用 iter() 函数，请使用该函数。

let a = [1, 2, 3, 4, 5];
for i in a.iter() {
    println!(“{}”, i);
}

使用功能来记录分配位置和分配变量 i 的值。

如果需要在相反的顺序中输入排列元素，请使用 rev() 函数。

let a = [1, 2, 3, 4, 5];
for n in (0..5).rev() {
    println!("{}", a[n]);
}

El bloque de codigo front imprime los elementos del arreglo de la ultima posición a la primera.

而
La sintaxis del ciclo 虽然与其他语言类似，但定义了变量的分隔符，该变量的编号是 bloque de código si la condición se cumple。 La sintaxis en Rust es como sigue：

while condition {
    expressions;
}

请记住
，我们将在这段时间里使用编组的内容。

let a = [1, 2, 3, 4, 5];
let mut i = 0;
while i < 5 {
    println!(“{}”, a[i]);
    i = i + 1;
}

功能

Rust 的函数定义了保留函数的用途，并指定了函数的名称、括号，并且您可以使用该函数的参数，将括号中的变量命名为变量的名称和值。如果您的功能被赋予了勇气，那么您将获得特定的功能。

fn name(arg: Type) -> ReturnType {
    statements;
}

例如
，定义变量的值的函数。

fn main() {
    let a = 9;
    let b = 15;
    suma(a, b);
}

fn suma(a: i32, b: i32) {
    let c = a + b;
    println!(“La suma de {} + {} es: {}”, a, b, c);
}

函数的定义与主函数的定义无关，不会影响程序的执行。该功能的名称为 si contiene dos palabras，estas deben separse con un guión bajo (_)。

例句

fn cinco() -> i32 {
    5
}
fn main() {
    let x = cinco();
    println!(“El valor de x es {}”, x);
}

在前面的例子中，如果您的功能开发了勇气或变量，则没有使用保留的保留返回，并且 colocarse el valor que devolverá sin punto y coma (;) al Final。

这是 Rust 程序语言的简短介绍，前面的内容描述了详细的信息，官方文档中包含了一些官方文档和递归信息。