RUST 入坑笔记

文章目录 (?) [+]

    RUST

    Date: 2021/03/20

    开发环境

     # 安装
     curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
     
     # 升级
     rustup update
     
     # 卸载
     rustup self uninstall
     
     # 创建项目
     cargo new hello_world
     
     # 构建项目
     # --release 优化编译
     cargo build
     
     # 编译并运行
     cargo run
     
     # 代码检查
     cargo check

    Hello World

     fn main() {
         println!("Hello World");
     }

    数据类型

    rust 中有整型、浮点型、布尔型、字符型 4 种标量类型(Scalar Type)

    整型

    std::u128:MAX 定义最大整型为 340282366920938463463374607431768211455

    std::i128:MIN 定义最小整型为 -170141183460469231731687303715884105728

    sizesignedunsigned
    8 biti8u8
    16 biti16u16
    32 biti32u32
    64 biti64u64
    128 biti128u128
    Archisizeusize
    举例字面值
    10_24十进制
    0xff十六进制
    0o66八进制
    0b1100_1101二进制
    b'A'字节(u8)

     fn main() {
         // 默认标量类型为 i32
         let i = 01_86; // 186
         let num: u8 = 0xff;
         let uarch: usize = 64;
     
         println!("i = {}, num = {}, uarch = {}", i, num, uarch);
     }
     // i = 186, num = 255, uarch = 64

    浮点型

    浮点类型不能与整型自动类型转换。

     fn main() {
         let f = 64.00;
     
         println!("f is {:?}", f);
     }
     // f is 64.0

    布尔类型

    只有 truefalse 两种值

    字符类型

    &str 字符串面量

    字符串由标准库 std:str 提供,字符串面量在编译时就知道值的字符串类型。

    String 对象

    字符串对象是是一个长度可变的集合,它是可变的而且使用 UTF-8 作为底层数据编码格式,字符串对象在 heap 中分配,在运行的时候可以对其进行操作。

     fn main() {
         // 默认类型为 char
         let special_character = '@';
         let alphabet: char = 'A';
         let chinese: char = '丁';
         let emoji: char = '🦀';
     
         println!("special character is {}", special_character);
         println!("alphabet is {}", alphabet);
         println!("chinese is {}", chinese);
         println!("emoji is {}", emoji);
     
         // 默认类型为 &str
         // 字符串字面量模式是静态的,这意味着字符串字面量从创建时开始会一直保存到程序结束
         let city = "上海";
         // 字符串面量默认就是静态的,也可以通过 static 关键字显式声明
         let programmer: &'static str = "rust coder";
         let url = "http://example.com";
         // 将字符串面量转成 Sting 对象
         let mut blog = url.to_string().replace("http://", "");
         println!("city: {1}, programmer: {0}, blog: {blog}", programmer, city, blog = blog);
     
         // 字符串对象
         let mut phone = String::new();
         phone.push_str("Apple iPhone");
         let iphone = String::from(phone);
         let model = String::from("XS");
         println!("{} {}", iphone, model);
     }
     /*
     special character is @
     alphabet is A
     chinese is 丁
     emoji is 🦀
     city: 上海, programmer: rust coder, blog: example.com
     Apple iPhone XS
     */

    变量定义

    常量与不可变变量的区别

    • 常量名的命名规则可变量的命名规则一样,但常量名一般都是大写字母

    • 定义常量时必须指定数据类型,而定义变量时数据类型可以省略。

    • 常量一旦定义就永远不可变更,不能重新赋值和重新定义

    • 常量只能被赋值为常量表达式/数学表达式,不能是函数返回值或者其它只有在运行时才能确定的值。

    • 常量只是一个符号,会在编译时替换为具体的值,类似于 C 语言中的 #define 定义的符号。

     fn main() {
         // 通过 let 声明的变量是不可变的
         // 类似于 Java 中 使用 final 关键字修饰变量
         let msg = "hello";
     
         // 再次赋值将出现 unexpected token 错误
         // msg = "world"
     
         // 通过 mut 关键字声明的变量可以被修改
         let mut num = 16;
         num *= 2;
     
         // let 重新声明同名变量会砍掉之前的变量
         // 如果需要之前变量值则会先取到值再重新分配地址
         // 可以通过查看内存地址查看变化
         let count = 32;
         println!("old pointer is {:p}", &count);
         let count = 32 + count;
         println!("new pointer is {:p}", &count);
     
         const NUMBER: u64 = 99;
     
         // 常量再次赋值或定义将会抛出错误
         // const NUMBER:usize = msg.len();
     
         println!("msg: {}, num: {}, count: {}, NUMBER: {}", msg, num, count, NUMBER);
     }
     /*
     old pointer is 0x7fff6a496274
     new pointer is 0x7fff6a4962cc
     msg: hello, num: 32, count: 64, Number: 99
     */


    填坑中。。。

    本文标题:RUST 入坑笔记
    本文链接:https://lanseyujie.com/post/rust-learning-notes.html
    版权声明:本文使用「署名-非商业性使用-相同方式共享」创作共享协议,转载或使用请遵守署名协议。
    点赞 0 分享 0
    上一篇:Git 提交规范