rust02 문법

큰따옴표와 큰따옴표

잘못된 작법

fn main() {
    println!('hello world');
}


#  
error: character literal may only contain one codepoint: ')
 --> src/main.rs:2:26
  |
2 |     println!('hello world')
                             ^^

정확한 작법

fn main() {
    println!("hello world");
}

작은 매듭
변수 정의는 모두 더블 따옴표를 사용하고 단일 따옴표를 사용할 수 없습니다.

행 끝 문자;

잘못된 작법

fn main() {
    println!("hello world")
    println!("sssssssssss")
}


#  
error: expected one of `.`, `;`, `?`, `}`, or an operator, found `println`
 --> src/main.rs:3:5
  |
2 |     println!("hello world")
  |                            - expected one of `.`, `;`, `?`, `}`, or an operator here

정확한 작법

fn main() {
    println!("hello world");
    println!("sssssssssss");
}

작은 매듭
줄마다 실행 코드 뒤에 줄 끝 문자;가 있는 것이 가장 좋다.

움츠리다

들여쓰기 없음(지원)

fn main() {
println!("hello world"); 
}

스페이스 바 들여쓰기 (지원)

fn main() {
    println!("hello world");
}

tab 들여쓰기(지원)

fn main() {
        println!("hello world");
}

작은 매듭
rust는 축소에 대한 요구가 없지만 코드 블록을 4개의 공백으로 축소하는 것을 권장합니다.

main 특수 함수

코드를 전역 작용 영역에 직접 노출시키는 것은main을 쓰지 않는다는 것이다.

println!("hello world");


#  
error: macros that expand to items must either be surrounded with braces or followed by a semicolon
 --> :2:9
  |
