Rust的入门篇(上)

Rust的入门篇(上)

最近跟着菜鸟一起入门了比较火的Rust语言,下面整理一下学习的笔记吧。

1. Helloworld程序

rust 复制代码
fn main(){
    println!("hello rust")
}

2. 格式化字符串

rust 复制代码
fn main(){
    let a = 12;
    // 格式化字符串
    println!("a={}", a);
    println!("a={}, a={}", a, a);
    println!("a={0}, again a={0}", a);

    println!("{{}}")

}

3. 基础运算

rust 复制代码
fn main(){
    // 不可变的变量,强类型语言,但是会自动推测变量的类型
    let a  = 123;
    let a = 1234;
    // 上面是合法的,可以重复声明

    // 可改变的变量
    let mut a = 123;
    a = 456;
    println!("{}", a);

    // const b = 123;
    // let b = 456;

    // 手动指定变量的类型,如果不指定,默认是u32
    let c : u64 = 345;
    // 变量的重影 shadowing 大直白是自己给自己赋值
    let x = 5;
    let x = x + 1;
    let x = x * 2;
    // 12
    println!("The value of x is {}", x);

}

4. 变量的类型

rust 复制代码
fn main(){
    // 默认推测的是f64
    let a  = 2.0;
    let y:f32 = 3.0;

    let sum = 5 + 10;
    let difference = 95.5 - 4.3;
    let product = 4 * 30;
    let quotient = 56.7 / 32.2;
    let remainder = 423 % 5;

    // 复合类型 元组
    let tup:(i32, f64, u8) = (500, 6.4, 1);
    let (x, y, z) = tup;
    // y=6.4
    println!("y={}", y);

    let a = [1, 2, 3, 4, 5];
    let b = ["January", "February", "March"];
    let c:[i32; 5] = [1, 2, 3, 4, 5];

    // 等同于 let d = [3, 3, 3, 3, 3];
    let d = [3;5];

    let first = a[0];
    let second = a[1];
    println!("first={}, second={}", first, second);
    
    // a[0] = 123; // 错误,数组a不可变

    let mut a = [1, 2, 3];
    a[0] = 4;
    // println!("{}", a);
    
}

5. 函数举例

rust 复制代码
fn main(){
    println!("Hello, world!");

    let x = 5;
    let y = {
        let x = 3;
        x + 1
    };
    println!("x={}", x);
    println!("y={}", y);

    fn five()->i32{5}
    println!("five={}", five());

}

fn another_function(){
    println!("Hello, runoob!");
}

fn add(a:i32, b:i32)->i32{
    return a+b;
}

6. 条件语句

rust 复制代码
fn main(){
    let number = 3;
    // 条件语句
    if number < 5{
        println!("true");
    } else {
        println!("false");
    }

    let a = 3;
    // 三目运算符
    let number = if a > 0 {1} else {-1};
    println!("number={}", number);
}

7. 循环

rust 复制代码
fn main(){
    let mut number = 1;

    // while语句
    while number!=4{
        println!("{}", number);
        number += 1;
    }
    println!("EXIT");

    // while循环
    let mut i = 0;
    while i < 10 {
        i += 1;
    }
    println!("i={}", i);

    // for 语句
    let a = [10, 20, 30, 40, 50];
    for i in a.iter(){
        println!("a={} ", i);
    }

    // 下标访问
    let a = [10, 20, 30, 40, 50];
    for i in 0..5{
        println!("a[{}] = {}", i, a[i]);
    }
    
    // loop无线循环
    let s = ['R', 'U', 'N', 'O', 'O', 'B'];
    let mut i = 0;
    loop {
        let ch = s[i];
        if ch == 'O'{
            break;
        }
        println!("\'{}\'", ch);
        i += 1;
    }


    let s = ['R', 'U', 'N', 'O', 'O', 'B'];
    let mut i = 0;
    let location = loop{
        let ch = s[i];
        if ch == 'O'{
            break i;
        }
        i += 1;
    };
    println!(" \'O\' index {}", location);


}

8. 所有权一

所有权是Rust里面一个比较新的概念。一个变量赋值到另一个变量上面的时候,所有权就会发生转移,如果这时候再去访问原来的变量就会出错了。

rust 复制代码
fn main(){
    // 所有权
    let a = "hello";
    let b = a;
    println!("{} world", b);

    let s1 = String::from("world");
    let s2 = s1;
    // 错误 s1 已经不存在了
    // println!("{}, world", s1); 
    println!("{}, world", s2);

    let s1 = String::from("hello");
    // 使用克隆解决上面的问题
    let s2 = s1.clone();

    println!("s1={}, s2={}", s1, s2);


}

9. 所有权二

rust 复制代码
// 函数所有权机制

