画板

变量与函数

  • rust支持类型推导，在编译器能够推导类型的情况下，变量类型一般可以省略(例如像java中我们也可用var关键字来做变量定义)，但常量（const）和静态变量（static）必须声明类型。
  • 函数是一等公民，可以作为参数或者返回值 
  1. fn add(x: i32, y: i32) -> i32 { 
  2.     x + y 
  3. }
  5. fn sub(x: i32, y: i32) -> i32 { 
  6.     x - y 
  7. }
  9. fn div(x: i32, y: i32) -> i32 {
  10.     x / y
  11. }
  13. fn mul(x: i32, y: i32) -> i32 { 
  14.     x * y 
  15. }
  17. // rust不用显式return
  18. fn operate(x: i32, y: i32, f: fn(i32, i32) -> i32) -> i32 {
  19.     f(x, y)
  20. }
  22. fn str_func(str: String) -> fn(i32, i32) -> i32 {
  23.     match str.as_str() { 
  24.         "+"         => add,
  25.         "-"         => sub,
  26.         "*"         => mul,
  27.         "/"         => div,
  28.         _           => add
  29.     }
  30. }
  32. fn main() {
  33.     let xf = String::from("+");
  34.     let x1 = operate(1, 2, str_func(xf));
  35.     println!("({} + {}) = {}", 1, 2, x1);
  36.     let x2 = operate(2, 3, sub);
  37.     println!("({} - {}) = {}", 1, 2, x2);
  38. }
这里 fn(i32, i32) -> i32 是operate的第三个参数，是一个函数。fn(i32, i32) -> i32 是str_func的返回值。 Rust 函数参数的类型和返回值的类型都必须显式定义，如果没有返回值可以省略，返回 unit即为()。函数内部如果提前返回，需要用 return 关键字，否则最后一个表达式就是其返回值。如果最后一个表达式后添加了; 分号，隐含其返回值为 unit即为()。 
  1. // 无申明，默认最后一行 无; 则为返回值，加了; 即无返回值
  2. fn pi() -> f64 {
  3.     3.141592653589793238
  4. }
  6. // 可以显示申明return
  7. fn pi_show() -> f64 {  
  8.     return pi() 
  9. }
  11. fn pi_none() {
  12.     3.141592653589793238;
  13. }
  15. fn pi_none1() -> () {
  16.     3.141592653589793238;
  17. }
  20. fn test_fun_return() {
  21.     let pai: f64 = pi_show();
  22.     println!("{}", pai);
  23.     let xx: () = pi_none();
  24.     let xx1: () = pi_none1();
  25. }

数据结构

  1. // 性别枚举
  2. enum Sex {
  3.     None    = 0,    // 未知的
  4.     Man     = 1,    // 男
  5.     Woman   = 2,    // 女
  6. }
  8. struct User {
  9.     id: i64,        // 用户id
  10.     name: String,   // 用户名称
  11.     sex: Sex,       // 性别
  12. }
  14. struct UserTopic {
  15.     id:     i64,    // 用户队列id
  16.     name:   String, // 用户队列名称
  17.     owner:  i64,    // 用户id
  18. }
  20. enum MessageType { 
  21.     None        = 0, // 未知
  22.     Text        = 1, // 文本
  23.     Emoji       = 2, // 表情
  24.     RedEnvelope = 3, // 红包
  25.     Image       = 4, // 图片
  26.  }
  28. /**
  29.  * 元组结构体
  30.  * 没有字段名称，通过 . 和下标来进行访问：
  31.  */
  32. struct Message(MessageType, String);
  34. // Event：标准的标签联合体，它定义了三种事件：Join、Leave、Message。每种事件都有自己的数据结构。
  35. enum Event{
  36.     // 元组结构体
  37.     Join(i64, i64),                 // i64[用户id], i64[topicid]
  38.     Leave(i64, i64),                // i64[用户id], i64[topicid]
  39.     SendMessage(i64, i64, Message), // i64[用户id], i64[topicid], Message[消息]
  40. }
  42. fn test_data_struct() {
  43.     let user1 = User { id: 1, name: "user1".into(), sex: Sex::Man };
  44.     let user1_topic = UserTopic { id: 1, name: "/chat/user1/topic".into(), owner: user1.id };
  46.     let user2 = User { id: 2, name: "user2".into(), sex: Sex::Woman };
  47.     let user2_topic = UserTopic { id: 2, name: "/chat/user2/topic".into(), owner: user2.id };
  49.     let event1 = Event::Join(user1.id, user1_topic.id);
  50.     let event2 = Event::Join(user2.id, user2_topic.id);
  51.     // 发给 user1 一条消息的事件
  52.     let event3 = Event::SendMessage(user1.id, user1_topic.id, Message(MessageType::Text, "hello rust!".into()));
  53. }