2 | print ! ( concat ! ( $ fmt , "
" ) ) ) ; ( $ fmt : expr , $ ( $ arg : tt ) *
  |         ^^^^^^^^^^^^^^^^^^^

코드를 함수에 봉인하고main을 쓰지 않습니다.

fn simple() {
    println!("hello world");
}


#  
error: main function not found

정확한 작법

fn simple() {
    println!("hello world");
}

fn main() {
    simple();
}

main 함수는 매개 변수를 정의할 수 없습니다

fn main(first: i32, second: f64) {     //  
    println!("{} {}", first, second)
}

main 함수는 반환 값을 정의할 수 없습니다

fn main() -> String {                   //  
    let s = String::from("hello");
    s
}

일반 함수 사용return 반환값

fn simple_function() -> i32 {
    let s = 10;
    return s
}

fn main() {
    let s = simple_function();
    println!("{}", s)
}

일반 함수 없음return 반환값(공식 추천, 원본 규범)

fn simple_function() -> i32 {
    let s = 10;
    s
}

fn main() {
    let s = simple_function();
    println!("{}", s)
}

작은 매듭

전역 역할 영역에서 실행 유형의 문장을 직접 작성할 수 없습니다.

main의 특수 함수는 모든 프로그램의 입구이기 때문에 모든 코드를 봉한 후main에 넣어서rust에 식별되고 실행해야 한다.

변수

변수는 함수 밖으로 정의할 수 없습니다

let s = "a";

fn main() {
    println!("hello world! {}", s)
}


#  
error: expected item, found `let`
 --> main.rs:1:1
  |
1 | let s = "a";
  | ^^^
  


#  
fn main() {
    let s = "a";   //  
    println!("hello world! {}", s);
}

변수는 직접 인쇄할 수 없습니다.

fn main() {
    let s = "a";
    println!(s);
}

#  
error: expected a literal
 --> main.rs:3:14
  |
3 |     println!(s);
  |              ^
  
  
  
#  
fn main() {
    let s = "a";
    let x = "xxx";
    println!("{} {}", s, x);
}

변수는 기본적으로 수정할 수 없습니다.

fn main() {
    let s = 1;
    s += 2;
    println!("{}", s)
}

#  
error[E0384]: re-assignment of immutable variable `s`
 --> main.rs:3:5
  |
2 |     let s = 1;
  |         - first assignment to `s`
3 |     s += 2;
  |     ^^^^^^ re-assignment of immutable variable



#  
fn main() {
    let mut s = 1;
    s += 2;
    println!("{}", s);
}

변경 가능한 변수는 유형이 같아야 합니다.

fn main() {
    let mut s = 10;
    s += 'abc';
}

#  
error: character literal may only contain one codepoint: 'abc'
  --> main.rs:25:10
   |
25 |     s += 'abc';
   |          ^^^^^

error: aborting due to previous error(s)

변수 숨기기(Shadowing)

fn main() {
    let s = 1;
    let s = 2 + 10;
    println!("{}", s);
}


#  ,  ;  
#  ,  `let s = 1` 
#  ,  .
   Compiling datatype v0.1.0 (file:///opt/learn_rust/datatype)
warning: unused variable: `s`
 --> src/main.rs:2:9
  |
2 |     let s = 1;
  |         ^
  |
  = note: #[warn(unused_variables)] on by default

    Finished dev [unoptimized + debuginfo] target(s) in 0.46 secs
     Running `target/debug/datatype`
12



#  Shadowing 
fn main() {
    let s = 1;
    let s = s + 10;
    println!("{}", s);
}

변수 할당

정수 유형 변수

fn main() {
    // "i32"   
    //  : -(2 ** (32 - 1))  ~  (2 ** (32 - 1)) -1
    //  : -2147483648     ~   2147483647
    let s = 150;          
    println!("{}", s);    
}


fn main() {
    // "u32"   
    //  : 0 ~ (2 ** (32 - 1)) -1
    //  : 0 ~  4294967295
    let s: u32 = 4294967295;          
    println!("{}", s);    
}

부동 소수점 유형 변수

fn main() {
    let s = 3.14;       // "f64"
    println!("{}", s);
}

문자열 변수

fn main() {
    let s = "hello";      // "&str"
    println!("{}", s);
}

수조 숫자 변수

fn main() {
    let s = [1, 2, 3, 4];   // "[i32; 4]"
    println!("{}", s);
}



#  ,
   Compiling datatype v0.1.0 (file:///opt/learn_rust/datatype)
error[E0277]: the trait bound `[{integer}; 4]: std::fmt::Display` is not satisfied
 --> src/main.rs:3:20
  |
3 |     println!("{}", s);
  |                    ^ the trait `std::fmt::Display` is not implemented for `[{integer}; 4]`
  |
  = note: `[{integer}; 4]` cannot be formatted with the default formatter; try using `:?` instead if you are using a format string
  = note: required by `std::fmt::Display::fmt`

error: aborting due to previous error

error: Could not compile `datatype`.

To learn more, run the command again with --verbose.



#  
fn main() {
    let s = [1, 2, 3, 4];     // "[i32; 4]"
    println!("{:?}", s);
}

배열 문자열 변수

fn main() {
    let s = ["a", "b", "c"];     // "[&str; 3]"
    println!("{:?}", s);
}

배열 혼합 요소

#  ,  ,  :
# https://rustbyexample.com/primitives/array.html  

fn main() {
    let s = ["a", 1, 2, "b"];     
    println!("{:?}", s);
}

error[E0308]: mismatched types
  --> main.rs:12:19
   |
12 |     let s = ["a", 1, 2, "b"];
   |                   ^ expected &str, found integral variable
   |
   = note: expected type `&str`
              found type `{integer}`

error: aborting due to previous error(s)




#  ,  .
#  
fn main() {
    let s = [
        ["a", "b", "c", "d"],
        ["e", "f", "g", "h", "i"],
    ];   
    println!("{:?}", s);
}

#  
fn main() {
    let s = [                               // "[[&str; 4]; 6]"
        ["a", "b", "c", "d"],
        ["e", "f", "g", "h"],
        ["i", "j", "k", "l"],
        ["m", "n", "o", "p"],
        ["q", "r", "s", "t"],
        ["q", "r", "s", "t"],
    ];  
    println!("{:?}", s);
}

#  
fn main() {
    let s = [                               // "[(&str, i32); 6]"
        ("a", 1), ("b", 2), ("c", 3),
        ("d", 4), ("e", 5), ("f", 6),
    ];   
    println!("{:?}", s);
}

원조 숫자 변수

fn main() {
    let s = (1, 2, 3, 4, 5);                // "(i32, i32, i32, i32, i32)"
    println!("{:?}", s);
}

기본 문자열 변수

fn main() {
    let s = ("a", "b", "c");                // "(&str, &str, &str)"
    println!("{:?}", s);
}

원조 혼합 변수

fn main() {
    let s = (                               
        "a", 1, 2, "b",                     // "(&str, i32, i32, &str, 
        [3, 4], ["c", "d"],                 //   [i32; 2], [&str; 2], 
        [[4, 5], [6, 7]],                   //   [[i32; 2]; 2], 
        [["e", "f"], ["g", "h"]]            //   [[&str; 2]; 2])"
    );
    println!("{:?}", s);
}

이 변수 유형을 어떻게 인쇄합니까?

//  rust-nightly .
//  : https://users.rust-lang.org/t/get-the-type-of-a-var/3618/2

#![feature(core_intrinsics)]

use std::intrinsics::type_name;

fn test_type(_: T) {
    println!("{:?}", unsafe { type_name::() });
}

fn main() {
    let s = (
        "a", 1, 2, "b",
        [3, 4], ["c", "d"],
        [[4, 5], [6, 7]],
        [["e", "f"], ["g", "h"]]
    );
    test_type(s);
}

상량

문자열 상수

const program_language: &'static str = "Rust";

fn main() {
    let hello = "Hello";
    println!("{} {}!", hello, program_language);
}


#  ,  ;
#  ;
   Compiling datatype v0.1.0 (file:///opt/learn_rust/datatype)
warning: constant `program_language` should have an upper case name such as `PROGRAM_LANGUAGE`
 --> src/main.rs:1:1
  |
1 | const program_language: &'static str = "Rust";
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: #[warn(non_upper_case_globals)] on by default

    Finished dev [unoptimized + debuginfo] target(s) in 0.43 secs
     Running `target/debug/datatype`
Hello Rust!



#  
const PROGRAM_LANGUAGE: &'static str = "Rust";

fn main() {
    let hello = "Hello";
    println!("{} {}!", hello, PROGRAM_LANGUAGE);
}

부동 상수

const PROGRAM_VERSION: f64 = 1.18;
const PROGRAM_LANGUAGE: &'static str = "Rust";

fn main() {
    let hello = "Hello";
    println!("{} {}: {}!", hello, PROGRAM_LANGUAGE, PROGRAM_VERSION);
}

정수 상수

#  ,  ,  .
const NUMBER: i32 = 100_000_000;

fn main() {
    println!("{}", NUMBER);     //  : 100000000 
}


#  : "i32"     i == sign ==  (- )
#  : -(2 ** (32 - 1))  ~  (2 ** (32 - 1)) -1
#  : -2147483648     ~   2147483647
const ROLLBACK_VERSION: i32 = 2;  
const PROGRAM_LANGUAGE: &'static str = "Rust";

fn main() {
    let hello = "Hello";
    println!("{} {}: {}!", hello, PROGRAM_LANGUAGE, ROLLBACK_VERSION);
}




#  : "u32"     u == unsign ==  ( )
#  : 0 ~ (2 ** (32 - 1)) -1
#  : 0 ~  4294967295
const ROLLBACK_VERSION: i32 = 2;  
const PROGRAM_LANGUAGE: &'static str = "Rust";

fn main() {
    let hello = "Hello";
    println!("{} {}: {}!", hello, PROGRAM_LANGUAGE, ROLLBACK_VERSION);
}

수조 숫자 상수

const DATA_TYPE_ARRAY: &'static [i32] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

fn main() {
    let hello = "Hello";
    println!("{} {:?}", hello, DATA_TYPE_ARRAY);
}



#  
const DATA_TYPE_ARRAY: &'static [i32; 10] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

fn main() {
    let hello = "Hello";
    println!("{} {:?}", hello, DATA_TYPE_ARRAY);
}

배열 문자열 상수

const DATA_TYPE_ARRAY: &'static [&'static str] = &["a", "b"];

fn main() {
    let hello = "Hello";
    println!("{} {:?}", hello, DATA_TYPE_ARRAY);
}



#  
const DATA_TYPE_ARRAY: &'static [&'static str; 2] = &["a", "b"];

fn main() {
    let hello = "Hello";
    println!("{} {:?}", hello, DATA_TYPE_ARRAY);
}

수조 수조 상수

#  
const DATA_TYPE_ARRAY: [[i32; 2]; 2] = [[1, 2], [3, 4]];

fn main() {
    let hello = "Hello";
    println!("{} {:?}", hello, DATA_TYPE_ARRAY);
}



#  
const DATA_TYPE_ARRAY: [(&str, i32); 2] = [("a", 1), ("b", 2)];

fn main() {
    let hello = "Hello";
    println!("{} {:?}", hello, DATA_TYPE_ARRAY);
}

원조 문자열 상수

const DATA_TYPE_ARRAY: (&str, &str, &str, i32, i32, i32) = ("a", "b", "c", 1, 2, 3);

fn main() {
    let hello = "Hello";
    println!("{} {:?}", hello, DATA_TYPE_ARRAY);
}



#  
const DATA_TYPE_ARRAY: (
    &'static str, &'static str, &'static str, i32, i32, i32
) = ("a", "b", "c", 1, 2, 3);

fn main() {
    let hello = "Hello";
    println!("{} {:?}", hello, DATA_TYPE_ARRAY);
}

순환

for 순환 그룹 (교체)

#  
fn main() {
    let a = [1, 2, 3, 4, 5, 6, 7, 8, 9];

    for i in a {
        println!("{}", i)
    }
}


#  
fn main() {
    let a = [1, 2, 3, 4, 5, 6, 7, 8, 9];

    for i in a.iter() {
        println!("{}", i)
    }
}

for 순환 교체 대상(교체)


# 1..9 == [1,2,3,4,5,6,7,8,9].iter()
# 1..9 == Iter(1,2,3,4,5,6,7,8,9)
# 1..9 
fn main() {
    for i in 1..9 {
        println!("{}", i)
    }
}


#  
fn main() {
    for i in (1..9).rev() {
        println!("{:?}", i)
    }
}

#  
fn main() {
    let a = [1,2,3,4,5,6,7,8,9];
    for i in a.iter().rev() {
        println!("{:?}", i)
    }
}

for 루프continue 키워드

#  30 
fn main() {
    let a = 1..100;
    for i in a {
        if i < 30 {
            continue
        }
        println!("{:?}", i)
    }
}

for 루프break 키워드

#  30 ， 
fn main() {
    let a = 1..100;
    for i in a {
        println!("{:?}", i);
        if i > 30 {
            break
        }
    }
}

while 순환

#  30 ,  
fn main() {
    let mut a = 1;
    while a < 30 {
        println!("{}", a);
        a += 1
    }
}


#  30 ,  
fn main() {
    let mut a = 1;
    while true {
        if a < 30 {
            println!("{}", a);
        } else {
            break
        }
        a += 1
    }
}

loop 순환

fn main() {
    let mut a = 1;
    loop {
        if a < 30 {
            println!("{}", a)
        }
        a += 1
    }
}

while true와 loop은 어떤 차이가 있습니까?

순환의 측면에서 보면 그것들은 차이가 없다.컴파일러의 측면에서 볼 때while 뒤에 있는 조건문의 해석은loop은 조건문의 해석이 없기 때문에loop이론적으로while보다 빠르다.프로그래머의 측면에서 볼 때while는 하나의 구체적인 업무 논리적 판단을 하는 데 쓰인다.한편, loop은 더욱 거시적인 모듈 코드 설계를 위해 사용하고 논리적 판단을 추상층에 의존하여 완성한다. 예를 들어read_라인은 계속하거나 종료할지 여부를 판단하기 위해 사용자 입력을 가져옵니다.

일일이 열거하다

매거는 하나의 대상의 모든 속성 정의를 설정하는 데 사용되며, 프로그램이 실행 과정에서 이 대상과 관련되었을 때, 입력과 출력이 예상 이외의 값을 초과하지 않도록 하는 데 사용된다.
매거 구성원은 특수한 유형 값이다
매거는 그 구성원이 int, str, String, Array 또는 Tuple가 아니라 변수 이름과 같은 특수한 표지가 될 수 있도록 허용한다.

#[derive(Debug)]        // trait
enum UserRole {         //  
    Admin,              //  
    Manager,            
    Employee
}


fn main() {
    let admin = UserRole::Admin;        //  
    let manager = UserRole::Manager;    
    let employee = UserRole::Employee;
    println!("{:?} {:?} {:?}", admin, manager, employee);
    println!("{:?}", UserRole::Admin);  //  ， 。
}

매거 일치

#[derive(Debug)]
enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}


fn value_in_cents(coin: Coin) -> i32 {
    match coin {
        Coin::Penny => {
            println!("Match Penny");
            1
        },
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}


fn main() {
    println!("{:?}", value_in_cents(Coin::Penny))
}

매거중첩

#[derive(Debug)]      // trait
enum UsState {        //  
    Alabama,          //  
    Alaska,
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),     //  ,  Quarter .
}

fn value_in_cents(coin: Coin) -> i32 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        //   state  ，  abc
        Coin::Quarter(state) => {
            //  state ,  .
            println!("State quarter from {:?}!", state);
            25
        },
    }
}

