Rustを始めてみた

### この記事はRustを触り始めて２日目の初心者が書いています。こう書いた方がわかりやすい、ここが間違っているなどご指摘あればお願いします。

## Rustはコンパイル言語
Rustはコンパイルを行ってから実行する
~~~
# コンパイル
$ rustc hello.rs

# 実行 これはhello.rsというファイルの実行
$ ./hello
hello, world!
~~~
# 画面出力にチャレンジ

>Rustでの画面出力
$ println!("ここに出力内容を書き込む")

ここでの「！」は、普通の関数ではなく、<b>マクロとして定義されてる</b>という意味。
⇒マクロを使うのは、Rustの静的型付き言語という特性と所有権システムが関係している。
⇒マクロを利用することでデータ型を手軽に画面出力できる。
⇒この画面出力をマクロなしでやろうとすると、膨大なプログラムを書かないといけない。
<b>マクロを使って画面出力を行うことで、少ないコードで記述することが可能になる。</b>

## 数字を埋め込んだ画面出力
println!では、第一引数に文字列、第二引数に値を指定して出力を行う。
⇒代入したい部分に{}を入れる。

let 変数名 = 値; # 値を変数に束縛する
println!("…文字列…{}…, 代入したい値"）; # 値を書式に入れ込み画面出力

~~~Rust:exam.rs
fn main() {
    let ken_age = 20;
    println!("ケンの年齢は{}歳です", ken_age);
}

>>>ケンの年齢は20歳です
~~~

# 四則演算にチャレンジ
 ~~~Rust:exam2.rs
fn main(){
    let pen = 100;
    let eraser = 50;
    let count = 3;
    println!("ペンと消しゴムを1つずつ買った合計は{}円", pen + eraser);
    println!("ペンを3本買った合計は{}円", pen * count);
}

>>>
ペンと消しゴムを1つずつ買った合計は150円
ペンを3本買った合計は300円
~~~
⇒上記のコードは整数の計算をしている。
⇒150.0のように、すると実数型となる。
⇒Rustは、型に厳しい言語なので、整数と実数を明確に区別する必要がある。


## Rustの基本文法について覚え書き
* Rustはmain関数から実行される
　⇒Rustはmain関数から実行され、関数を定義するときは「fn」を使う。
~~~Rust
// ここから実行
fn main() {
    ptintln!("hello World!")
}
~~~
* コメントが「//」から始まる
~~~Rust
// 1行コメント

/*
複数行でも
コメントが
書ける
*/
~~~

* 繰り返しfor文
~~~Rust
/*
for 変数 in 開始..終了値+1 {
    繰り返す処理文
}
*/

// 10から100まで出力する処理
fn main() {
    for i in 10..101 {
        println!("{}", i)
    }
}
~~~

* 条件分岐if文
~~~Rust
/*
if 条件１ {
    条件１がTrueのときの処理
}
else if 条件２ {
    条件２がだったときの処理
else {
    すべての条件文がFalseだったときの処理
}
*/


fn main() {
    let count = 100;
    if count % 3 == 0 {
        println!("３で割り切れる");
    } else if count % 2 == 0 {
        println!("２で割り切れる"); 
    } else {
        println!("３でも２でも割り切れない")
    }
}
~~~

* 文末には「;」を付け、いらない丸括弧をつけると警告が出る
~~~Rust:exam3.rs
fn main() {
    let a = "hello";
    if (a == "hello") {
        println!("こんにちわ")
    }
}

$ rustc exam3.rs
>>>
warning: unnecessary parentheses around `if` condition
--> hello.rs:3:8
 |
3 |     if (a == "hello") {
 |        ^            ^
 |
 = note: `#[warn(unused_parens)]` on by default
help: remove these parentheses
 |
3 -     if (a == "hello") {
3 +     if a == "hello" {
 |

warning: 1 warning emitted

// 警告は出るが実行はできる。つけない方がいいかも
$ ./exam3
>>>こんにちわ
~~~

## Rustの変数定義について
Rustでは、変数を「let 変数名 = 値; 」というように宣言する。変数の値は、変更ができないイミューダブルな変数となる。このように定義した後、コンパイルを行うとエラーが発生してしまう。
⇒不用意に変数の値を書き換えてしまうとバグやエラーの原因にもつながってしまう。
⇒このような仕様にすることで、意図しない変更を防止できるので、保守性向上にもつながる。

書き換え可能な変数を定義するには、
~~~
let mut 変数名 = 値;
~~~
というように定義する。


⇒mutは、「mutable」の意。
~~~Rust
fn main() {
    let x = 10;
    x = x + 1;
    println!("{}", x)
}

$ rustc exam.py

>>>
2 |     let x = 10;
  |         -
  |         |
  |         first assignment to `x`
  |         help: consider making this binding mutable: `mut x`
3 |     x = x + 1;
  |     ^^^^^^^^^ cannot assign twice to immutable variable

error: aborting due to previous error

For more information about this error, try `rustc --explain E0384`.
~~~

## Rustの変数の型について
Rustは静的型付け言語である。⇒したがって、変数の型を指定しないといけない。

これまでは、変数の型宣言を行っていないのはなぜか？
⇒それは、Rustには、<b>型推論</b>という機能を持っているからである。

しかし、関数を定義したり、新しいデータ型を使う場合には、型を指定しないといけない
⇒Rustで型推論が有効になるのは、main関数の内側だけだからである。
⇒Rustでは、大きく分けて「符号あり整数」「符号なし整数」「浮動小数点数」の3つの数値型が存在する。

Rustで変数の型を指定したいときは
~~~
let 変数名: データ型 = 値
~~~
というようにしてをする。
参照
[Rustの数値型をマスターしたい（Part1）](https://qiita.com/LynxLevin/items/6cf47f5f68abe573f135)

利用可能な数値範囲を出力することができる。
⇒最大値を「型::MAX」、最小値を「型::MIN」という風に表せる。
~~~Rust
fn main() {
    println!("符号あり整数");
    println!("i8={}から{}", i8::MIN, i8::MAX);
    println!("i16={}から{}", i16::MIN, i16::MAX);
    println!("i32={}から{}", i32::MIN, i32::MAX);
    println!("i64={}から{}", i64::MIN, i64::MAX);
    
    println!("符号なし整数");
    println!("u8={}から{}", u8::MIN, u8::MAX);
    println!("u16{}から{}", u16::MIN, u16::MAX);
    println!("u32={}から{}", u32::MIN, u32::MAX);
    println!("u64={}から{}", u64::MIN, u64::MAX);

    println!("浮動小数点");
    println!("isize={}から{}", isize::MIN, isize::MAX);
    println!("usize={}から{}", usize::MIN, usize::MAX);
    println!("usize=u{}", usize::BITS);
}

>>>
符号あり整数
i8=-128から127
i16=-32768から32767
i32=-2147483648から2147483647
i64=-9223372036854775808から9223372036854775807
符号なし整数
u8=0から255
u160から65535
u32=0から4294967295
u64=0から18446744073709551615
浮動小数点
isize=-9223372036854775808から9223372036854775807
usize=0から18446744073709551615
usize=u64

~~~

# Rustは文字と文字列を区別する？
Rustでは「文字」と「文字列」を区別する。
⇒'X' とすると<b>文字</b>となり、"X"とすると<b>文字列</b>となる。
つまり、シングルクォーテーションは、文字、ダブルクォーテーションは文字列に使う。

また、Rustでは、「as」を用いて強制的な型変換を行うことが可能である。
~~~
// asで強制型変換
let 変数名 = 変数 as 型;
~~~

## 関数の定義について
~~~
fn 関数名（引数宣言）-> 戻り値 {
       関数の内容を記述
}
~~~
関数を宣言するときは、引数や戻り値のデータ型を明記しなくてはならない。

~~~Rust:exam.py
fn add(x: i64, y: i64) -> i64 {
    x + y
}

fn main() {
    let a_b = add(15, 30);
    println!("15+30={}", a_b)
}
~~~
Rustでは、関数の値を返す方法が2つあります。
⇒値
⇒return 値;

上記のコード（add関数）の例では、「値」のみを記述して関数から値を返している。
これをreturn 値;のようにも記述できる。
ここでの違いは、「;」セミコロンの有無に注目。returnを使うとreturn文となるので、「;」が必要になる。

## クロージャーを使ってみる
Rustの「クロージャ」とは、Pythonでいう「ラムダ関数のこと」である。
~~~
let 名前 = |引数| 定義;
~~~

例で、クロージャを記述してみる。
~~~Rust
fn main() {
    // クロージャ
    let x = |a| a+100;
    println!("{}", x(10));
}

>>>110
~~~
## Rustで配列を用意する
~~~
// 配列要素数の配列を初期値で初期化する
let mut 配列名 = [初期値; 配列要素数];

// 配列に値を代入
配列名[要素番号] = 値;

// 要素の取得
let 変数 = 配列名[要素番号];
~~~

~~~Rust
fn main() {
   let mut a = [0; 10];
   a[0] = 999;
   let x = a[0];
   println!("{}", x)
}

>>>999
~~~

## 参考図書
手を動かして考えればよく分かる　高効率言語　Rustの書き方