从零开始学 Rust:基本概念——变量、数据类型、函数、控制流

文章目录

    • [Variables and Mutability](#Variables and Mutability)
    • [Data Types](#Data Types)
      • [Scalar Types](#Scalar Types)
      • [Compound Types](#Compound Types)
    • Functions
      • [Function Parameters](#Function Parameters)
    • Comments
    • [Control Flow](#Control Flow)
      • [Repetition with Loops](#Repetition with Loops)

Variables and Mutability

rust 复制代码
fn main() {
    let mut x = 5;
    println!("The value of x is: {}", x);
    x = 6;
    println!("The value of x is: {}", x);
}
rust 复制代码
fn main() {
    let x = 5;
    let x = x + 1;
    let x = x * 2;
    println!("The value of x is: {}", x);
}
  • constant: const MAX_POINTS: u32 = 100_000;

Shadowing

The other difference between mut and shadowing is that because we're effectively creating a new variable when we use the let keyword again, we can change the type of the value but reuse the same name.

Data Types

Keep in mind that Rust is a statically typed language, which means that it must know the types of all variables at compile time.

Scalar Types

  • Integer Types

    • Signed numbers are stored using two's complement representation.
    • Each signed variant can store numbers from − ( 2 n − 1 ) -(2^{n - 1}) −(2n−1) to 2 n − 1 − 1 2^{n - 1} - 1 2n−1−1 inclusive, where n is the number of bits that variant uses. So an i8 can store numbers from − ( 2 7 ) -(2^7) −(27) to 2 7 − 1 2^7 - 1 27−1, which equals -128 to 127. Unsigned variants can store numbers from 0 to 2 n − 1 2^n - 1 2n−1, so a u8 can store numbers from 0 to 2 8 − 1 2^8 - 1 28−1, which equals 0 to 255.
    • The isize and usize types depend on the kind of computer your program is running on: 64 bits if you're on a 64-bit architecture and 32 bits if you're on a 32-bit architecture.
    • All number literals except the byte literal allow a type suffix, such as 57u8, and _ as a visual separator, such as 1_000.
    • Integer Overflow
  • Floating-Point Types

    rust 复制代码
    fn main() {
        let x = 2.0; // f64
        let y: f32 = 3.0; // f32
    }
  • The Boolean Type

  • The Character Type

    • Rust's char type is four bytes in size and represents a Unicode Scalar Value, which means it can represent a lot more than just ASCII.

Compound Types

  • The Tuple Type

    • Tuples have a fixed length: once declared, they cannot grow or shrink in size.

      rust 复制代码
      fn main() {
          let tup: (i32, f64, u8) = (500, 6.4, 1);
      }
    • destructure by pattern matching:

      rust 复制代码
      fn main() {
          let tup = (500, 6.4, 1);
          let (x, y, z) = tup;
          println!("The value of y is: {}", y);
      }
    • period(.):

      rust 复制代码
      fn main() {
          let x: (i32, f64, u8) = (500, 6.4, 1);
          let five_hundred = x.0;
          let six_point_four = x.1;
          let one = x.2;
      }
  • The Array Type (fixed length)

    rust 复制代码
    fn main() {
        let a = [1, 2, 3, 4, 5];
    }
    rust 复制代码
    let a: [i32; 5] = [1, 2, 3, 4, 5];
    rust 复制代码
    let a = [3; 5];
    rust 复制代码
    let a = [3, 3, 3, 3, 3];
    • An array is a single chunk of memory allocated on the stack.
    • Invalid Array Element Access

Functions

You've also seen the fn keyword, which allows you to declare new functions.

Rust code uses snake case as the conventional style for function and variable names.

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

    another_function();
}

fn another_function() {
    println!("Another function.");
}

Rust doesn't care where you define your functions, only that they're defined somewhere.

Function Parameters

  • 形参 parameter
  • 实参 argument
rust 复制代码
fn main() {
    another_function(5, 6);
}

fn another_function(x: i32, y: i32) {
    println!("The value of x is: {}", x);
    println!("The value of y is: {}", y);
}
  • Statements are instructions that perform some action and do not return a value.
  • Expressions evaluate to a resulting value.
  • Statements do not return values. Therefore, you can't assign a let statement to another variable.
rust 复制代码
fn main() {
    let x = 5;

    let y = {
        let x = 3;
        x + 1
    };

    println!("The value of y is: {}", y);
}

This expression:

rust 复制代码
{
    let x = 3;
    x + 1
}

is a block that, in this case, evaluates to 4. That value gets bound to y as part of the let statement. Note the x + 1 line without a semicolon at the end, which is unlike most of the lines you've seen so far. Expressions do not include ending semicolons. If you add a semicolon to the end of an expression, you turn it into a statement, which will then not return a value.

In Rust, the return value of the function is synonymous with the value of the final expression in the block of the body of a function. You can return early from a function by using the return keyword and specifying a value, but most functions return the last expression implicitly.

rust 复制代码
fn five() -> i32 {
    5
}

fn main() {
    let x = five();

    println!("The value of x is: {}", x);
}
rust 复制代码
fn main() {
    let x = plus_one(5);

    println!("The value of x is: {}", x);
}

fn plus_one(x: i32) -> i32 {
    x + 1
}

Comments

Control Flow

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

    if number < 5 {
        println!("condition was true");
    } else {
        println!("condition was false");
    }
}

It's also worth noting that the condition in this code must be a bool.

Rust will not automatically try to convert non-Boolean types to a Boolean. You must be explicit and always provide if with a Boolean as its condition.

rust 复制代码
fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };

    println!("The value of number is: {}", number);
}

In this case, the value of the whole if expression depends on which block of code executes. This means the values that have the potential to be results from each arm of the if must be the same type.

Repetition with Loops

  • loop

    The loop keyword tells Rust to execute a block of code over and over again forever or until you explicitly tell it to stop.

    rust 复制代码
    fn main() {
        let mut counter = 0;
    
        let result = loop {
            counter += 1;
    
            if counter == 10 {
                break counter * 2;
            }
        };
    
        println!("The result is {}", result);
    }
  • while

    rust 复制代码
    	fn main() {
    	    let mut number = 3;
    	
    	    while number != 0 {
    	        println!("{}!", number);
    	
    	        number -= 1;
    	    }
    	
    	    println!("LIFTOFF!!!");
    	}
  • for

    rust 复制代码
    fn main() {
        let a = [10, 20, 30, 40, 50];
    
        for element in a.iter() {
            println!("the value is: {}", element);
        }
    }
    rust 复制代码
    fn main() {
        for number in (1..4).rev() {
            println!("{}!", number);
        }
        println!("LIFTOFF!!!");
    }
相关推荐
励志要当大牛的小白菜1 小时前
ART配对软件使用
开发语言·c++·qt·算法
武子康2 小时前
Java-80 深入浅出 RPC Dubbo 动态服务降级:从雪崩防护到配置中心秒级生效
java·分布式·后端·spring·微服务·rpc·dubbo
舒一笑2 小时前
我的开源项目-PandaCoder迎来史诗级大更新啦
后端·程序员·intellij idea
@昵称不存在3 小时前
Flask input 和datalist结合
后端·python·flask
爱装代码的小瓶子4 小时前
数据结构之队列(C语言)
c语言·开发语言·数据结构
zhuyasen4 小时前
Go 分布式任务和定时任务太难?sasynq 让异步任务从未如此简单
后端·go
东林牧之4 小时前
Django+celery异步:拿来即用,可移植性高
后端·python·django
Maybe_ch5 小时前
.NET-键控服务依赖注入
开发语言·c#·.net
超浪的晨5 小时前
Java UDP 通信详解:从基础到实战,彻底掌握无连接网络编程
java·开发语言·后端·学习·个人开发
终焉暴龙王5 小时前
CTFHub web进阶 php Bypass disable_function通关攻略
开发语言·安全·web安全·php