fn main() {
    println!("{:?}", value_in_cents(Coin::Penny));
    println!("{:?}", value_in_cents(Coin::Nickel));
    println!("{:?}", value_in_cents(Coin::Dime));
    println!("{:?}", value_in_cents(Coin::Quarter(UsState::Alabama)));
    println!("{:?}", value_in_cents(Coin::Quarter(UsState::Alaska)))
}

Some 특수 열거 멤버

표준 match 쓰기

fn main() {
    let integer_ = Some(4u8);    // Some 
    match integer_ {
        Some(4) => println!("four"),
        _ => println!("unknown"),     // _ ( :  )
    }
}

iflet 표현식은 match의 줄임말 문법 설탕이다

fn main() {
    let integer_ = Some(4u8);
    if let Some(4) = integer_ {
        println!("four");
    }
}

if let ... else ... 표현식

fn main() {
    let integer_ = Some(4u8);
    if let Some(6) = integer_ {    //  .
        println!("four")                //  .
    } else {
        println!("unknown")
    }
}

이 내용에 흥미가 있습니까?

현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:

다양한 언어의 JSON

JSON은 Javascript 표기법을 사용하여 데이터 구조를 레이아웃하는 데이터 형식입니다. 그러나 Javascript가 코드에서 이러한 구조를 나타낼 수 있는 유일한 언어는 아닙니다. 저는 일반적으로 '객체'{}...

텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.

CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.

rust02 문법

큰따옴표와 큰따옴표

행 끝 문자;

움츠리다

main 특수 함수

변수

변수 할당

상량

순환

while true와 loop은 어떤 차이가 있습니까?

일일이 열거하다

표준 match 쓰기

iflet 표현식은 match의 줄임말 문법 설탕이다

if let ... else ... 표현식

좋은 웹페이지 즐겨찾기