[Rust]TypeScriptと比較してRustの文法をおさらいする②

if文

TypeScriptの場合

TypeScriptではifを使って条件分岐を実現します。複数条件を扱う場合はelse ifやelseを組み合わせます。

条件に従って値を導きたいときは三項演算子を使います。

const value = 10;
if (value > 10) {
  console.log("Greater than 10");
} else if (value === 10) {
  console.log("Equal to 10");
} else {
  console.log("Less than 10");
}

let result = value > 10 ? "Greater than 10" : "10 or less";

Rustの場合

Rustでもifを使いますが、式として値を返すことができます。

let value = 10;
if value > 10 {
    println!("Greater than 10");
} else if value == 10 {
    println!("Equal to 10");
} else {
    println!("Less than 10");
}

// 式として使用
let result = if value > 10 {
    "Greater than 10"
} else {
    "10 or less"
};
println!("{}", result);

while, for文

TypeScriptの場合

TypeScriptではwhileやforを使ってループ処理を記述します。

// whileループ
let count = 0;
while (count < 5) {
  console.log(count);
  count++;
}

// forループ
for (let i = 0; i < 5; i++) {
  console.log(i);
}

Rustの場合

Rustでもwhileやforを使えます。特にforはイテレータを利用した表現が特徴的です。

// whileループ
let mut count = 0;
while count < 5 {
    println!("{}", count);
    count += 1;
}

// forループ
for i in 0..5 { // 0から4までの範囲
    println!("{}", i);
}

オブジェクト指向プログラミング

TypeScriptの場合

TypeScriptではclassを使ってクラスを定義し、プロパティやメソッドを記述します。

class User {
  id: number;
  name: string;

  constructor(id: number, name: string) {
    this.id = id;
    this.name = name;
  }

  greet(): string {
    return `Hello, ${this.name}!`;
  }
}

const user = new User(1, "Alice");
console.log(user.greet());

Rustの場合

Rustではstructとimplブロックを組み合わせて、オブジェクト指向的なプログラミングを実現します。

struct User {
    id: u32,
    name: String,
}

impl User {
    fn new(id: u32, name: &str) -> User {
        User {
            id,
            name: String::from(name),
        }
    }

    fn greet(&self) -> String {
        format!("Hello, {}!", self.name)
    }
}

let user = User::new(1, "Alice");
println!("{}", user.greet());

Rustのimplは非常に強力で、構造体だけでなく、列挙型にも実装でき、トレイトと組み合わせることができます。

エラーハンドリング

TypeScriptの場合

TypeScriptではtry-catch構文を使ってエラーハンドリングを行います。

function divide(a: number, b: number): number {
  if (b === 0) {
    throw new Error("Division by zero");
  }
  return a / b;
}

try {
  console.log(divide(10, 2)); // 5
  console.log(divide(10, 0)); // Error
} catch (error) {
  console.error(error.message);
}

Rustの場合

RustではResult型を使用してエラーを表現し、安全に処理します。

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err(String::from("Division by zero"))
    } else {
        Ok(a / b)
    }
}

fn main() {
    match divide(10.0, 2.0) {
        Ok(result) => println!("Result: {}", result),
        Err(err) => println!("Error: {}", err),
    }

    match divide(10.0, 0.0) {
        Ok(result) => println!("Result: {}", result),
        Err(err) => println!("Error: {}", err),
    }
}