fn main(){
    let s = String::from("hello");
    // 所有权转移到函数中
    take_ownership(s);
    // 报错了,s已经不存在了
    // println!("{}", s);


    let x = 5;
    makes_copy(x);
    println!("{}", x);

}


fn take_ownership(some_string: String){
    println!("{}", some_string);
}

fn makes_copy(some_integer:i32){
    println!("{}", some_integer);
}

10. 所有权三 函数所有权转移

rust 复制代码
// 函数所有权机制

fn main(){
    let s1 = gives_ownership();

    let s2 = String::from("hello");

    let s3 = takes_and_gives_back(s2);

    println!("s3={}", s3);


}

// 返回所有权
fn gives_ownership()->String{
    let some_string = String::from("hello");
    return some_string;
}

// 获取和返回所有权
fn takes_and_gives_back(a_string:String)->String{
      return a_string; // 被当做返回值移出函数
}

11. 所有权四 引用

rust 复制代码
// 引用与租借
fn main(){
    let s1 = String::from("hello");
    // 引用并不会交出所有权
    let s2 = &s1;
    println!("s1 is {}, s2 is {}", s1, s2);

    // 引用传参
    let s1 = String::from("hello");
    let len = calculate_length(&s1);

    println!("The length of '{}' is  {}.", s1, len);

}


// 引用传参
fn calculate_length(s:&String)->usize{
    s.len()
}

12. 引用四 可变引用

rust 复制代码
fn main(){
    // 引用只是把所有权租借,容易产生问题的代码
    let s1 = String::from("hello");
    // s2引用了s1
    let mut s2 = &s1;
    // s1把拥有权给了s3,s1不再可用
    let s3 = s1;

    // 下面错误,s2租借的s1已经不可用
    // println!("{}", s2);

    // s2重新向s3 borrow所有权
    s2 = &s3;
    println!("s2={}", s2);

    
    let mut s4 = String::from("hello");
    s4.push_str(" world");
    println!("{}", s4);
    
    // s5引用s4
    let s5 = &s4;
    // 错误,租借后不允许修改
    // s5.push_str(" rust");

    // 如果需要修改,s6引用s4并允许修改
    let s6 = &mut s4;
    s6.push_str(" oob");
    println!("{}", s6);

    // 不可以被多次可变引用
    let mut s7 = String::from("hello");
    // let r1 = &mut s7;
    // let r2 = &mut s7;
    // println!("r1={}, r2={}", r1, r2);

    // // 垂悬引用, 不允许出现
    // let ref_nothing = dangle();


}


// 垂悬引用, 不允许出现
// fn dangle()->&String{
//     let s = String::from("hello");
//     &s
// }

13. slice 字符串切片操作

rust 复制代码
// 切片操作     
fn main(){
    let s = String::from("broadcast");
    // 字符串切片
    let part1 = &s[0..5];
    let part2 = &s[5..9];
    println!("{}={}+{}", s, part1, part2);

    //被切片引用的字符串禁止更改其值
    // let mut s = String::from("runoob");
    // let slice = &s[0..3];
    // slice.push_str("yes!");
    // println!("slice={}", slice);

    // String 类型是 Rust 标准公共库提供的一种数据类型,
    // 它的功能更完善------它支持字符串的追加、清空等实用的操作。
    // String 和 str 除了同样拥有一个字符开始位置属性和一个字符串长度
    // 属性以外还有一个容量(capacity)属性。
    let slice = &s[0..3];

    // 快速将String转成&str
    let s1 = String::from("hello");
    let s2 = &s1[..];
    
    // 其他数据类型的切片操作
    let arr = [1, 3, 5, 7, 9];
    let part = &arr[0..3];
    for i in part.iter(){
        println!("i={}", i);
    }

    
}

14. 结构体一

rust 复制代码
// 结构体

use std::string;



fn main(){
    // 初始化结构体
    let runoob = Site{
        domain: String::from("www.runoob.com"),
        name: String::from("runnob"),
        nation: String::from("china"),
        found: 2013
    };

    let domain = String::from("www.runoob.com");
    let name = String::from("runoob");
    let runnob2 = Site{
        domain,
        name,
        nation:String::from("china"),
        found: 2013
    };

    // 使用旧结构体的部分属性来新建新的结构体
    let site = Site{
        domain: String::from("www.runoob.com"),
        name: String::from("runoob"),
        ..runoob
    };

    // 元组结构体初始化
    let black = Color(0, 0, 0);
    let origin: Point = Point(0.0, 0.0);

    println!("black = ({}, {}, {})", black.0, black.1, black.2);
    println!("origin = ({}, {})", origin.0, origin.1);

    // 打印结构体
    let rect1 = Rectangle{
        width:30,
        height:50
    };
    // println!("rect1 is {:#?}", rect1);


}

// 结构体
struct Site{
    domain:String,
    name:String,
    nation:String,
    found:u32
}

