Rustを学ぶためのコンソールプログラムを使用する

私たちは、Rust を使用してポーランド記法のシンプルなコンソールプログラムを作成します。このプログラムは、浮動小数点数と負数をサポートします。

コンソールからの入力#

Rust では、コンソールからの入力を簡単に取得することができます。標準ライブラリのenvには、コンソールからの入力を取得するための方法が用意されています。

let symbol:String = env::args()
    .nth(1)
    .expect("入力が不完全です");

let var_a:String = env::args().nth(2).expect("入力が不完全です");
let var_b:String = env::args().nth(3).expect("入力が不完全です");


println!("|{}|{}|{}|", symbol, var_a, var_b);

それでは、実行してみましょう。

cargo run -- 1 2 3

問題がなければ、コンソールに次の出力が表示されます。

|1|2|3|

次に、取得したデータを計算モジュールに渡す必要があります。ここで、型変換が必要になります。

型変換#

コンソールアプリケーションが一定の使いやすさを持つようにするために、小数と負数をサポートしています。数値型をf64（浮動小数点数）に変換する必要があります。

fn change_type(var:String) -> f64 {
    let var:f64 = match var.trim().parse() {
        Ok(num) => num,
        Err(_) => {
            println!("エラー：無効な入力です");
            return 0.0;
        }
    };

    var
}

次に、変換した型を保存する方法を見つける必要があります。私はここで配列を使用して保存することにしました。
現在のコードは次のようになります。

fn obtain_var() {
    let symbol:String = env::args().nth(1).expect("入力が不完全です");
    let var_a:String = env::args().nth(2).expect("入力が不完全です");
    let var_b:String = env::args().nth(3).expect("入力が不完全です");

    let number_var:[f64; 2] = [change_type(var_a), change_type(var_b)];
...

また、値を保存する方法が必要です。ここでは、構造体を使用することにしました。
まず、プログラムの先頭で構造体を宣言します。

...
struct ComputeData {
    symbol:String,
    var_a:f64,
    var_b:f64
}
...

次に、この関数が構造体を返すように設定し、値を返すための構造体を作成します。

fn obtain_var() -> ComputeData {
    let symbol:String = env::args().nth(1).expect("入力が不完全です");
    let var_a:String = env::args().nth(2).expect("入力が不完全です");
    let var_b:String = env::args().nth(3).expect("入力が不完全です");

    let number_var:[f64; 2] = [change_type(var_a), change_type(var_b)];

    let data = ComputeData {
        symbol:String::from(symbol),
        var_a:number_var[0],
        var_b:number_var[1]
    };

    data
}

さて、計算関数を書くことができます。

計算#

入力されたデータと結果を返す関数です。

fn compute(symbol:String, var_a:f64, var_b:f64) -> f64

理論的には、matchを使用して値を返すだけで十分ですが、Rust では、String型を直接チェックすることはできません。したがって、&str型に変換する必要があります。
完全なコードは次のようになります。

fn compute(symbol:String, var_a:f64, var_b:f64) -> f64 {
    let symbol:&str = &symbol.to_string()[..];
    match symbol {
        "+" => var_a + var_b,
        "-" => var_a - var_b,
        "*" => var_a * var_b,
        "/" => var_a / var_b,
        _ => {
            println!("無効な計算記号");
            0.0
        }
    }
}

完了！#

次に、main関数を書くだけです。

fn main() {
    println!("{}",compute(
            obtain_var().symbol,
            obtain_var().var_a,
            obtain_var().var_b
        )
    );
}

実行#

cargo run -- 演算子 数字1 数字2

例えば

cargo run -- / 2 5

ターミナルで実行すると、結果は 0.4 になります。

完全なコード#

use std::env;

struct ComputeData {
    symbol:String,
    var_a:f64,
    var_b:f64
}

fn main() {
    println!("{}",compute(
            obtain_var().symbol,
            obtain_var().var_a,
            obtain_var().var_b
        )
    );
}

fn obtain_var() -> ComputeData {
    let symbol:String = env::args().nth(1).expect("入力が不完全です");
    let var_a:String = env::args().nth(2).expect("入力が不完全です");
    let var_b:String = env::args().nth(3).expect("入力が不完全です");

    let number_var:[f64; 2] = [change_type(var_a), change_type(var_b)];

    let data = ComputeData {
        symbol:String::from(symbol),
        var_a:number_var[0],
        var_b:number_var[1]
    };

    data
}

fn change_type(var:String) -> f64 {
    let var:f64 = match var.trim().parse() {
        Ok(num) => num,
        Err(_) => {
            println!("エラー：無効な入力です");
            return 0.0;
        }
    };

    var
}

fn compute(symbol:String, var_a:f64, var_b:f64) -> f64 {
    let symbol:&str = &symbol.to_string()[..];
    match symbol {
        "+" => var_a + var_b,
        "-" => var_a - var_b,
        "*" => var_a * var_b,
        "/" => var_a / var_b,
        _ => {
            println!("無効な計算記号");
            0.0
        }
    }
}

これは、私が Rust を学んでから作成した最初の例です（）