// 元组结构体
struct Color(u8, u8, u8);
struct Point(f64, f64);

// 输出完整的结构体
struct Rectangle{
    width: u32,
    height: u32,
}

15. 结构体二 结构体方法

结构体方法的第一个参数必须是 &self,不需声明类型,因为 self 不是一种风格而是关键字。

rust 复制代码
fn main(){
    let rect1 = Rectangle{width:30, height:50};
    println!("rect1's area is {}", rect1.area());
}

struct Rectangle{
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self)->u32{
        self.width*self.height
    }
}

16. 结构体三

rust 复制代码
fn main(){
    let rect1 = Rectangle{width:30, height:50};
    let rect2=Rectangle{width:40, height:20};
    println!("{}", rect1.wider(&rect2));

}

struct Rectangle{
    width: u32,
    height: u32,
}

// 结构体方法
impl Rectangle {
    fn area(&self)->u32{
        self.width*self.height
    }
    fn wider(&self, rect:&Rectangle)->bool{
        self.width > rect.width
    }
}

17. 枚举类型一

rust 复制代码
fn main(){
    enum Book {
        Popery(u32),
        Electronic(String),
    }
    let book = Book::Popery(1001);
    let ebook = Book::Electronic(String::from("url://..."));

}

18. 枚举类型二

rust 复制代码
fn main(){
    // 枚举属性命名
    enum Book {
        Papery {index: u32},
        Electronic{url: String},
    }

    let book = Book::Papery { index: 1001 };

}

19. 枚举类型三

rust 复制代码
fn main(){
    // 枚举属性命名
    enum Book {
        Papery {index: u32},
        Electronic{url: String},
    }

    let book = Book::Papery { index: 1001 };
    let ebook = Book::Electronic { url: String::from("url...") };
    // 打印book有的属性
    match book{
        Book::Papery { index } =>{
            println!("Papery book {}", index);
        },
        Book::Electronic { url }=>{
            println!("E-book {}", url);
        }
    }
    // 打印ebook有的属性
    match ebook{
        Book::Papery { index } =>{
            println!("Papery book {}", index);
        },
        Book::Electronic { url }=>{
            println!("E-book {}", url);
        }
    }

}

20. 枚举类型四

rust 复制代码
// option 枚举类
fn main(){
    let opt = Option::Some("hello");
    match opt{
        Option::Some(something)=>{
            println!("{}", something);
        },
        Option::None=>{
            println!("opt is nothing");
        }
    }
    // hello

    let opt1:Option<&str> = Option::None;
    match opt1{
        Option::Some(something)=>{
            println!("{}", something);
        }
        Option::None=>{
            println!("opt1 is nothing");
        }
    }
    // opt is nothing

    // 由于 Option 是 Rust 编译器默认引入的,在使用时可以省略 Option:: 直接写 None 或者 Some()。
    let t = Some(64);
    match t{
        Some(64)=>println!("yes"),
        _=>println!("No"),
    }
    // yes



}

21. 枚举类型五

rust 复制代码
// option 枚举类
fn main(){
    // if let 用法
    let i = 0;
    if let 0 = i {
        println!("zero");
    }

    enum Book {
        Papery(u32),
        Electronic(String)
    }
    let book = Book::Electronic(String::from("url"));
    if let Book::Papery(index) = book{
        println!("Papery {}", index);
    }else{
        println!("Not papery book");
    }
    // Not papery book

}
相关推荐
码事漫谈5 小时前
以后人人都可以成为导演
后端
Resean02235 小时前
Spring 源码分析(二)配置类的解析与扫描
java·后端·spring
一只爱撸猫的程序猿5 小时前
五周、两个开源仓库、九次拦截之后:AI 时代程序员缺的到底是什么
人工智能·后端·开源
ShineWinsu6 小时前
对于Qt:QFormLayout常见属性以及方法的解析
开发语言·c++·qt·面试·客户端·表单·qformlayout
北城笑笑7 小时前
Vue 110 ,若依SSE流式接口限次空500排查与解决
前端·javascript·vue.js·后端·vue
ServBay7 小时前
Local harness 将退役,VS Code 本地开发要不要搬到云端?
后端·ai编程·visual studio code
ashiho8 小时前
【LeetCode hot 100】3. 无重复字符的最长子串 (三种解法)
java·数据结构·后端·算法·leetcode·滑动窗口
张一凡939 小时前
你的 AGENTS.md,真的管到模型写代码了吗?
前端·后端·agent
00后程序员9 小时前
iOS 实时活动怎么开发,Windows 上用 KXBuild 和 ActivityKit 写灵动岛
后端·ios
程序员cxuan9 小时前
推荐 10 个 WorkBuddy 中的邪修用法
人工智能·后端·程序员