Shannon  Rippin

Shannon Rippin

1637914560

Getter & Setter & Inheritance in JavaScript

In part 4 of ES6 JavaScript, we will learn Class in JavaScript | Getter & Setter in JavaScript | Inheritance in JS

Explained 
* Why Class  ?
* How to Create Class ?
* Getter & Setters of Class
* Inheritance

Timeline
-------------------------------------
00:00 Introduction
00:05 Why Class ?
00:30 Create Function Constructor
01:20 Create Class ES6 Way
02:40 Adding Methods or functions
03:55 Getters & Setters
07:03 Inheritance
10:04 Super keyword in class


#javascript  #Beginners  

 Getter & Setter & Inheritance in JavaScript
Shannon  Rippin

Shannon Rippin

1637870400

Learn React useState in 12 Minutes

Learn useState in 12 Minutes - React Hooks Explained | ReactJS 2021
Thanks for watching 🙏

🔥🔥 Concepts Covered:

- What are hooks in React ?
- How to convert class state to function state with useState
- How to use the useState hook
- Best way to define initiate state in useState

Timeline :
Scenario 1 
-------------------------------------------------------
00:00 introduction to React Hooks
00: 23 What are react hooks ?
00:48  useState
02:12 Hide or Show a section in React
02:47 Applying Css class conditionally

Scenario 2
-------------------------------------------------------
04:22 How useState functions  execute
04:42 Do & Don't
05:15 Best way to update state of useState
08:00 use data object as current State in useState
11:06 Best way to set initial state for useState

Thanks for watching 🙏

#reactjs   #usestate  #Beginners

Learn React useState in 12 Minutes
Jocelyn  Rempel

Jocelyn Rempel

1637697480

Getting started with python programming - Added Subtitles

In this tutorial we will start dealing with python programming for beginners you may follow them to learn the most easiest programming language.

Software installations python, pycharm required for python programming is covered, detailed installation procedures. Subtitles are provided in almost all major languages available world wide.

#python  #Beginners 

Getting started with python programming - Added Subtitles

CSS: Flexbox Tutorial in 20 Minutes | Flexbox for beginners

CSS FlexBox Tutorial | Flexbox for Beginners

Flexbox is a one-dimensional layout method for arranging items in rows or columns.
Items flex (expand) to fill additional space or shrink to fit into smaller spaces.

🔥🔥🔥 Happy Learning 🔥🔥🔥
Timeline :
00:48 4 Main Concepts you must know
01:57 Creating Flex Container

Flex Container Properties

03:31 Flex-Direction-Row
05:11 Justify-Content
06:31 Align-Items
08:55 Flex-Direction-Column
10:45 Flex-Wrap
19:25 Align Content Flex Item Properties

11:39 Flex Item Properties Starts

11:44 Align-Self
12:38 Order Property
14:23 Flex-Grow
16:10 Flex-Basis
16:48 Flex-Shrink
18:25 Flex Shorthand Property

#css #flexbox #javascript #webdesign #responsive #Beginners #tutorial 

https://youtu.be/dVGyTeJj1dU

CSS: Flexbox Tutorial in 20 Minutes | Flexbox for beginners

3 CSS Tricks You Must Know 2021

Web/Fullstack development Tutorial:
In this tutorial, we will learn 3 CSS Tricks You Must Know 2021


#css  #csstricks  #Beginners 

Timeline:
------------------------------------------------------
00:00 Introduction to video
00:10 Blend Mode
01:33 Clip Path
03:47 Google Fonts

3 CSS Tricks You Must Know 2021

Rustのエラーを処理する

エラー処理は、障害の可能性を予測して処理するプロセスです。

たとえば、プログラムがファイルの読み取りに失敗した後、その不正な入力を継続して使用すると、明らかに問題のあるエラーが発生します。これらのエラーに気づき、明示的に管理する機能により、プログラムをさまざまな追加の落とし穴から救うことができます。

学習目標

このモジュールでは、次の方法を学習します。

  • panic!回復不能なエラーを処理するために使用します。
  • Option値がオプションである場合、または値の欠如がエラー状態ではない場合は、列挙型を使用します。
  • Result問題が発生する可能性があり、発信者が問題に対処しなければならない可能性がある場合は、列挙型を使用してください。

前提条件

  • Rust開発環境
  • Cargoを使用したRustコードの作成、編集、および実行に関する知識

パニックによる致命的なエラーについて学びましょう!


パニックは、Rustで最も単純なエラー処理メカニズムです。

panic!マクロを使用して、現在のスレッドをパニックにすることができます。エラーメッセージを出力し、リソースを解放してから、プログラムを終了します。

この簡単な例は、panic!マクロを呼び出す方法を示しています。

fn main() {
    panic!("Farewell!");
}

このプログラムはステータスコード101で終了し、次のメッセージを出力します。

thread 'main' panicked at 'Farewell!', src/main.rs:2:5

前のパニックメッセージの最後の部分は、パニックの場所を示しています。これは、src /main.rsファイルの2行目の5番目の文字で発生しました。

一般的panic!に、プログラムが回復不能な状態に達したときに使用する必要があります。つまり、エラーから回復する方法がまったくない場合に使用します。

次のコードに示すように、ゼロ除算や、配列、ベクトル、またはハッシュマップに存在しないインデックスへのアクセスの試みなどの一部の操作でRustはパニックになります。

let v = vec![0, 1, 2, 3];
println!("{}", v[6]); // this will cause a panic!

次の単元では、プログラムをパニックに陥らせることなく、このようなエラーを処理する方法を学びます。

オプションタイプを使用して欠席に対処する

Rust標準ライブラリは、Option<T>値がない可能性がある場合に使用される列挙型を提供します。Option<T>Rustコードで広く使用されています。これは、存在する可能性のある値または空の可能性がある値を操作する場合に役立ちます。

他の多くの言語では、これはnullまたはを使用してモデル化されますnilが、Rustはnull他の言語と相互運用するコードの外部を使用しません。これは、Rustが値がオプションである場合について明示的であることを意味します。多くの言語でいる間、かかる機能Stringかもしれないが、実際に取るのいずれかStringまたはnull同じ機能のみを実際取ることができることを、錆で、String秒。Rustでオプションの文字列をモデル化する場合は、明示的に次のOptionタイプでラップする必要がありますOption<String>。

Option<T> 次の2つのバリアントのいずれかとして現れます。

enum Option<T> {
    None,     // The value doesn't exist
    Some(T),  // The value exists
}

列挙型宣言の<T>一部は、Option<T>型Tが汎用でありSome、Option列挙型のバリアントに関連付けられることを示しています。

前のセクションで説明したようにNone、Someはタイプではなく、Option<T>タイプのバリアントです。これは、とりわけ、関数が引数として、SomeまたはNone引数として取ることができず、のみであることを意味しますOption<T>。

前の単元で、ベクトルの存在しないインデックスにアクセスしようとするとプログラムがにアクセスするpanicことを説明しましVec::getたが、Optionパニックの代わりに型を返すメソッドを使用することでそれを回避できます。指定されたインデックスに値が存在する場合、その値はOption::Some(value)バリアントにラップされます。インデックスが範囲外の場合、Option::None代わりに値を返します。
 

やるだけやってみよう。以下のコードは、ローカルまたはRustプレイグラウンドで実行できます。

let fruits = vec!["banana", "apple", "coconut", "orange", "strawberry"];

// pick the first item:
let first = fruits.get(0);
println!("{:?}", first);

// pick the third item:
let third = fruits.get(2);
println!("{:?}", third);

// pick the 99th item, which is non-existent:
let non_existent = fruits.get(99);
println!("{:?}", non_existent);

出力は次のとおりです。

Some("banana")
Some("coconut")
None

印刷されたメッセージは、fruits配列内の既存のインデックスにアクセスしようとした最初の2回の試行でとが発生したことを示していますが、99番目の要素をフェッチしようとするSome("banana")とSome("coconut")、Noneパニックになる代わりに値(データに関連付けられていない)が返されました。

実際には、取得する列挙型バリアントに応じて、プログラムの動作を決定する必要があります。しかし、Some(data)バリアント内のデータにアクセスするにはどうすればよいでしょうか。

パターンマッチング

Rustには、と呼ばれる強力な演算子がありmatchます。パターンを提供することにより、プログラムのフローを制御するために使用できます。ときにmatch一致するパターンを見つけ、それはあなたがそのパターンで供給することにコードを実行します。

let fruits = vec!["banana", "apple", "coconut", "orange", "strawberry"];
for &index in [0, 2, 99].iter() {
    match fruits.get(index) {
        Some(fruit_name) => println!("It's a delicious {}!", fruit_name),
        None => println!("There is no fruit! :("),
    }
}

この例をRustプレイグラウンドで実行してみることができます。

出力は次のとおりです。

It's a delicious banana!
It's a delicious coconut!
There is no fruit! :(

前のコードでは、前の例(0、2、および99)と同じインデックスを反復処理し、それぞれを使用fruitsして、fruits.get(index)式を使用してベクトルから値を取得します。

のでfruits、ベクターに含まれる&str要素を、私たちは、この式の結果は型であることを知っていますOption<&str>。次に、値に対して一致式を使用し、Optionそのバリアントごとに一連のアクションを定義します。Rustは、これらのブランチを一致アームと呼び、各アームは、一致した値に対して1つの可能な結果を処理できます。

最初のアームは、新しい変数、を導入しますfruit_name。この変数は、値内の任意の値と一致しSomeます。のスコープは一致式にfruit_name限定されているため、でfruit_name導入する前に宣言することは意味がありませんmatch。

バリアント内の値に応じて、一致式をさらに改良して、異なる動作をすることができますSome。たとえば、次のコマンドを実行することで、ココナッツが素晴らしいという事実を強調できます。

let fruits = vec!["banana", "apple", "coconut", "orange", "strawberry"];
for &index in [0, 2, 99].iter() {
    match fruits.get(index) {
        Some(&"coconut") => println!("Coconuts are awesome!!!"),
        Some(fruit_name) => println!("It's a delicious {}!", fruit_name),
        None => println!("There is no fruit! :("),
    }
}

ノート

一致する最初のパターンはSome(&"coconut")(&文字列リテラルの前に注意してください)です。これは、文字列スライスへの参照のまたはオプションをfruits.get(index)返すためOption<&&str>です。&パターンから削除するということは、Option<&str>(文字列スライスへのオプションの参照ではなく、オプションの文字列スライス)と照合しようとしていることを意味します。参照については説明していませんので、現時点では完全には意味がない可能性があります。今のところ&、タイプが正しく並んでいることを確認していることを覚えておいてください。

この例をRustプレイグラウンドで実行してみることができます。

出力は次のとおりです。

It's a delicious banana!
Coconuts are awesome!!!
There is no fruit! :(

文字列値が"coconut"、の場合、最初のアームが照合され、実行のフローを決定するために使用されることに注意してください。

一致式を使用するときは常に、次のルールに注意してください。

  • match腕は上から下に評価されます。特定のケースは、一般的なケースよりも早く定義する必要があります。そうしないと、一致して評価されることはありません。
  • matchアームは、入力タイプが持つ可能性のあるすべての可能な値をカバーする必要があります。網羅的でないパターンリストと照合しようとすると、コンパイラエラーが発生します。

場合のlet表現

Rustは、値が単一のパターンに準拠しているかどうかをテストするための便利な方法を提供します。

次の例では、への入力matchはOption<u8>値です。matchその入力値がある場合式はコードのみを実行する必要があります7。

let a_number: Option<u8> = Some(7);
match a_number {
    Some(7) => println!("That's my lucky number!"),
    _ => {},
}

この場合、NoneバリアントとSome<u8>一致しないすべての値を無視しますSome(7)。ワイルドカードパターンは、このタイプの状況に役立ちます。あなたは追加することができ_、他の全てのパターンが一致した後(アンダースコア)のワイルドカードパターンを何かをし、マッチ腕を排出するためのコンパイラの需要を満たすために使われています。

このコードを要約するには、iflet式を使用できます。

let a_number: Option<u8> = Some(7);
if let Some(7) = a_number {
    println!("That's my lucky number!");
}

場合のlet演算子は式のパターンを比較します。式がパターンに一致する場合、ifブロックが実行されます。if let式の良いところは、一致する単一のパターンに関心がある場合、一致式の定型コードをすべて必要としないことです。

使用unwrapしてexpect

メソッドOptionを使用して、型の内部値に直接アクセスすることを試みることができますunwrap。ただし、バリアントがNone。の場合、このメソッドはパニックになるので注意してください。

例えば:

let gift = Some("candy");
assert_eq!(gift.unwrap(), "candy");

let empty_gift: Option<&str> = None;
assert_eq!(empty_gift.unwrap(), "candy"); // This will panic!

この場合、コードは次の出力でパニックになります。

    thread 'main' panicked at 'called `Option::unwrap()` on a `None` value', src/main.rs:6:27

このexpectメソッドはと同じようunwrapに機能しますが、2番目の引数によって提供されるカスタムパニックメッセージを提供します。

let a = Some("value");
assert_eq!(a.expect("fruits are healthy"), "value");

let b: Option<&str> = None;
b.expect("fruits are healthy"); // panics with `fruits are healthy`

出力は次のとおりです。

    thread 'main' panicked at 'fruits are healthy', src/main.rs:6:7

これらの関数はパニックになる可能性があるため、使用することはお勧めしません。代わりに、次のいずれかのアプローチを検討してください。

  • パターンマッチングを使用して、Noneケースを明示的に処理します。
  • のような同様のパニックにならないメソッドを呼び出しunwrap_orます。これは、バリアントがの場合はデフォルト値を返し、バリアントがのNone場合は内部値を返しますSome(value)。
assert_eq!(Some("dog").unwrap_or("cat"), "dog");
assert_eq!(None.unwrap_or("cat"), "cat");

演習-不在に対処するためにオプションタイプを使用する


この演習では、Person構造体を受け取り、Stringそのフルネームを含むを返す関数の実装を終了します。

ミドルネームを持っていない人もいますが、持っている場合は、戻り値に含める必要があることに注意してください。

build_full_name関数のみを編集する必要があります。名と姓を処理する部分はすでに実装されていることに注意してください。

struct Person {
    first: String,
    middle: Option<String>,
    last: String,
}

fn build_full_name(person: &Person) -> String {
    let mut full_name = String::new();
    full_name.push_str(&person.first);
    full_name.push_str(" ");

    // TODO: Implement the part of this function that handles the person's middle name.

    full_name.push_str(&person.last);
    full_name
}

fn main() {
    let john = Person {
        first: String::from("James"),
        middle: Some(String::from("Oliver")),
        last: String::from("Smith"),
    };
    assert_eq!(build_full_name(&john), "James Oliver Smith");

    let alice = Person {
        first: String::from("Alice"),
        middle: None,
        last: String::from("Stevens"),
    };
    assert_eq!(build_full_name(&alice), "Alice Stevens");

    let bob = Person {
        first: String::from("Robert"),
        middle: Some(String::from("Murdock")),
        last: String::from("Jones"),
    };
    assert_eq!(build_full_name(&bob), "Robert Murdock Jones");
}

上記のコードを実行し、すべてのassert_eq!式がパニックにならずに合格することを確認します。Rustプレイグラウンドでコードを編集することもできます。

結果タイプを使用してエラーを処理します

Rustは、Result<T, E>エラーを返したり伝播したりするための列挙型を提供します。慣例により、Ok(T)バリアントは成功を表し、値を含み、バリアントErr(E)はエラーを表し、エラー値を含みます。

Result<T, E>列挙型は次のように定義されています。

enum Result<T, E> {
    Ok(T):  // A value T was obtained.
    Err(E): // An error of type E was encountered instead.
}

値Optionがない可能性を説明するタイプとは対照的に、タイプResultは障害が発生する可能性がある場合に最適です。

このResultタイプには、次のいずれかを実行するunwrapandexpectメソッドもあります。

  • Okこの場合、バリアント内の値を返します。
  • バリアントがErr。の場合、プログラムをパニックにします。

Result実際の動作を見てみましょう。次のサンプルコードには、次のsafe_divisionいずれかを返す関数の実装があります。

  • 成功した除算の結果を運ぶバリアントを持つResult値Ok。
  • Err構造体担持バリアントDivisionByZeroError失敗分割信号を送ります。
#[derive(Debug)]
struct DivisionByZeroError;

fn safe_division(dividend: f64, divisor: f64) -> Result<f64, DivisionByZeroError> {
    if divisor == 0.0 {
        Err(DivisionByZeroError)
    } else {
        Ok(dividend / divisor)
    }
}

fn main() {
    println!("{:?}", safe_division(9.0, 3.0));
    println!("{:?}", safe_division(4.0, 0.0));
    println!("{:?}", safe_division(0.0, 2.0));
}

このプログラムを確認するには、Rustプレイグラウンドにアクセスしてください。

出力は次のとおりです。

Ok(3.0)
Err(DivisionByZeroError)
Ok(0.0)

構造体の#[derive(Debug)]前の部分DivisionByZeroErrorは、デバッグ目的で型を印刷可能にするようにRustコンパイラーに指示するマクロです。この概念については、後の特性モジュールで詳しく説明します。
演習-結果タイプを使用してエラーを処理します

この演習では、コンピューターからファイルを読み取るプログラムにエラー処理を追加します。サンプルプログラムでは、read_file_contents関数はPathBuf単一の入力として構造体を受け取り、を返しますResult<String, io::Error>。この関数は次のタスクを実行します。

  1. 変更可能な空のString変数を作成します。
  2. 指定されたパスにあるファイルにアクセスします。
  3. メソッドを使用して、ファイルの内容をString変数に読み込みますread_to_string。
  4. 変更されたString変数を返します。

コードの詳細は次のとおりです。

  • プログラムはいくつかの構造体と特性を使用します。コードの最初の3行は、これらのデータ型をスコープに入れます。
  • 一部のmatchアームは、file_handleやのような変数を導入しますio_error。それらのスコープはmatch式に制限されているため、前のコードでは宣言されていませんmatch。
  • このopenメソッドはResult<File, Error>列挙型を返します。エラーが発生しない場合は、Okバリアントでラップされたファイルハンドルを返します。
  • このread_to_stringメソッドは、ファイルの内容をstring戻り値ではなく、渡されたパラメーターに追加します。
  • プログラムは、match式を使用して変数に値を割り当てます。その代入ステートメント内で、matcharmsを使用して関数から早期に戻ることもできます。

サンプルプログラムを開く

この演習のサンプルコードで作業するには、次の2つのオプションがあります。

  • 次のコードをコピーして、ローカル開発環境で編集します。
  • この準備されたRustPlaygroundでコードを開きます。

ローカル開発環境で編集する

ローカルコンピューターでこのコードを実行するには、src /main.rsファイルにコードを記述します。ファイルはCargoプロジェクトのルートにある必要があります。新しいCargoプロジェクトを設定する方法に関する質問については、この学習パスの最初のモジュールを確認してください。

さび遊び場で働く

Rust Playgroundで演習を完了するには、独自のコードをsrc /main.rsという名前のファイルとして読み取ることができます。このファイルは独自の仮想パス上にあります。

use std::fs::File;
use std::io::{Error, Read};
use std::path::PathBuf;

fn read_file_contents(path: PathBuf) -> Result<String, Error> {
    let mut string = String::new();

    // Access a file at a specified path
    // ---------------------------------
    // TODO #1:
    // - Pass variable to `file` variable on success, or
    // - Return from function early if there's an error
    let mut file: File = match File::open(path) {
        Ok(file_handle) => todo!("Pass variable to `file` variable on success"),
        Err(io_error) => todo!("Return from function early if there's an error")
    };

    // Read file contents into `String` variable with `read_to_string`
    // ---------------------------------
    // Success path is already filled in
    // TODO #2: Return from function early if there's an error
    match file.read_to_string(&mut string) {
        Ok(_) => (),
        Err(io_error) => todo!("Return from function early if there's an error")
    };

    // TODO #3: Return `string` variable as expected by function signature
    todo!("Return `string` variable")
}

fn main() {
    if read_file_contents(PathBuf::from("src/main.rs")).is_ok() {
        println!("The program found the main file.");
    }
    if read_file_contents(PathBuf::from("non-existent-file.txt")).is_err() {
        println!("The program reported an error for the file that doesn't exist.");
    }
}

成功と失敗のシナリオを処理する

最初のタスクは、成功と失敗のシナリオを処理するためのコードを追加することです。

ノート

サンプルコードで、TODOコメントとtodo!マクロを探します。コメントは、完了するタスクを説明しています。このマクロは、終了または更新する必要のあるコードを示します。

次のコードを更新して、match式内の成功と失敗のシナリオを処理します。

    // Access a file at a specified path
    // ---------------------------------
    // TODO #1:
    // - Pass variable to `file` variable on success, or
    // - Return from function early if there's an error
    let mut file: File = match File::open(path) {
        Ok(file_handle) => todo!("Pass variable to `file` variable on success"),
        Err(io_error) => todo!("Return from function early if there's an error")
    };

タスクを完了したら、次のプログラミング目標に取り組みます。

  • Ok(value)ケースは、内側を提供する必要がありますvalue。
  • Err(error_value)値は早期から返却されなければならないread_file_contents機能。

エラーシナリオを処理する

次のタスクは、エラー処理を追加することです。Errケースをサポートするために、次のコードを更新してください。

    // Read file contents into `String` variable with `read_to_string`
    // ---------------------------------
    // Success path is already filled in
    // TODO #2: Return from function early if there's an error
    match file.read_to_string(&mut string) {
        Ok(_) => (),
        Err(io_error) => todo!("Return from function early if there's an error")
    };

このタスクに取り組むときは、次のプログラミング目標に取り組んでください。

  • Ok(value)ケースは、内側を提供する必要がありますvalue。
  • Err(error_value)値は早期から返却されなければならないread_file_contents機能。
     

文字列を返す

最後のタスクは、コードを修正しStringて、Okバリアント内の変更された変数を返すことです。実装は、戻り値が関数の期待される成功した出力であることを表現する必要があります。

fn read_file_contents(path: PathBuf) -> Result<String, Error> {
    ...
    // TODO #3: Return `string` variable as expected by function signature
    todo!("Return `string` variable")
}

プログラムをビルドする

タスクを完了したら、プログラムをビルドして実行します。次の出力が表示されます。

The program found the main file.
The program reported an error for the file that doesn't exist.

概要

このモジュールでは、次のことを学びました。

  • を使用して、回復不能なエラーが発生した場合にRustプログラムを停止する方法panic!。
  • 列挙型を使用して値が存在しない可能性を表す方法Option。
  • Result列挙型を使用して操作を表す方法。
  • パターンマッチングを使用して、特定のタイプのすべての可能な値に安全にアクセスする方法。

この学習パスの次のモジュールでは、Rustの最も斬新な側面の1つであるボローチェッカーと、コード内のさまざまな種類のバグを防ぐ方法について学習します。

 ãƒªãƒ³ã‚¯: https://docs.microsoft.com/en-us/learn/modules/rust-error-handling/

#rust #Beginners 

Rustのエラーを処理する

ループを使用して、Rustのデータを反復処理します

このモジュールでは、Rustでハッシュマップ複合データ型を操作する方法について説明します。ハッシュマップのようなコレクション内のデータを反復処理するループ式を実装する方法を学びます。演習として、要求された注文をループし、条件をテストし、さまざまなタイプのデータを処理することによって車を作成するRustプログラムを作成します。

さび遊び場

錆遊び場は錆コンパイラにブラウザインタフェースです。言語をローカルにインストールする前、またはコンパイラが利用できない場合は、Playgroundを使用してRustコードの記述を試すことができます。このコース全体を通して、サンプルコードと演習へのPlaygroundリンクを提供します。現時点でRustツールチェーンを使用できない場合でも、コードを操作できます。

Rust Playgroundで実行されるすべてのコードは、ローカルの開発環境でコンパイルして実行することもできます。コンピューターからRustコンパイラーと対話することを躊躇しないでください。Rust Playgroundの詳細については、What isRust?をご覧ください。モジュール。

学習目標

このモジュールでは、次のことを行います。

  • Rustのハッシュマップデータ型、およびキーと値にアクセスする方法を確認してください
  • ループ式を使用してRustプログラムのデータを反復処理する方法を探る
  • Rustプログラムを作成、コンパイル、実行して、ループを使用してハッシュマップデータを反復処理します

Rustのもう1つの一般的なコレクションの種類は、ハッシュマップです。このHashMap<K, V>型は、各キーKをその値にマッピングすることによってデータを格納しますV。ベクトル内のデータは整数インデックスを使用してアクセスされますが、ハッシュマップ内のデータはキーを使用してアクセスされます。

ハッシュマップタイプは、オブジェクト、ハッシュテーブル、辞書などのデータ項目の多くのプログラミング言語で使用されます。

ベクトルのように、ハッシュマップは拡張可能です。データはヒープに格納され、ハッシュマップアイテムへのアクセスは実行時にチェックされます。

ハッシュマップを定義する

次の例では、書評を追跡するためのハッシュマップを定義しています。ハッシュマップキーは本の名前であり、値は読者のレビューです。

use std::collections::HashMap;
let mut reviews: HashMap<String, String> = HashMap::new();

reviews.insert(String::from("Ancient Roman History"), String::from("Very accurate."));
reviews.insert(String::from("Cooking with Rhubarb"), String::from("Sweet recipes."));
reviews.insert(String::from("Programming in Rust"), String::from("Great examples."));

このコードをさらに詳しく調べてみましょう。最初の行に、新しいタイプの構文が表示されます。

use std::collections::HashMap;

このuseコマンドは、Rust標準ライブラリの一部HashMapからの定義をcollectionsプログラムのスコープに取り込みます。この構文は、他のプログラミング言語がインポートと呼ぶものと似ています。

HashMap::newメソッドを使用して空のハッシュマップを作成します。reviews必要に応じてキーと値を追加または削除できるように、変数を可変として宣言します。この例では、ハッシュマップのキーと値の両方がStringタイプを使用しています。

let mut reviews: HashMap<String, String> = HashMap::new();

キーと値のペアを追加します

このinsert(<key>, <value>)メソッドを使用して、ハッシュマップに要素を追加します。コードでは、構文は<hash_map_name>.insert()次のとおりです。

reviews.insert(String::from("Ancient Roman History"), String::from("Very accurate."));

キー値を取得する

ハッシュマップにデータを追加した後、get(<key>)メソッドを使用してキーの特定の値を取得できます。

// Look for a specific review
let book: &str = "Programming in Rust";
println!("\nReview for \'{}\': {:?}", book, reviews.get(book));

出力は次のとおりです。

Review for 'Programming in Rust': Some("Great examples.")

ノート

出力には、書評が単なる「すばらしい例」ではなく「Some( "すばらしい例。")」として表示されていることに注意してください。getメソッドはOption<&Value>型を返すため、Rustはメソッド呼び出しの結果を「Some()」表記でラップします。

キーと値のペアを削除します

この.remove()メソッドを使用して、ハッシュマップからエントリを削除できます。get無効なハッシュマップキーに対してメソッドを使用すると、getメソッドは「なし」を返します。

// Remove book review
let obsolete: &str = "Ancient Roman History";
println!("\n'{}\' removed.", obsolete);
reviews.remove(obsolete);

// Confirm book review removed
println!("\nReview for \'{}\': {:?}", obsolete, reviews.get(obsolete));

出力は次のとおりです。

'Ancient Roman History' removed.
Review for 'Ancient Roman History': None

このコードを試して、このRustPlaygroundでハッシュマップを操作できます。

演習:ハッシュマップを使用して注文を追跡する
この演習では、ハッシュマップを使用するように自動車工場のプログラムを変更します。

ハッシュマップキーと値のペアを使用して、車の注文に関する詳細を追跡し、出力を表示します。繰り返しになりますが、あなたの課題は、サンプルコードを完成させてコンパイルして実行することです。

この演習のサンプルコードで作業するには、次の2つのオプションがあります。

  • コードをコピーして、ローカル開発環境で編集します。
  • 準備されたRustPlaygroundでコードを開きます。

ノート

サンプルコードで、todo!マクロを探します。このマクロは、完了するか更新する必要があるコードを示します。

現在のプログラムをロードする

最初のステップは、既存のプログラムコードを取得することです。

  1. 編集のために既存のプログラムコードを開きます。コードは、データ型宣言、および定義のため含みcar_quality、car_factoryおよびmain機能を。

次のコードをコピーしてローカル開発環境で編集する
か、この準備されたRustPlaygroundでコードを開きます。

#[derive(PartialEq, Debug)]
struct Car { color: String, motor: Transmission, roof: bool, age: (Age, u32) }

#[derive(PartialEq, Debug)]
enum Transmission { Manual, SemiAuto, Automatic }

#[derive(PartialEq, Debug)]
enum Age { New, Used }

// Get the car quality by testing the value of the input argument
// - miles (u32)
// Return tuple with car age ("New" or "Used") and mileage
fn car_quality (miles: u32) -> (Age, u32) {

    // Check if car has accumulated miles
    // Return tuple early for Used car
    if miles > 0 {
        return (Age::Used, miles);
    }

    // Return tuple for New car, no need for "return" keyword or semicolon
    (Age::New, miles)
}

// Build "Car" using input arguments
fn car_factory(order: i32, miles: u32) -> Car {
    let colors = ["Blue", "Green", "Red", "Silver"];

    // Prevent panic: Check color index for colors array, reset as needed
    // Valid color = 1, 2, 3, or 4
    // If color > 4, reduce color to valid index
    let mut color = order as usize;
    if color > 4 {        
        // color = 5 --> index 1, 6 --> 2, 7 --> 3, 8 --> 4
        color = color - 4;
    }

    // Add variety to orders for motor type and roof type
    let mut motor = Transmission::Manual;
    let mut roof = true;
    if order % 3 == 0 {          // 3, 6, 9
        motor = Transmission::Automatic;
    } else if order % 2 == 0 {   // 2, 4, 8, 10
        motor = Transmission::SemiAuto;
        roof = false;
    }                            // 1, 5, 7, 11

    // Return requested "Car"
    Car {
        color: String::from(colors[(color-1) as usize]),
        motor: motor,
        roof: roof,
        age: car_quality(miles)
    }
}

fn main() {
    // Initialize counter variable
    let mut order = 1;
    // Declare a car as mutable "Car" struct
    let mut car: Car;

    // Order 6 cars, increment "order" for each request
    // Car order #1: Used, Hard top
    car = car_factory(order, 1000);
    println!("{}: {:?}, Hard top = {}, {:?}, {}, {} miles", order, car.age.0, car.roof, car.motor, car.color, car.age.1);

    // Car order #2: Used, Convertible
    order = order + 1;
    car = car_factory(order, 2000);
    println!("{}: {:?}, Hard top = {}, {:?}, {}, {} miles", order, car.age.0, car.roof, car.motor, car.color, car.age.1);    

    // Car order #3: New, Hard top
    order = order + 1;
    car = car_factory(order, 0);
    println!("{}: {:?}, Hard top = {}, {:?}, {}, {} miles", order, car.age.0, car.roof, car.motor, car.color, car.age.1);

    // Car order #4: New, Convertible
    order = order + 1;
    car = car_factory(order, 0);
    println!("{}: {:?}, Hard top = {}, {:?}, {}, {} miles", order, car.age.0, car.roof, car.motor, car.color, car.age.1);

    // Car order #5: Used, Hard top
    order = order + 1;
    car = car_factory(order, 3000);
    println!("{}: {:?}, Hard top = {}, {:?}, {}, {} miles", order, car.age.0, car.roof, car.motor, car.color, car.age.1);

    // Car order #6: Used, Hard top
    order = order + 1;
    car = car_factory(order, 4000);
    println!("{}: {:?}, Hard top = {}, {:?}, {}, {} miles", order, car.age.0, car.roof, car.motor, car.color, car.age.1);
}

2. プログラムをビルドします。次のセクションに進む前に、コードがコンパイルされて実行されることを確認してください。

次の出力が表示されます。

1: Used, Hard top = true, Manual, Blue, 1000 miles
2: Used, Hard top = false, SemiAuto, Green, 2000 miles
3: New, Hard top = true, Automatic, Red, 0 miles
4: New, Hard top = false, SemiAuto, Silver, 0 miles
5: Used, Hard top = true, Manual, Blue, 3000 miles
6: Used, Hard top = true, Automatic, Green, 4000 miles

注文の詳細を追跡するためのハッシュマップを追加する

現在のプログラムは、各車の注文を処理し、各注文が完了した後に要約を印刷します。car_factory関数を呼び出すたびにCar、注文の詳細を含む構造体が返され、注文が実行されます。結果はcar変数に格納されます。

お気づきかもしれませんが、このプログラムにはいくつかの重要な機能がありません。すべての注文を追跡しているわけではありません。car変数は、現在の注文の詳細のみを保持しています。関数carの結果で変数が更新されるたびcar_factoryに、前の順序の詳細が上書きされます。

ファイリングシステムのようにすべての注文を追跡するために、プログラムを更新する必要があります。この目的のために、<K、V>ペアでハッシュマップを定義します。ハッシュマップキーは、車の注文番号に対応します。ハッシュマップ値は、Car構造体で定義されているそれぞれの注文の詳細になります。

  1. ハッシュマップを定義するには、main関数の先頭、最初の中括弧の直後に次のコードを追加します{。
// Initialize a hash map for the car orders
    // - Key: Car order number, i32
    // - Value: Car order details, Car struct
    use std::collections::HashMap;
    let mut orders: HashMap<i32, Car> = HashMap;

2. ordersハッシュマップを作成するステートメントの構文の問題を修正します。

ヒント

ハッシュマップを最初から作成しているので、おそらくこのnew()メソッドを使用することをお勧めします。

3. プログラムをビルドします。次のセクションに進む前に、コードがコンパイルされていることを確認してください。コンパイラからの警告メッセージは無視してかまいません。

ハッシュマップに値を追加する

次のステップは、履行された各自動車注文をハッシュマップに追加することです。

このmain関数では、car_factory車の注文ごとに関数を呼び出します。注文が履行された後、println!マクロを呼び出して、car変数に格納されている注文の詳細を表示します。

// Car order #1: Used, Hard top
    car = car_factory(order, 1000);
    println!("{}: {}, Hard top = {}, {:?}, {}, {} miles", order, car.age.0, car.roof, car.motor, car.color, car.age.1);

    ...

    // Car order #6: Used, Hard top
    order = order + 1;
    car = car_factory(order, 4000);
    println!("{}: {}, Hard top = {}, {:?}, {}, {} miles", order, car.age.0, car.roof, car.motor, car.color, car.age.1);

新しいハッシュマップで機能するように、これらのコードステートメントを修正します。

  • car_factory関数の呼び出しは保持します。返された各Car構造体は、ハッシュマップの<K、V>ペアの一部として格納されます。
  • println!マクロの呼び出しを更新して、ハッシュマップに保存されている注文の詳細を表示します。
  1. main関数で、関数の呼び出しcar_factoryとそれに伴うprintln!マクロの呼び出しを見つけます。
// Car order #1: Used, Hard top
    car = car_factory(order, 1000);
    println!("{}: {}, Hard top = {}, {:?}, {}, {} miles", order, car.age.0, car.roof, car.motor, car.color, car.age.1);

    ...

    // Car order #6: Used, Hard top
    order = order + 1;
    car = car_factory(order, 4000);
    println!("{}: {}, Hard top = {}, {:?}, {}, {} miles", order, car.age.0, car.roof, car.motor, car.color, car.age.1);

2. すべての自動車注文のステートメントの完全なセットを次の改訂されたコードに置き換えます。

// Car order #1: Used, Hard top
    car = car_factory(order, 1000);
    orders(order, car);
    println!("Car order {}: {:?}", order, orders.get(&order));

    // Car order #2: Used, Convertible
    order = order + 1;
    car = car_factory(order, 2000);
    orders(order, car);
    println!("Car order {}: {:?}", order, orders.get(&order));

    // Car order #3: New, Hard top
    order = order + 1;
    car = car_factory(order, 0);
    orders(order, car);
    println!("Car order {}: {:?}", order, orders.get(&order));

    // Car order #4: New, Convertible
    order = order + 1;
    car = car_factory(order, 0);
    orders(order, car);
    println!("Car order {}: {:?}", order, orders.get(&order));

    // Car order #5: Used, Hard top
    order = order + 1;
    car = car_factory(order, 3000);
    orders(order, car);
    println!("Car order {}: {:?}", order, orders.get(&order));

    // Car order #6: Used, Hard top
    order = order + 1;
    car = car_factory(order, 4000);
    orders(order, car);
    println!("Car order {}: {:?}", order, orders.get(&order));

3. 今すぐプログラムをビルドしようとすると、コンパイルエラーが表示されます。<K、V>ペアをordersハッシュマップに追加するステートメントに構文上の問題があります。問題がありますか?先に進んで、ハッシュマップに順序を追加する各ステートメントの問題を修正してください。

ヒント

ordersハッシュマップに直接値を割り当てることはできません。挿入を行うにはメソッドを使用する必要があります。

プログラムを実行する

プログラムが正常にビルドされると、次の出力が表示されます。

Car order 1: Some(Car { color: "Blue", motor: Manual, roof: true, age: ("Used", 1000) })
Car order 2: Some(Car { color: "Green", motor: SemiAuto, roof: false, age: ("Used", 2000) })
Car order 3: Some(Car { color: "Red", motor: Automatic, roof: true, age: ("New", 0) })
Car order 4: Some(Car { color: "Silver", motor: SemiAuto, roof: false, age: ("New", 0) })
Car order 5: Some(Car { color: "Blue", motor: Manual, roof: true, age: ("Used", 3000) })
Car order 6: Some(Car { color: "Green", motor: Automatic, roof: true, age: ("Used", 4000) })

改訂されたコードの出力が異なることに注意してください。println!マクロディスプレイの内容Car各値を示すことによって、構造体と対応するフィールド名。

次の演習では、ループ式を使用してコードの冗長性を減らします。

for、while、およびloop式を使用します


多くの場合、プログラムには、その場で繰り返す必要のあるコードのブロックがあります。ループ式を使用して、繰り返しの実行方法をプログラムに指示できます。電話帳のすべてのエントリを印刷するには、ループ式を使用して、最初のエントリから最後のエントリまで印刷する方法をプログラムに指示できます。

Rustは、プログラムにコードのブロックを繰り返させるための3つのループ式を提供します。

  • loop:手動停止が発生しない限り、繰り返します。
  • while:条件が真のままで繰り返します。
  • for:コレクション内のすべての値に対して繰り返します。

この単元では、これらの各ループ式を見ていきます。

ループし続けるだけ

loop式は、無限ループを作成します。このキーワードを使用すると、式の本文でアクションを継続的に繰り返すことができます。ループを停止させるための直接アクションを実行するまで、アクションが繰り返されます。

次の例では、「We loopforever!」というテキストを出力します。そしてそれはそれ自体で止まりません。println!アクションは繰り返し続けます。

loop {
    println!("We loop forever!");
}

loop式を使用する場合、ループを停止する唯一の方法は、プログラマーとして直接介入する場合です。特定のコードを追加してループを停止したり、Ctrl + Cなどのキーボード命令を入力してプログラムの実行を停止したりできます。

loop式を停止する最も一般的な方法は、breakキーワードを使用してブレークポイントを設定することです。

loop {
    // Keep printing, printing, printing...
    println!("We loop forever!");
    // On the other hand, maybe we should stop!
    break;                            
}

プログラムがbreakキーワードを検出すると、loop式の本体でアクションの実行を停止し、次のコードステートメントに進みます。

breakキーワードは、特別な機能を明らかにするloop表現を。breakキーワードを使用すると、式本体でのアクションの繰り返しを停止することも、ブレークポイントで値を返すこともできます。

次の例はbreak、loop式でキーワードを使用して値も返す方法を示しています。

let mut counter = 1;
// stop_loop is set when loop stops
let stop_loop = loop {
    counter *= 2;
    if counter > 100 {
        // Stop loop, return counter value
        break counter;
    }
};
// Loop should break when counter = 128
println!("Break the loop at counter = {}.", stop_loop);

出力は次のとおりです。

Break the loop at counter = 128.

私たちのloop表現の本体は、これらの連続したアクションを実行します。

  1. stop_loop変数を宣言します。
  2. 変数値をloop式の結果にバインドするようにプログラムに指示します。
  3. ループを開始します。loop式の本体でアクションを実行します:
    ループ本体
    1. counter値を現在の値の2倍にインクリメントします。
    2. counter値を確認してください。
    3. もしcounter値が100以上です。

ループから抜け出し、counter値を返します。

4. もしcounter値が100以上ではありません。

ループ本体でアクションを繰り返します。

5. stop_loop値を式のcounter結果である値に設定しますloop。

loop式本体は、複数のブレークポイントを持つことができます。式に複数のブレークポイントがある場合、すべてのブレークポイントは同じタイプの値を返す必要があります。すべての値は、整数型、文字列型、ブール型などである必要があります。ブレークポイントが明示的に値を返さない場合、プログラムは式の結果を空のタプルとして解釈します()。

しばらくループする

whileループは、条件式を使用しています。条件式が真である限り、ループが繰り返されます。このキーワードを使用すると、条件式がfalseになるまで、式本体のアクションを実行できます。

whileループは、ブール条件式を評価することから始まります。条件式がと評価されるtrueと、本体のアクションが実行されます。アクションが完了すると、制御は条件式に戻ります。条件式がと評価されるfalseと、while式は停止します。

次の例では、「しばらくループします...」というテキストを出力します。ループを繰り返すたびに、「カウントが5未満である」という条件がテストされます。条件が真のままである間、式本体のアクションが実行されます。条件が真でなくなった後、whileループは停止し、プログラムは次のコードステートメントに進みます。

while counter < 5 {
    println!("We loop a while...");
    counter = counter + 1;
}

これらの値のループ

forループは、項目のコレクションを処理するためにイテレータを使用しています。ループは、コレクション内の各アイテムの式本体のアクションを繰り返します。このタイプのループの繰り返しは、反復と呼ばれます。すべての反復が完了すると、ループは停止します。

Rustでは、配列、ベクトル、ハッシュマップなど、任意のコレクションタイプを反復処理できます。Rustはイテレータを使用して、コレクション内の各アイテムを最初から最後まで移動します。

forループはイテレータとして一時変数を使用しています。変数はループ式の開始時に暗黙的に宣言され、現在の値は反復ごとに設定されます。

次のコードでは、コレクションはbig_birds配列であり、イテレーターの名前はbirdです。

let big_birds = ["ostrich", "peacock", "stork"];
for bird in big_birds

iter()メソッドを使用して、コレクション内のアイテムにアクセスします。for式は結果にイテレータの現在の値をバインドするiter()方法。式本体では、イテレータ値を操作できます。

let big_birds = ["ostrich", "peacock", "stork"];
for bird in big_birds.iter() {
    println!("The {} is a big bird.", bird);
}

出力は次のとおりです。

The ostrich is a big bird.
The peacock is a big bird.
The stork is a big bird.

イテレータを作成するもう1つの簡単な方法は、範囲表記を使用することですa..b。イテレータはa値から始まりb、1ステップずつ続きますが、値を使用しませんb。

for number in 0..5 {
    println!("{}", number * 2);
}

このコードは、0、1、2、3、および4の数値をnumber繰り返し処理します。ループの繰り返しごとに、値を変数にバインドします。

出力は次のとおりです。

0
2
4
6
8

このコードを実行して、このRustPlaygroundでループを探索できます。

演習:ループを使用してデータを反復処理する


この演習では、自動車工場のプログラムを変更して、ループを使用して自動車の注文を反復処理します。

main関数を更新して、注文の完全なセットを処理するためのループ式を追加します。ループ構造は、コードの冗長性を減らすのに役立ちます。コードを簡素化することで、注文量を簡単に増やすことができます。

このcar_factory関数では、範囲外の値での実行時のパニックを回避するために、別のループを追加します。

課題は、サンプルコードを完成させて、コンパイルして実行することです。

この演習のサンプルコードで作業するには、次の2つのオプションがあります。

  • コードをコピーして、ローカル開発環境で編集します。
  • 準備されたRustPlaygroundでコードを開きます。

ノート

サンプルコードで、todo!マクロを探します。このマクロは、完了するか更新する必要があるコードを示します。

プログラムをロードする

前回の演習でプログラムコードを閉じた場合は、この準備されたRustPlaygroundでコードを再度開くことができます。

必ずプログラムを再構築し、コンパイラエラーなしで実行されることを確認してください。

ループ式でアクションを繰り返す

より多くの注文をサポートするには、プログラムを更新する必要があります。現在のコード構造では、冗長ステートメントを使用して6つの注文をサポートしています。冗長性は扱いにくく、維持するのが困難です。

ループ式を使用してアクションを繰り返し、各注文を作成することで、構造を単純化できます。簡略化されたコードを使用すると、多数の注文をすばやく作成できます。

  1. ではmain機能、削除次の文を。このコードブロックは、order変数を定義および設定し、自動車の注文のcar_factory関数とprintln!マクロを呼び出し、各注文をordersハッシュマップに挿入します。
// Order 6 cars
    // - Increment "order" after each request
    // - Add each order <K, V> pair to "orders" hash map
    // - Call println! to show order details from the hash map

    // Initialize order variable
    let mut order = 1;

    // Car order #1: Used, Hard top
    car = car_factory(order, 1000);
    orders.insert(order, car);
    println!("Car order {}: {:?}", order, orders.get(&order));

    ...

    // Car order #6: Used, Hard top
    order = order + 1;
    car = car_factory(order, 4000);
    orders.insert(order, car);
    println!("Car order {}: {:?}", order, orders.get(&order));

2. 削除されたステートメントを次のコードブロックに置き換えます。

// Start with zero miles
    let mut miles = 0;

    todo!("Add a loop expression to fulfill orders for 6 cars, initialize `order` variable to 1") {

        // Call car_factory to fulfill order
        // Add order <K, V> pair to "orders" hash map
        // Call println! to show order details from the hash map        
        car = car_factory(order, miles);
        orders.insert(order, car);
        println!("Car order {}: {:?}", order, orders.get(&order));

        // Reset miles for order variety
        if miles == 2100 {
            miles = 0;
        } else {
            miles = miles + 700;
        }
    }

3. アクションを繰り返すループ式を追加して、6台の車の注文を作成します。order1に初期化された変数が必要です。

4. プログラムをビルドします。コードがエラーなしでコンパイルされることを確認してください。

次の例のような出力が表示されます。

Car order 1: Some(Car { color: "Blue", motor: Manual, roof: true, age: ("New", 0) })
Car order 2: Some(Car { color: "Green", motor: SemiAuto, roof: false, age: ("Used", 700) })
Car order 3: Some(Car { color: "Red", motor: Automatic, roof: true, age: ("Used", 1400) })
Car order 4: Some(Car { color: "Silver", motor: SemiAuto, roof: false, age: ("Used", 2100) })
Car order 5: Some(Car { color: "Blue", motor: Manual, roof: true, age: ("New", 0) })
Car order 6: Some(Car { color: "Green", motor: Automatic, roof: true, age: ("Used", 700) })

車の注文を11に増やす

 ãƒ—ログラムは現在、ループを使用して6台の車の注文を処理しています。6台以上注文するとどうなりますか?

  1. main関数のループ式を更新して、11台の車を注文します。
    todo!("Update the loop expression to create 11 cars");

2. プログラムを再構築します。実行時に、プログラムはパニックになります!

Compiling playground v0.0.1 (/playground)
    Finished dev [unoptimized + debuginfo] target(s) in 1.26s
    Running `target/debug/playground`
thread 'main' panicked at 'index out of bounds: the len is 4 but the index is 4', src/main.rs:34:29

この問題を解決する方法を見てみましょう。

ループ式で実行時のパニックを防ぐ

このcar_factory関数では、if / else式を使用colorして、colors配列のインデックスの値を確認します。

// Prevent panic: Check color index for colors array, reset as needed
    // Valid color = 1, 2, 3, or 4
    // If color > 4, reduce color to valid index
    let mut color = order as usize;
    if color > 4 {        
        // color = 5 --> index 1, 6 --> 2, 7 --> 3, 8 --> 4
        color = color - 4;
    }

colors配列には4つの要素を持ち、かつ有効なcolor場合は、インデックスの範囲は0〜3の条件式をチェックしているcolor私たちはをチェックしません(インデックスが4よりも大きい場合color、その後の関数で4に等しいインデックスへのときに我々のインデックスを車の色を割り当てる配列では、インデックス値から1を減算しますcolor - 1。color値4はcolors[3]、配列と同様に処理されます。)

現在のif / else式は、8台以下の車を注文するときの実行時のパニックを防ぐためにうまく機能します。しかし、11台の車を注文すると、プログラムは9番目の注文でパニックになります。より堅牢になるように式を調整する必要があります。この改善を行うために、別のループ式を使用します。

  1. ではcar_factory機能、ループ式であれば/他の条件文を交換してください。colorインデックス値が4より大きい場合に実行時のパニックを防ぐために、次の擬似コードステートメントを修正してください。
// Prevent panic: Check color index, reset as needed
    // If color = 1, 2, 3, or 4 - no change needed
    // If color > 4, reduce to color to a valid index
    let mut color = order as usize;
    todo!("Replace `if/else` condition with a loop to prevent run-time panic for color > 4");

ヒント

この場合、if / else条件からループ式への変更は実際には非常に簡単です。

2. プログラムをビルドします。コードがエラーなしでコンパイルされることを確認してください。

次の出力が表示されます。

Car order 1: Some(Car { color: "Blue", motor: Manual, roof: true, age: ("New", 0) })
Car order 2: Some(Car { color: "Green", motor: SemiAuto, roof: false, age: ("Used", 700) })
Car order 3: Some(Car { color: "Red", motor: Automatic, roof: true, age: ("Used", 1400) })
Car order 4: Some(Car { color: "Silver", motor: SemiAuto, roof: false, age: ("Used", 2100) })
Car order 5: Some(Car { color: "Blue", motor: Manual, roof: true, age: ("New", 0) })
Car order 6: Some(Car { color: "Green", motor: Automatic, roof: true, age: ("Used", 700) })
Car order 7: Some(Car { color: "Red", motor: Manual, roof: true, age: ("Used", 1400) })
Car order 8: Some(Car { color: "Silver", motor: SemiAuto, roof: false, age: ("Used", 2100) })
Car order 9: Some(Car { color: "Blue", motor: Automatic, roof: true, age: ("New", 0) })
Car order 10: Some(Car { color: "Green", motor: SemiAuto, roof: false, age: ("Used", 700) })
Car order 11: Some(Car { color: "Red", motor: Manual, roof: true, age: ("Used", 1400) })

概要

このモジュールでは、Rustで使用できるさまざまなループ式を調べ、ハッシュマップの操作方法を発見しました。データは、キーと値のペアとしてハッシュマップに保存されます。ハッシュマップは拡張可能です。

loop手動でプロセスを停止するまでの式は、アクションを繰り返します。while式をループして、条件が真である限りアクションを繰り返すことができます。このfor式は、データ収集を反復処理するために使用されます。

この演習では、自動車プログラムを拡張して、繰り返されるアクションをループし、すべての注文を処理しました。注文を追跡するためにハッシュマップを実装しました。

このラーニングパスの次のモジュールでは、Rustコードでエラーと障害がどのように処理されるかについて詳しく説明します。

 ãƒªãƒ³ã‚¯: https://docs.microsoft.com/en-us/learn/modules/rust-loop-expressions/

#rust #Beginners 

ループを使用して、Rustのデータを反復処理します

【Rust入門】最初のRustプログラムを作成する

このモジュールでは、プログラミング言語の一般的な概念を学び、それらがRustでどのように実装されているかを発見します。概念はRustに固有のものではありませんが、すべてのRustプログラムの基盤を提供します。これらの概念について学ぶことで、あらゆるプログラミング言語での開発をサポートするための理解を得ることができます。

さび遊び場

錆遊び場は錆コンパイラにブラウザインタフェースです。言語をローカルにインストールする前、またはコンパイラが利用できない場合は、Playgroundを使用してRustコードの記述を試すことができます。このコース全体を通して、サンプルコードと演習へのPlaygroundリンクを提供します。現時点でRustツールチェーンを使用できない場合でも、コードを操作できます。

Rust Playgroundで実行されるすべてのコードは、ローカルの開発環境でコンパイルして実行することもできます。コンピューターからRustコンパイラーと対話することを躊躇しないでください。Rust Playgroundの詳細については、What isRust?をご覧ください。モジュール。

学習目標

このモジュールでは、次のことを行います。

  • 関数、データ型、変数など、Rustのコア言語の概念を探る
  • テキスト、数値、ブール値、および複合データの基本的なRustタイプを理解する
  • 基本的なRustプログラムを作成、コンパイル、実行します
  • プログラムからの出力を印刷する方法を発見する

基本的なRustプログラムの構造を理解する

この単元では、単純なRustプログラムがどのように構成されているかを確認します。

Rustの機能


関数は、特定のタスクを実行するコードのブロックです。プログラム内のコードをタスクに基づいてブロックに分割します。この分離により、コードの理解と保守が容易になります。タスクの関数を定義した後、そのタスクを実行する必要があるときに関数を呼び出すことができます。

すべてのRustプログラムには、という名前の関数が1つ必要mainです。main関数内のコードは、常にRustプログラムで実行される最初のコードです。関数内からmain、または他の関数内から他の関数を呼び出すことができます。

fn main() {
	println!("Hello, world!");
}

Rustで関数を宣言するには、fnキーワードを使用します。関数名の後に、関数が入力として期待するパラメーターまたは引数の数をコンパイラーに通知します。引数は括弧内にリストされています()。関数本体は、機能のタスクを行い、中括弧内で定義されているコードです{}。関数本体の開始中括弧が括弧内の引数リストの直後に表示されるように、コードをフォーマットすることをお勧めします。

コードのインデント

関数本体では、ほとんどのコードステートメントはセミコロンで終わり;ます。Rustは、これらのステートメントを順番に処理します。コードステートメントがセミコロンで終わっていない場合、Rustは、開始ステートメントを完了する前に、コードの次の行を実行する必要があることを認識しています。

コード内の実行関係を確認しやすくするために、インデントを使用します。この形式は、コードがどのように編成されているかを示し、関数タスクを完了するためのステップのフローを明らかにします。開始コードステートメントは、左マージンから4スペースインデントされます。コードがセミコロンで終わっていない場合、実行するコードの次の行はさらに4つのスペースでインデントされます。

次に例を示します。

fn main() { // The function declaration is not indented

    // First step in function body
        // Substep: execute before First step can be complete

    // Second step in function body
        // Substep A: execute before Second step can be complete
        // Substep B: execute before Second step can be complete
            // Sub-substep 1: execute before Substep B can be complete

    // Third step in function body, and so on...
}

やること!大きい

Rustモジュールで演習を行うと、サンプルコードでtodo!マクロがよく使用されることに気付くでしょう。Rustのマクロは、可変数の入力引数を受け取る関数のようなものです。このtodo!マクロは、Rustプログラムの未完成のコードを識別するために使用されます。このマクロは、プロトタイピングや、完全ではない動作を示したい場合に役立ちます。

todo!演習でマクロを使用する方法の例を次に示します。

fn main() {
    // Display the message "Hello, world!"
    todo!("Display the message by using the println!() macro");
}

todo!マクロを使用するコードをコンパイルすると、コンパイラーは、完了した機能を見つけることを期待するパニックメッセージを返す可能性があります。

   Compiling playground v0.0.1 (/playground)
    Finished dev [unoptimized + debuginfo] target(s) in 1.50s
     Running `target/debug/playground`
thread 'main' panicked at 'not yet implemented: Display the message by using the println!() macro', src/main.rs:3:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

println!大きい

私たちのmain関数は1つのタスクを実行します。println!Rustで事前定義されているマクロを呼び出します。println!マクロを期待それは画面または表示に一つ以上の入力引数、標準出力。この例では、1つの入力引数であるテキスト文字列「Hello、world!」をマクロに渡します。

さびコピー

 

fn main() {
    // Our main function does one task: show a message
    // println! displays the input "Hello, world!" to the screen
    println!("Hello, world!");
}

{}引数の値の置換

Rust Learnモジュールのレッスンではprintln!、中括弧{}やその他の値のインスタンスを含むテキスト文字列を含む引数のリストを使用してマクロを呼び出すことがよくあります。println!マクロは、中括弧の各インスタンスを置き換え{}リスト内の次の引数の値を持つテキスト文字列内。

次に例を示します。

fn main() {
    // Call println! with three arguments: a string, a value, a value
    println!("The first letter of the English alphabet is {} and the last letter is {}.", 'A', 'Z');
}

println!文字列、値、および別の値の3つの引数を使用してマクロを呼び出します。マクロは引数を順番に処理します。{}テキスト文字列内の中括弧の各インスタンスは、リスト内の次の引数の値に置き換えられます。

出力は次のとおりです。

The first letter of the English alphabet is A and the last letter is Z.

Rustで変数を作成して使用する


開発者は、データを操作するためのコンピュータープログラムを作成します。データは収集、分析、保存、処理、共有、および報告されます。変数を使用して、コードの後半で参照できる名前付き参照にデータを格納します。

変数

Rustでは、変数はキーワードで宣言されていletます。各変数には一意の名前があります。変数が宣言されると、値にバインドすることも、プログラムの後半で値をバインドすることもできます。次のコードは、という名前の変数を宣言しますa_number。

let a_number;

a_number変数がまだ値にバインドされていません。このステートメントを変更して、値を変数にバインドできます。

let a_number = 10;

ノート

キーワード   他のプログラミング言語と同様に、およびのような特定のキーワードは、Rustのみが使用するために予約されています。キーワードを関数または変数の名前として使用することはできません。fnlet

別の例を見てみましょう。次のコードは、2つの変数を宣言しています。最初の変数が宣言され、数値にバインドされます。2番目の変数が宣言されていますが、値にバインドされていません。プログラムの後半で、2番目の変数の値が単語にバインドされます。コードはprintln!マクロを呼び出して変数値を表示します。

// Declare a variable
let a_number;
    
// Declare a second variable and bind the value
let a_word = "Ten";
    
// Bind a value to the first variable
a_number = 10;

println!("The number is {}.", a_number);
println!("The word is {}.", a_word);

この例では、次の出力を出力します。

The number is 10.
The word is Ten.

println!マクロを呼び出して、a_numberバインドされる前に変数の値を表示しようとすると、コンパイラーはエラーを返します。このエラーメッセージは、RustPlaygroundで確認できます。[実行]ボタンを選択してコードを実行します。

不変対可変

Rustでは、変数バインディングはデフォルトで不変です。変数が不変である場合、値が名前にバインドされた後は、その値を変更することはできません。

たとえばa_number、前の例の変数の値を変更しようとすると、コンパイラからエラーメッセージが表示されます。

// Change the value of an immutable variable
a_number = 15;

この変更を自分で試して、RustPlaygroundでエラーメッセージを確認できます。

値をmut変更するには、最初にキーワードを使用して変数バインディングを変更可能にする必要があります。

// The `mut` keyword lets the variable be changed
let mut a_number = 10; 
println!("The number is {}.", a_number);

// Change the value of an immutable variable
a_number = 15;
println!("Now the number is {}.", a_number);

この例では、次の出力を出力します。

The number is 10.
Now the number is 15.

変数を変更a_numberできるようになったため、このコードはエラーなしでコンパイルされます。

可変シャドウイング

既存の変数と同じ名前を使用する新しい変数を宣言できます。新しい宣言により、新しいバインディングが作成されます。Rustでは、新しい変数が前の変数をシャドウイングするため、この操作は「シャドウイング」と呼ばれます。古い変数はまだ存在しますが、このスコープでそれを参照することはできなくなりました。

次のコードは、シャドウイングの使用法を示しています。shadow_num。という名前の変数を宣言します。各let操作はnumber、前の変数バインディングをシャドウイングしている間に名前が付けられた新しい変数を作成するため、変数を可変として定義しません。

// Declare first variable binding with name "shadow_num"
let shadow_num = 5;

// Declare second variable binding, shadows existing variable "shadow_num" 
let shadow_num = shadow_num + 5; 

// Declare third variable binding, shadows second binding of variable "shadow_num"
let shadow_num = shadow_num * 2; 

println!("The number is {}.", shadow_num);

出力を推測できますか?この例を実行するには、RustPlaygroundにアクセスしてください。

数値、テキスト、および真/偽の値のデータ型を調べる


Rustは静的に型付けされた言語です。コンパイラは、プログラムをコンパイルして実行するために、コード内のすべての変数の正確なデータ型を知っている必要があります。コンパイラは通常、バインドされた値に基づいて変数のデータ型を推測できます。コード内でタイプを明示的に指定する必要は必ずしもありません。多くの型が可能な場合は、型注釈を使用して特定の型をコンパイラーに通知する必要があります。

次の例では、number変数を32ビット整数として作成するようにコンパイラーに指示します。u32変数名の後にデータ型を指定します。:変数名の後にコロンが使用されていることに注意してください。

let number: u32 = 14;
println!("The number is {}.", number);

変数値を二重引用符で囲むと、コンパイラーは値を数値ではなくテキストとして解釈します。値の推定データ型がu32変数に指定されたデータ型と一致しないため、コンパイラーはエラーを発行します。

let number: u32 = "14";

コンパイラエラー:

   Compiling playground v0.0.1 (/playground)
error[E0308]: mismatched types
 --> src/main.rs:2:23
  |
2 |     let number: u32 = "14";
  |                 ---   ^^^^ expected `u32`, found `&str`
  |                 |
  |                 expected due to this

error: aborting due to previous error

このRustPlaygroundで前述のコードを操作できます。

組み込みのデータ型

Rustには、数値、テキスト、および真実性を表現するためのいくつかの組み込みプリミティブデータ型が付属しています。これらのタイプのいくつかは、単一の値を表すため、スカラーと呼ばれます。

  • 整数
  • 浮動小数点数
  • ブール値
  • キャラクター

Rustは、文字列値やタプル値など、データ系列を処理するためのより複雑なデータ型も提供します。

数値:整数と浮動小数点値

Rustの整数は、ビットサイズと符号付きプロパティによって識別されます。符号付き整数は、正または負の数であってもよいです。符号なし整数は正の数値を指定できます。

長さ署名済み署名なし  
8ビットi8u8  
16ビットi16u16  
32ビットi32u32  
64ビットi64u64  
128ビットi128u128  
アーキテクチャに依存isizeusize  

タイプは、あなたのプログラムが実行されているコンピュータの種類によって異なります。64ビットタイプは64ビットアーキテクチャで使用され、32ビットタイプは32ビットアーキテクチャで使用されます。整数の型を指定せず、システムが型を推測できない場合、デフォルトで型(32ビットの符号付き整数)が割り当てられます。isizeusizei32

Rustには、10進値用の2つの浮動小数点データ型f32((32ビット)とf64(64ビット))があります。デフォルトの浮動小数点型はf64です。最近のCPUでは、f64タイプはタイプとほぼ同じ速度ですが、f32精度が高くなっています。

let number_64 = 4.0;      // compiler infers the value to use the default type f64
let number_32: f32 = 5.0; // type f32 specified via annotation

Rustのすべてのプリミティブ数値型は、加算、減算、乗算、除算などの数学演算をサポートしています。

// Addition, Subtraction, and Multiplication
println!("1 + 2 = {} and 8 - 5 = {} and 15 * 3 = {}", 1u32 + 2, 8i32 - 5, 15 * 3);

// Integer and Floating point division
println!("9 / 2 = {} but 9.0 / 2.0 = {}", 9u32 / 2, 9.0 / 2.0);

ノート

println関数を呼び出すときは、データ型の接尾辞を各リテラル番号に追加して、データ型についてRustに通知します。構文1u32は、値が数値1であり、値を符号なし32ビット整数として解釈するようにコンパイラーに指示します。型注釈を提供しない場合、Rustはコンテキストから型を推測しようとします。コンテキストがあいまいな場合、i32デフォルトでタイプ(32ビットの符号付き整数)が割り当てられます。

この例をRustPlaygroundで実行してみることができます。

ブール値:TrueまたはFalse

Rustのブール型は、真実性を格納するために使用されます。boolタイプは2つの値を持っていますtrueかfalse。ブール値は、条件式で広く使用されています。場合boolステートメントまたは値がtrueの場合、このアクションを行います。それ以外の場合(ステートメントまたは値がfalse)、別のアクションを実行します。ブール値は、多くの場合、比較チェックによって返されます。

次の例では、大なり>記号演算子を使用して2つの値をテストします。演算子は、テストの結果を示すブール値を返します。

// Declare variable to store result of "greater than" test, Is 1 > 4? -- false
let is_bigger = 1 > 4;
println!("Is 1 > 4? {}", is_bigger);  

テキスト:文字と文字列

Rustは、2つの基本的な文字列タイプと1つの文字タイプのテキスト値をサポートします。文字は単一のアイテムであり、文字列は一連の文字です。すべてのテキストタイプは有効なUTF-8表現です。

charタイプは、テキストタイプの最も原始的です。値は、アイテムを一重引用符で囲むことによって指定されます。

let uppercase_s = 'S';
let lowercase_f = 'f';
let smiley_face = '😃';

ノート

一部の言語では、char型を8ビットの符号なし整数として扱います。これはRustu8型と同等です。charRustの型にはユニコードコードポイントが含まれていますが、utf-8エンコーディングを使用していません。charRustのAは、32ビット幅になるようにパディングされた21ビット整数です。にcharは、プレーンコードポイント値が直接含まれています。

文字列

str知られているタイプ、文字列スライスは、あるビュー文字列データに変換します。ほとんどの場合、これらの型は、型の前にアンパサンドを付ける参照スタイルの構文を使用して参照します&str。次のモジュールでリファレンスについて説明します。今の&strところ、不変の文字列データへのポインタと考えることができます。文字列リテラルはすべてタイプ&strです。

文字列リテラルは、Rustの紹介の例で使用すると便利ですが、テキストを使用する可能性のあるすべての状況に適しているわけではありません。コンパイル時にすべての文字列を認識できるわけではありません。例としては、ユーザーが実行時にプログラムを操作し、端末を介してテキストを送信する場合があります。

これらのシナリオでは、RustにはString。という名前の2番目の文字列型があります。このタイプはヒープに割り当てられます。String型を使用する場合、コードをコンパイルする前に文字列の長さ(文字数)を知る必要はありません。

ノート

ガベージコレクションされた言語に精通している場合は、Rustに2つの文字列型があるのはなぜか疑問に思われるかもしれません。1文字列は非常に複雑なデータ型です。ほとんどの言語は、ガベージコレクターを使用して、この複雑さを理解しています。システムの言語としてのRustは、文字列に固有の複雑さの一部を明らかにします。複雑さが増すと、プログラムでのメモリの使用方法を非常にきめ細かく制御できます。
 

1 _実際、Rustには3つ以上の文字列タイプがあります。このモジュールでは、Stringと&strタイプについてのみ説明します。Rustのドキュメントで提供されている文字列型について詳しく知ることができます。

私たちは、違いの完全なアイデア得ることはありませんStringし、&str私たちは錆の所有権および借入システムについて学ぶまでに。それまでは、String型データは、プログラムの実行中に変化する可能性のあるテキストデータと考えることができます。&str参照は、あなたのプログラムの実行と変わらないテキストデータへの不変の図です。

テキストの例

次の例は、Rustでcharおよび&strデータ型を使用する方法を示しています。

  • 2つの文字変数が: char注釈構文で宣言されています。値は一重引用符を使用して指定されます。
  • 3番目の文字変数が宣言され、単一の画像にバインドされます。この変数については、コンパイラにデータ型を推測させます。
  • 2つの文字列変数が宣言され、それぞれの値にバインドされます。文字列は二重引用符で囲まれています。
  • 文字列変数の1つは、: &strデータ型を指定するための注釈構文で宣言されています。他の変数のデータ型は指定されていません。コンパイラは、コンテキストに基づいてこの変数のデータ型を推測します。

string_1変数には、一連の文字の最後に空のスペースが含まれていることに注意してください。

// Specify the data type "char"
let character_1: char = 'S';
let character_2: char = 'f';
   
// Complier interprets a single item in quotations as the "char" data type
let smiley_face = '😃';

// Complier interprets a series of items in quotations as a "str" data type and creates a "&str" reference
let string_1 = "miley ";

// Specify the data type "str" with the reference syntax "&str"
let string_2: &str = "ace";

println!("{} is a {}{}{}{}.", smiley_face, character_1, string_1, character_2, string_2);

この例の出力は次のとおりです。

😃 is a Smiley face.

この例で&前strにアンパサンドを指定しなかった場合はどうなりますか?調べるには、RustPlaygroundでこの例を実行してみてください。

タプルと構造体を使用してデータコレクションを定義する


この単元では、データコレクションまたは複合データの操作に役立つ2つのデータ型(タプルと構造体)について説明します。

タプル

タプルは、1つの複合値に収集されたさまざまなタイプの値のグループです。タプル内の個々の値は要素と呼ばれます。値は、括弧で囲まれたコンマ区切りのリストとして指定されます(<value>, <value>, ...)。

タプルの長さは固定されており、要素の数と同じです。タプルが宣言された後は、サイズを拡大または縮小することはできません。要素を追加または削除することはできません。タプルのデータ型は、要素のデータ型のシーケンスによって定義されます。

タプルを定義する

これは、3つの要素を持つタプルの例です。

// Tuple of length 3
let tuple_e = ('E', 5i32, true);

次の表は、タプルの各要素の値、データ型、およびインデックスを示しています。

エレメント価値データ・タイプ
0Echar
15i32
2NSbool

このタプルの型シグネチャは、次の3つの要素の型のシーケンスによって定義されます(char, i32, bool)。

タプル内の要素にアクセスする

タプル内の要素には、ゼロから始まるインデックス位置からアクセスできます。このプロセスは、タプルインデックスと呼ばれます。タプル内の要素にアクセスするには、構文を使用します<tuple>.<index>。

次の例は、インデックスを使用してタプル内の要素にアクセスする方法を示しています。

// Declare a tuple of three elements
let tuple_e = ('E', 5i32, true);

// Use tuple indexing and show the values of the elements in the tuple
println!("Is '{}' the {}th letter of the alphabet? {}", tuple_e.0, tuple_e.1, tuple_e.2);

この例は、次の出力を示しています。

Is 'E' the 5th letter of the alphabet? true

この例は、RustPlaygroundで調べることができます。

タプルは、さまざまなタイプを1つの値に結合する場合に役立ちます。タプルは任意の数の値を保持できるため、関数はタプルを使用して複数の値を返すことができます。

構造体

構造体は、他の型で構成される型です。構造体の要素はフィールドと呼ばれます。タプルと同様に、構造体のフィールドはさまざまなデータ型を持つことができます。構造体タイプの重要な利点は、各フィールドに名前を付けることができるため、値の意味が明確になることです。

Rustプログラムで構造体を操作するには、最初に名前で構造体を定義し、各フィールドのデータ型を指定します。次に、別の名前で構造体のインスタンスを作成します。インスタンスを宣言するときは、フィールドに特定の値を指定します。

Rustは、クラシック構造体、タプル構造体、ユニット構造体の3つの構造体タイプをサポートしています。これらの構造体タイプは、データをグループ化して操作するさまざまな方法をサポートしています。

  • クラシックC構造体が最も一般的に使用されます。構造体の各フィールドには、名前とデータ型があります。従来の構造体を定義した後、構文を使用して構造体のフィールドにアクセスできます<struct>.<field>。
  • タプル構造体は従来の構造体に似ていますが、フィールドに名前がありません。タプル構造体のフィールドにアクセスするには、タプルのインデックスを作成する場合と同じ構文を使用します<tuple>.<index>。タプルと同様に、タプル構造体のインデックス値はゼロから始まります。
  • ユニット構造体は、マーカーとして最も一般的に使用されます。Rustの特性機能について学ぶときに、ユニット構造体が役立つ理由について詳しく学びます。

次のコードは、3種類の構造体タイプの定義例を示しています。

// Classic struct with named fields
struct Student { name: String, level: u8, remote: bool }

// Tuple struct with data types only
struct Grades(char, char, char, char, f32);

// Unit struct
struct Unit;

構造体を定義する

構造体を定義するには、キーワードにstruct続けて構造体名を入力します。グループ化されたデータの重要な特性を説明する構造体タイプの名前を選択します。これまで使用してきた命名規則とは異なり、構造体タイプの名前は大文字になります。

構造体タイプはmain、Rustプログラムの関数やその他の関数の外部で定義されることがよくあります。このため、構造体定義の先頭は左マージンからインデントされません。データがどのように編成されているかを示すために、定義の内側の部分のみがインデントされています。

古典的な構造

関数と同様に、古典的な構造体の本体は中括弧内に定義されています{}。クラシック構造体の各フィールドには、構造体内で一意の名前が付けられています。各フィールドのタイプは、構文で指定されます: <type>。クラシック構造体のフィールドは、コンマ区切りのリストとして指定されます<field>, <field>, ...。古典的な構造体の定義はセミコロンで終わりません。

// Classic struct with named fields
struct Student { name: String, level: u8, remote: bool }

従来の構造体定義の利点は、名前で構造体フィールドの値にアクセスできることです。フィールド値にアクセスするには、構文を使用します<struct>.<field>。

タプル構造体

タプルと同様に、タプル構造体の本体は括弧内に定義されています()。括弧は構造体名の直後に続きます。構造体名と開き括弧の間にスペースはありません。

タプルとは異なり、タプル構造体定義には、各フィールドのデータ型のみが含まれます。タプル構造体のデータ型は、コンマ区切りのリストとして指定されます<type>, <type>, ...。

// Tuple struct with data types only
struct Grades(char, char, char, char, f32);

構造体をインスタンス化する

構造体タイプを定義した後、タイプのインスタンスを作成し、各フィールドに値を指定することにより、構造体を使用します。フィールド値を設定するときに、定義されているのと同じ順序でフィールドを指定する必要はありません。

次の例では、StudentおよびGrades構造体タイプ用に作成した定義を使用しています。

// Instantiate classic struct, specify fields in random order, or in specified order
let user_1 = Student { name: String::from("Constance Sharma"), remote: true, level: 2 };
let user_2 = Student { name: String::from("Dyson Tan"), level: 5, remote: false };

// Instantiate tuple structs, pass values in same order as types defined
let mark_1 = Grades('A', 'A', 'B', 'A', 3.75);
let mark_2 = Grades('B', 'A', 'A', 'C', 3.25);

println!("{}, level {}. Remote: {}. Grades: {}, {}, {}, {}. Average: {}", 
         user_1.name, user_1.level, user_1.remote, mark_1.0, mark_1.1, mark_1.2, mark_1.3, mark_1.4);
println!("{}, level {}. Remote: {}. Grades: {}, {}, {}, {}. Average: {}", 
         user_2.name, user_2.level, user_2.remote, mark_2.0, mark_2.1, mark_2.2, mark_2.3, mark_2.4);

文字列リテラルを文字列型に変換します

構造体やベクトルなどの別のデータ構造内に格納されている文字列データは、文字列リテラル参照(&str)からString型に変換する必要があります。変換を行うには、標準的なString::from(&str)方法を使用します。この例でこのメソッドをどのように使用しているかに注意してください。

// Classic struct with named fields
struct Student { name: String, level: u8, remote: bool }
...
let user_2 = Student { name: String::from("Dyson Tan"), level: 5, remote: false };

値を割り当てる前に型を変換しないと、コンパイラはエラーを発行します。

error[E0308]: mismatched types
  --> src/main.rs:24:15
   |
24 |         name: "Dyson Tan",
   |               ^^^^^^^^^^^
   |               |
   |               expected struct `String`, found `&str`
   |               help: try using a conversion method: `"Dyson Tan".to_string()`

error: aborting due to previous error

コンパイラーは、.to_string()関数を使用して変換を行うことができることを提案しています。この例では、String::from(&str)メソッドを使用します。

このRustPlaygroundのサンプルコードを操作できます。

複合データに列挙型バリアントを使用する


列挙型は、いくつかのバリアントのいずれかになり得るタイプです。Rustが列挙型と呼ぶものは、より一般的に代数的データ型として知られています。重要な詳細は、各列挙型バリアントがそれに伴うデータを持つことができるということです。

私たちは、使用enum列挙型変異体の任意の組み合わせを持つことができます列挙型を作成するキーワードを。構造体と同様に、列挙型バリアントには、名前付きフィールド、名前のないフィールド、またはフィールドがまったくない場合があります。構造体型と同様に、列挙型も大文字になります。

列挙型を定義する

次の例では、Webイベントを分類するための列挙型を定義します。列挙型の各バリアントは独立しており、さまざまな量とタイプの値を格納します。

enum WebEvent {
    // An enum variant can be like a unit struct without fields or data types
    WELoad,
    // An enum variant can be like a tuple struct with data types but no named fields
    WEKeys(String, char),
    // An enum variant can be like a classic struct with named fields and their data types
    WEClick { x: i64, y: i64 }
}

この例の列挙型には、異なるタイプの3つのバリアントがあります。

  • WELoad 関連するデータ型またはデータはありません。
  • WEKeysデータ型Stringとの2つのフィールドがありcharます。
  • WEMClick名前付きフィールドxとy、およびそれらのデータ型(i64)を持つ匿名の構造体が含まれています。

さまざまな種類の構造体タイプを定義する方法と同様のバリアントを使用して列挙型を定義します。すべてのバリアントは、同じWebEvent列挙型にグループ化されます。列挙型の各バリアントは、独自のタイプではありません。WebEvent列挙型のバリアントを使用する関数は、列挙型内のすべてのバリアントを受け入れる必要があります。WEClickバリアントのみを受け入れ、他のバリアントは受け入れない関数を使用することはできません。

構造体で列挙型を定義する

列挙型バリアントの要件を回避する方法は、列挙型のバリアントごとに個別の構造体を定義することです。次に、列挙型の各バリアントは対応する構造体を使用します。構造体は、対応する列挙型バリアントによって保持されていたものと同じデータを保持します。このスタイルの定義により、各論理バリアントを独自に参照できます。

次のコードは、この代替定義スタイルの使用方法を示しています。構造体は、データを保持するように定義されています。列挙型のバリアントは、構造体を参照するように定義されています。

// Define a tuple struct
struct KeyPress(String, char);

// Define a classic struct
struct MouseClick { x: i64, y: i64 }

// Redefine the enum variants to use the data from the new structs
// Update the page Load variant to have the boolean type
enum WebEvent { WELoad(bool), WEClick(MouseClick), WEKeys(KeyPress) }

列挙型をインスタンス化します

次に、列挙型バリアントのインスタンスを作成するコードを追加しましょう。バリアントごとに、letキーワードを使用して割り当てを行います。列挙型定義の特定のバリアントにアクセスするには<enum>::<variant>、二重コロンを使用した構文を使用します::。

単純なバリアント:WELoad(bool)

WebEvent列挙型の最初のバリアントには、単一のブール値、がありWELoad(bool)ます。前の単元でブール値を操作したのと同様の方法で、このバリアントをインスタンス化します。

let we_load = WebEvent::WELoad(true);

構造体バリアント:WEClick(MouseClick)

2番目のバリアントには、古典的な構造体が含まれていWEClick(MouseClick)ます。構造体には2つの名前付きフィールドxとyがあり、両方のフィールドのi64データ型があります。このバリアントを作成するには、最初に構造体をインスタンス化します。次に、呼び出しの引数として構造体を渡して、バリアントをインスタンス化します。

// Instantiate a MouseClick struct and bind the coordinate values
let click = MouseClick { x: 100, y: 250 };

// Set the WEClick variant to use the data in the click struct
let we_click = WebEvent::WEClick(click);

タプルバリアント:WEKeys(KeyPress)

最後のバリアントにはタプルが含まれていWEKeys(KeyPress)ます。タプルには、Stringおよびcharデータ型を使用する2つのフィールドがあります。このバリアントを作成するには、最初にタプルをインスタンス化します。次に、バリアントをインスタンス化するための呼び出しでタプルを引数として渡します。

// Instantiate a KeyPress tuple and bind the key values
let keys = KeyPress(String::from("Ctrl+"), 'N');
    
// Set the WEKeys variant to use the data in the keys tuple
let we_key = WebEvent::WEKeys(keys);

このコードでは、新しい構文を使用していることに注意してくださいString::from("<value>")。この構文はString、Rustfromメソッドを呼び出すことによってtypeの値を作成します。このメソッドは、二重引用符で囲まれたデータの入力引数を想定しています。

列挙型の例

列挙型バリアントをインスタンス化するための最終的なコードは次のとおりです。

// Instantiate a MouseClick struct and bind the coordinate values
let click = MouseClick { x: 100, y: 250 };
println!("Mouse click location: {}, {}", click.x, click.y);
    
// Instantiate a KeyPress tuple and bind the key values
let keys = KeyPress(String::from("Ctrl+"), 'N');
println!("\nKeys pressed: {}{}", keys.0, keys.1);
    
// Instantiate WebEvent enum variants
// Set the boolean page Load value to true
let we_load = WebEvent::WELoad(true);
// Set the WEClick variant to use the data in the click struct
let we_click = WebEvent::WEClick(click);
// Set the WEKeys variant to use the data in the keys tuple
let we_key = WebEvent::WEKeys(keys);
    
// Print the values in the WebEvent enum variants
// Use the {:#?} syntax to display the enum structure and data in a readable form
println!("\nWebEvent enum structure: \n\n {:#?} \n\n {:#?} \n\n {:#?}", we_load, we_click, we_key);

このサンプルコードと対話するようにしてください錆遊び場。

デバッグステートメント

Rust Playgroundで、次のコードステートメントを探します。このステートメントは、コードのいくつかの場所で使用されています。

// Set the Debug flag so we can check the data in the output
#[derive(Debug)]

この#[derive(Debug)]構文により、コードの実行中に、他の方法では標準出力では表示できない特定の値を確認できます。println!マクロでデバッグデータを表示するには、構文を使用し{:#?}てデータを読み取り可能な方法でフォーマットします。

Rustの関数を操作する

関数は、Rust内でコードが実行される主要な方法です。この言語で最も重要な関数の1つである関数についてはすでに見てきましたmain。この単元では、関数の定義方法について詳しく説明します。

関数を定義する

Rustの関数定義は、fnキーワードで始まります。関数名の後に、関数の入力引数を括弧内のデータ型のコンマ区切りリストとして指定します。中括弧は、関数本体の開始位置と終了位置をコンパイラーに通知します。

fn main() {
    println!("Hello, world!");
    goodbye();
}

fn goodbye() {
    println!("Goodbye.");
}

名前と括弧内の入力引数を使用して関数を呼び出します。関数に入力引数がない場合は、括弧を空のままにします。この例では、mainとgoodbye関数の両方に入力引数がありません。

goodbye関数の後にmain関数を定義したことに気づいたかもしれません。を定義するgoodbye前に関数を定義することもできますmain。Rustは、ファイルのどこかに関数が定義されている限り、ファイルのどこに関数を定義してもかまいません。

入力引数を渡す

関数に入力引数がある場合、各引数に名前を付け、関数宣言の開始時にデータ型を指定します。引数は変数のように名前が付けられているため、関数本体の引数にアクセスできます。

goodbye関数を変更して、入力引数として文字列データへのポインタを取得しましょう。

fn goodbye(message: &str) {
    println!("\n{}", message);
}

fn main() {
    let formal = "Formal: Good bye.";
    let casual = "Casual: See you later!";
    goodbye(formal);
    goodbye(casual);
}

main2つの異なる引数値を使用して関数から関数を呼び出すことで関数をテストし、出力を確認します。

Formal: Good bye.
Casual: See you later!

値を返す

関数が値を返す場合、関数の-> <type>引数のリストの後、関数本体の開始中括弧の前に構文を追加します。矢印の構文->は、関数が呼び出し元に値を返すことを示しています。この<type>部分は、返される値のデータ型をコンパイラーに知らせます。

Rustでは、関数のコードの最後の行を返す値と等しくすることにより、関数の最後に値を返すのが一般的な方法です。次の例は、この動作を示しています。このdivide_by_5関数は、入力された数値を5で割った結果を呼び出し元の関数に返します。

fn divide_by_5(num: u32) -> u32 {
    num / 5
}

fn main() {
    let num = 25;
    println!("25 divided by 5 = {}", num, divide_by_5(25));
}

出力は次のとおりです。

25 divided by 5 = 5

return関数の任意の時点でキーワードを使用して、実行を停止し、呼び出し元に値を送り返すことができます。通常、returnキーワードの使用は、条件付きテストと組み合わせて使用されます。

returnの値numが0の場合に、キーワードを明示的に使用して関数から早期に戻る例を次に示します。

fn divide_by_5(num: u32) -> u32 {
    todo!("Check if num is 0") {
        // Return early
        return 0;
    }
    num / 5
}

returnキーワードを明示的に使用する場合は、ステートメントをセミコロンで終了します。returnキーワードを使用せずに戻り値を返送する場合、ステートメントをセミコロンで終了しません。num / 5戻り値ステートメントに終了セミコロンを使用しなかったことにお気づきかもしれません。

署名を確認する

関数の宣言の最初の部分は、関数シグネチャと呼ばれます。

このgoodbye例の関数のシグネチャには、次の特性があります。

  • fn:Rustの関数宣言キーワード。
  • goodbye:関数名。
  • (message: &str):関数の引数またはパラメータリスト。入力値として、文字列データへの1つのポインタが必要です。
  • -> bool:矢印は、この関数が常に返す値のタイプを示しています。

このgoodbye関数は、1つの文字列ポインタを入力として受け入れ、ブール値を出力します

演習:車を作るための関数を書く


この演習では、列挙型、構造体、および関数を使用して、新しい車の注文を処理します。課題は、サンプルコードを修正して、コンパイルして実行することです。

この演習のサンプルコードで作業するには、次の2つのオプションがあります。

  • コードをコピーして、ローカル開発環境で編集します。
  • 準備されたRustPlaygroundでコードを開きます。

ノート

サンプルコードで、todo!マクロを探します。このマクロは、完了するか更新する必要があるコードを示します。

列挙型を定義する

最初のタスクは、列挙型定義の構文の問題を修正して、コードをコンパイルすることです。

サンプルコードの最初のブロックを開きます。

次のコードをコピーしてローカル開発環境で編集する
か、この準備されたRustPlaygroundでコードを開きます。

Transmissionプログラムが正常にコンパイルされるように、列挙型の構文エラーを修正してください。

次のセクションに進む前に、コードがコンパイルされていることを確認してください。コードはまだ出力を表示していませんが、エラーなしでコンパイルする必要があります。

コンパイラからの警告メッセージは無視してかまいません。警告は、列挙型と構造体の定義を宣言したが、まだ使用していないためです。

  1. サンプルコードの最初のブロックを開きます。

次のコードをコピーしてローカル開発環境で編集する
か、この準備されたRustPlaygroundでコードを開きます。

// Declare Car struct to describe vehicle with four named fields
struct Car {
    color: String,
    transmission: Transmission,
    convertible: bool,
    mileage: u32,
}

#[derive(PartialEq, Debug)]
// Declare enum for Car transmission type
enum Transmission {
    // todo!("Fix enum definition so code compiles");
    Manual;
    SemiAuto;
    Automatic;
}

2. Transmissionプログラムが正常にコンパイルされるように、列挙型の構文エラーを修正してください。

次のセクションに進む前に、コードがコンパイルされていることを確認してください。コードはまだ出力を表示していませんが、エラーなしでコンパイルする必要があります。

コンパイラからの警告メッセージは無視してかまいません。警告は、列挙型と構造体の定義を宣言したが、まだ使用していないためです。

構造体をインスタンス化する

次に、構造体のcar_factoryインスタンスを作成する関数のコードを追加しますCar。入力引数の値を使用して、車の特性を割り当てます。

  1. 次のコードブロックを既存のコードに追加します。新しいコードは、ファイルの上部または下部に追加できます。
// Build a "Car" by using values from the input arguments
// - Color of car (String)
// - Transmission type (enum value)
// - Convertible (boolean, true if car is a convertible)
fn car_factory(color: String, transmission: Transmission, convertible: bool) {

    // Use the values of the input arguments
    // All new cars always have zero mileage
    let car: Car = todo!("Create an instance of a `Car` struct");
}

2. コードを再構築し、コンパイルされることを確認します。繰り返しますが、警告メッセージは無視してかまいません。

3. car変数の宣言を完了して、「Car」構造体のインスタンスを作成します。新しい車は、関数に渡された入力引数の値を使用する必要があります。すべての新車の走行距離はゼロです。

ヒント

ステートメントを型宣言let car: Carからインスタンス化に変更する必要がありますlet car = Car { ... }。

4. コードを再構築し、コンパイルされることを確認します。

関数から値を返す

次に、car_factory関数を更新して、作成されたCar構造体を返します。値を返すには、関数のシグネチャで値の型を宣言し、関数の本体で値を指定する必要があります。

 1. 関数のシグネチャを変更して、戻り値の型をCar構造体として宣言します。ファイル内の次のコード行を変更します。

fn car_factory(color: String, transmission: Transmission, convertible: bool) = todo!("Return a `Car` struct") {

ヒント

大文字と小文字の区別に注意してください。まだコードをコンパイルしようとしないでください!

2. 新しく作成された車を返すには、Car構造体をインスタンス化したステートメントを調整します。

let car: Car = todo!("An instance of a `Car` struct", "Set the function return value");
}

ヒント

前のセクションでlet car: Car =は、Car構造体のインスタンスを正しく作成するようにステートメントを変更しました。この手順を完了するには、このコードを簡略化できます。Car構造体を作成し、新しく作成した車を1つのステートメントで返すことができます。letまたはreturnキーワードを使用する必要はありません。

3. コードを再構築し、エラーなしでコンパイルされることを確認します。

関数を呼び出す

これで、関数を呼び出して車を作成する準備が整いました。

  1. main既存のコードに関数を追加します。新しいコードは、ファイルの上部または下部に追加できます。
fn main() {
    // We have orders for three new cars!
    // We'll declare a mutable car variable and reuse it for all the cars
    let mut car = car_factory(String::from("Red"), Transmission::Manual, false);
    println!("Car 1 = {}, {:?} transmission, convertible: {}, mileage: {}", car.color, car.transmission, car.convertible, car.mileage);

    car = car_factory(String::from("Silver"), Transmission::Automatic, true);
    println!("Car 2 = {}, {:?} transmission, convertible: {}, mileage: {}", car.color, car.transmission, car.convertible, car.mileage);

    car = car_factory(String::from("Yellow"), Transmission::SemiAuto, false);
    println!("Car 3 = {}, {:?} transmission, convertible: {}, mileage: {}", car.color, car.transmission, car.convertible, car.mileage);    
}

2. コードを再構築します。宣言されたすべての項目が使用されるようになったため、コンパイラーはエラーや警告を発行しないはずです。次の出力が表示されます。

Car 1 = Red, Manual transmission, convertible: false, mileage: 0
Car 2 = Silver, Automatic transmission, convertible: true, mileage: 0
Car 3 = Yellow, SemiAuto transmission, convertible: false, mileage: 0

解決

あなたはこの中に調製した溶液を使用してコードを比較することができ錆遊び場。

概要

このモジュールでは、Rustプログラムの基本構造を確認しました。このmain関数は、すべてのRustプログラムへのエントリポイントです。println!マクロ変数の値および表示プログラムの進行状況を表示するために使用することができます。変数はletキーワードで定義されます。それらの値は、mutキーワードを使用して不変または可変(変更可能)として宣言できます。

多くのプライマリおよび複合データ型を含む、コアRust言語の概念を調査しました。整数と浮動小数点数、文字とテキスト文字列、およびブール値のtrue / false値の操作方法を学習しました。Rust言語は、データ型を厳密に解釈します。プログラムは、データ型が正しく定義および使用されている場合にのみ、正常にコンパイルおよび実行されます。

演習では、structとに格納されているデータを使用して自動車を作成する関数を作成しましたenum。todo!サンプルプログラムでマクロのインスタンスを探し、コードを完成させました。Rustプレイグラウンドを使用して、コードを変更し、プログラムをコンパイルして、実行可能ファイルを実行しました。

このラーニングパスの次のモジュールでは、Rustデータ型の詳細と、プログラムでif / else条件式を使用する方法について説明します。

リンク: https://docs.microsoft.com/en-us/learn/modules/rust-create-program/

#Beginners #rust 

【Rust入門】最初のRustプログラムを作成する

【初心者必見!】Rust言語とは?

Rustプログラミング言語を使用すると、信頼性が高く効率的なシステムソフトウェアを構築できます。開発者は、Webサーバー、メールサーバー、WebブラウザーなどのネットワークソフトウェアにRustを使用します。Rustは、コンパイラとインタプリタ、仮想化とソフトウェアコンテナ、データベース、オペレーティングシステム、および暗号化にも存在します。Rustを使用して、ゲーム、コマンドラインプログラム、Webアセンブリプログラム、および組み込みデバイス用のアプリケーションを構築できます。

Rustは、CやC ++などの既存のシステムソフトウェア言語の安全な代替手段です。CやC ++と同様に、Rustには大きなランタイムやガベージコレクターがないため、他のほとんどすべての現代言語とは対照的です。ただし、CやC ++とは異なり、Rustはメモリの安全性を保証します。Rustは、CおよびC ++で見られる可能性のあるメモリの誤った使用に関連するバグの多くを防ぎます。

Rustは、パフォーマンス、安全性、および実装表現の間で独自のバランスを取ります。プログラミングのバックグラウンドが何であれ、Rustには何か提供できるものがあることに気付くでしょう。

Rustを学ぶための最良の方法は何ですか?

Rustコードを生産的に作成するには、Rustに少し理論的な知識が必要です。開発を開始する前に、このコースまたは他のRust学習リソースに必ず従ってください。言語の基本的な理解に達したら、可能な限りコードを書く練習をしてください。このモジュールの演習とこの学習パスの他の演習と一緒に入力します。

まず、言語の小さな基本的な概念を学ぶことから始めます。次に、練習問題と探索を使用して基盤を構築します。途中でいくつかのプロジェクトを作成し、レッスンの終わりまでに、言語をしっかりと理解できるようになります。

学習目標

このモジュールでは、次のことを学びます。

  • Rustのユニークな機能のいくつか
  • 開発者が他のプログラミング言語よりもRustを選択する理由
  • Rustプログラムをビルド、コンパイル、実行するための基本的なコンポーネントとツール
  • Rustプレイグラウンドをお試しください

Rustとは何ですか?

Rustは、効率的で安全なソフトウェアを開発するために使用できるオープンソースのシステムプログラミング言語です。Rustを使用すると、メモリを管理したり、その他の低レベルの詳細を制御したりできます。ただし、反復やインターフェースなどの高レベルの概念を利用することもできます。これらの機能により、RustはCやC ++などの低水準言語とは一線を画しています。

Rustには、さまざまなアプリケーションに最適な次の利点もあります。

  • 型安全性:コンパイラーは、間違った型の変数に操作が適用されないことを保証します。
  • メモリセーフ: Rustポインタ(参照と呼ばれます)は常に有効なメモリを参照します。
  • データ競合なし: Rustの借用チェッカーは、プログラムの複数の部分が同時に同じ値を変更できないようにすることで、スレッドセーフを保証します。
  • ゼロコストの抽象化: Rustを使用すると、パフォーマンスコストを最小限に抑えながら、反復、インターフェイス、関数型プログラミングなどの高レベルの概念を使用できます。基礎となるコードを手作業で記述したかのように、抽象化も同様に機能します。
  • 最小限のランタイム: Rustには非常に最小限のオプションのランタイムがあります。この言語には、メモリを効率的に管理するためのガベージコレクタもありません。このように、RustはCやC ++などの言語に最もよく似ています。
  • ベアメタルをターゲットにする: Rustは、組み込みおよび「ベアメタル」プログラミングをターゲットにできるため、オペレーティングシステムのカーネルまたはデバイスドライバーの作成に適しています。

よると、スタックオーバーフローの開発調査2021年の、錆は、行の数年間、最も愛された言語となっています。開発者はRustでプログラミングを楽しんでいます!新興企業から大企業まで、多くの種類の組織が独自のユースケースにRustを使用しています。ツールの構築から、Webアプリの作成、サーバーでの作業、組み込みシステムの作成まで、可能性は無限大です。

Rustのユニークな機能

プログラミング言語がプロジェクトに適しているかどうかを判断するには、機能と制限を知る必要があります。次に、可能な言語を比較して、最適な言語を選択できます。

この単元では、Rustの機能と制限のいくつかを確認します。

  • Rustモジュールシステム:モジュール、木枠、およびパス
  • Rust標準ライブラリとサードパーティのクレート
  • RustCargoツールと依存関係マネージャー
  • Rustを使用するタイミング

Rustモジュールシステムでコードを管理する

Rustは、コードの管理と整理に役立つ機能のコレクションを提供します。これらの機能は「Rustモジュールシステム」と呼ばれます。システムは、クレート、モジュール、パス、およびそれらのアイテムを操作するためのツールで構成されています。

クレート:Rustクレートはコンパイルユニットです。これは、Rustコンパイラが実行できる最小のコードです。クレート内のコードは、バイナリ実行可能ファイルまたはライブラリを作成するために一緒にコンパイルされます。Rustでは、クレートのみが再利用可能なユニットとしてコンパイルされます。クレートには、暗黙の名前のないトップレベルモジュールを含むRustモジュールの階層が含まれています。

モジュール:Rustモジュールは、クレート内の個々のコードアイテムのスコープを管理できるようにすることで、プログラムを整理するのに役立ちます。関連するコードアイテムまたは一緒に使用されるアイテムは、同じモジュールにグループ化できます。再帰的なコード定義は、他のモジュールにまたがることができます。

パス:Rustでは、パスを使用してコード内のアイテムに名前を付けることができます。たとえば、パスは、ベクトル、コード関数、さらにはモジュールなどのデータ定義にすることができます。モジュール機能は、パスのプライバシーを制御するのにも役立ちます。パブリックにアクセスできるコードの部分とプライベートにアクセスできる部分を指定できます。この機能を使用すると、実装の詳細を非表示にできます。

Rustクレートとライブラリを使用する

Rust標準ライブラリにstdは、Rustプログラムの基本的な定義と操作のための再利用可能なコードが含まれています。このライブラリには、Stringやなどのコアデータ型の定義、Vec<T>Rustプリミティブの操作、一般的に使用されるマクロ関数のコード、入力アクションと出力アクションのサポート、およびその他の多くの機能領域があります。

Rustプログラムで使用できるライブラリとサードパーティのクレートは数万あり、そのほとんどはRustのサードパーティのクレートリポジトリcrates.ioからアクセスできます。プロジェクトからこれらのクレートにアクセスする方法については後で学習しますが、今のところ、プログラミング演習で使用されるいくつかのクレートを次に示します。

  • std -Rust標準ライブラリ。Rustの演習では、次のモジュールに気付くでしょう。
    • std :: collections-などのコレクションタイプの定義HashMap。
    • std :: env-環境を操作するための関数。
    • std :: fmt-出力フォーマットを制御する機能。
    • std :: fs-ファイルシステムを操作するための関数。
    • std :: io-入出力を操作するための定義と機能。
    • std :: path-ファイルシステムパスデータの操作をサポートする定義と関数。
  • structopt-コマンドライン引数を簡単に解析するためのサードパーティのクレート。
  • クロノ-日付と時刻のデータを処理するサードパーティのクレート。
  • regex-正規表現を処理するサードパーティのクレート。
  • serde -Rustデータ構造のシリアル化および逆シリアル化操作のサードパーティクレート。

デフォルトでは、stdライブラリはすべてのRustクレートで使用できます。クレートまたはライブラリ内の再利用可能なコードにアクセスするために、useキーワードを実装します。ではuse、あなたのプログラムの定義や機能にアクセスできるように、キーワード、クレートまたはライブラリのコードは、「スコープに持ち込ま」されます。標準ライブラリは、のようにuse、パスを持つステートメントでアクセスstdされuse std::fmtます。他のクレートまたはライブラリには、などの名前でアクセスしますuse regex::Regex。

Cargoでプロジェクトを作成および管理する

Rustコンパイラ(rustc)を直接使用してクレートをビルドすることは可能ですが、ほとんどのプロジェクトでは、RustビルドツールとCargoと呼ばれる依存関係マネージャーを使用します。

貨物はあなたのためにたくさんのことをします:

  • cargo newコマンドを使用して新しいプロジェクトテンプレートを作成します。
  • cargo buildコマンドを使用してプロジェクトをビルドします。
  • cargo runコマンドを使用してプロジェクトをビルドして実行します。
  • cargo testコマンドを使用してプロジェクトをテストします。
  • cargo checkコマンドでプロジェクトタイプを確認します。
  • cargo docコマンドを使用してプロジェクトのドキュメントを作成します。
  • cargo publishコマンドを使用して、ライブラリをcrates.ioに公開します。
  • Cargo.tomlファイルにクレート名を追加して、プロジェクトに依存クレートを追加します。

Rustを使用するタイミング

Rust言語には、プロジェクトに最適な言語を選択する際に考慮すべき多くの長所があります。

  • Rustを使用すると、CおよびC ++と同等の言語で記述されたプログラムとライブラリのパフォーマンスとリソース消費を制御できますが、デフォルトではメモリセーフであり、一般的なバグのクラス全体が排除されます。
  • Rustには豊富な抽象化機能があり、開発者はプログラムの不変条件の多くをコードにエンコードできます。コードは、規則やドキュメントに依存する代わりに、コンパイラーによってチェックされます。この機能は、「コンパイルすれば機能する」という感覚につながることがよくあります。
  • Rustには、コードを構築、テスト、文書化、共有するための組み込みツールと、サードパーティのツールとライブラリの豊富なエコシステムがあります。これらのツールは、依存関係の構築など、一部の言語では困難なタスクをRustで簡単かつ生産的にすることができます。

さびの遊び場


Rustコードを少し試したり、Rustライブラリの定義の構文を確認したりしたい場合があります。また、一部のコードを他のコードとすばやく共有する方法を探しているかもしれません。Rust言語は、Rustプレイグラウンドでこれらのタスクをサポートします。

遊び場は、インターネットで入手できるRust開発用のIDEですhttps://play.rust-lang.org/。誰でも遊び場にアクセスできます。コードを記述してから、同じ環境でコードをコンパイルして実行できます。次のスクリーンショットは、遊び場の環境を示しています。ツールバーの右端にある[構成]メニューには、環境の設定を設定するためのオプションがあります。

基本的なプログラムを示すRustプレイグラウンドのスクリーンショット。

遊び場では、Ruststd標準ライブラリのメソッドと関数にアクセスできます。crates.ioライブラリで最もダウンロードされた上位100のクレートも、それらの依存関係とともに利用できます。

ツールと機能

Rustプレイグラウンドには、いくつかの組み込みツールと開発機能があります。

  • フォーマットコード:Rustfmtツールは、公式のRustスタイルに従うようにコードをフォーマットします。ツールはコードを調整し、要素と演算子の間に推奨されるインデントと間隔を適用します。
  • テストコード:Clippyツールはコードの間違いをチェックします。このツールは、コードに対してlintテストを実行して、エラーと改善すべき領域を見つけます。
  • コードの保存:Rustプレイグラウンドで作業しているときに、コードはブラウザーのローカルストレージに自動的に保存されます。この機能により、特にブラウザウィンドウを閉じた場合に、最新の作業を簡単に復元できます。
  • コードの共有:共有機能は、遊び場のコードに共有可能なGitHubの要点を作成します。このURLを保存して、後でコードにアクセスできます。URLは、特定のコードの要点を遊び場にロードします。

ノート

ブラウザのローカルストレージはシングルトンリソースです。Rustプレイグラウンドに対して複数のブラウザウィンドウを開いていて、各ウィンドウで異なるコードを操作している場合、すべてのウィンドウで最後に保存されたコードのみがローカルストレージに保持されます。

ビルドオプション

Rustプレイグラウンドでコードをビルドして実行するには、いくつかのオプションがあります。

  • 実行:コードをビルドして実行し、出力を表示します。[実行]オプションは、cargo runコマンドを使用する場合と同じです。
  • ビルド:コードをビルドしますが、コードは実行しないでください。ビルドオプションが使用するのと同じであるcargo buildコマンドを。
  • テスト:コードをビルドし、コードに対してすべてのテストを実行します。テストオプションは、使用するのと同じであるcargo testコマンドを。

保護限界

サイトが悪意のある方法で使用されるのを防ぐために、遊び場にはいくつかの制限があります。制限は、サイトがすべてのユーザーに引き続き利用可能であることを保証するのに役立ちます。

  • ネットワーク:プレイグラウンドでコードをコンパイルまたは実行すると、ネットワーク接続が利用できなくなります。
  • メモリ:遊び場は、コードをコンパイルしてビルドされたプログラムを実行するために使用できるメモリを制限します。
  • 実行時間:遊び場は、コードをコンパイルしてビルドされたプログラムを実行するための最大時間を設定します。
  • ディスク:コードをコンパイルしてビルドされたプログラムを実行するために使用できるディスク容量は限られています。

エクササイズ


Rustプレイグラウンドは、小さなプログラムをテストしたり、新しいクレートやライブラリを試したり、他の人とコードを共有したりするのに便利です。この演習では、環境に慣れるために、遊び場で小さなプログラムを作成します。

遊び場でコードを書く

基本的なプログラムのコードを書くことから始めましょう。

Rustプレイグラウンドに接続します。

プレイグラウンドエディタに次のコードを入力します。

さびコピー

 

[ツール] > [ Rustfmt]を選択して、コードをフォーマットします。

Rustプレイグラウンドの[ツール]メニューのスクリーンショット。

このツールは、公式のRustスタイルに従うようにコードを調整します。

Rustプレイグラウンドで再フォーマットされたコードのスクリーンショット。

[ツール] > [クリッピー]を選択して、コードの間違いをチェックします。結果はエディターの下に表示されます。

Clippyツールのスクリーンショットは、Rustプレイグラウンドになります。

サンプルコードを修正するには、「Welcome toRust!」というテキストを引用符で囲みます。

Rustプレイグラウンドの修正コードのスクリーンショット。

遊び場でコードをビルドして実行する

次に、コードをコンパイルしてプログラムを実行します。

プレイグラウンドでコードをビルドして実行する方法を選択するには、UIの上部にある[実行]ドロップダウンメニューを開きます。

Rustプレイグラウンドの[実行]メニューのスクリーンショット。

[実行]を選択して、サンプルプログラムをビルドして実行します。プログラムの出力は、エディターの下に表示されます。

Rustプレイグラウンドで出力されたサンプルプログラムのスクリーンショット。

遊び場でコードを保存して共有する

遊び場で作業していると、コードは自動的にブラウザのストレージに保存されます。ブラウザウィンドウを閉じると、入力したコードが失われる可能性があります。コードを常に利用できるようにするために、共有可能なURLを作成できます。

ツールバーの[共有]機能を選択して、プレイグラウンドのコードのGitHub要点を作成します。

Rustプレイグラウンドで共有機能を使用する方法を示すスクリーンショット。

「遊び場へのパーマリンク」というテキストの横にある紙のアイコンを選択して、コードの共有可能な要点を取得します。

これで、URLを保存して後でコードにアクセスしたり、他の人がコードを表示できるようにURLを共有したりできます。

fn main(){println!(Welcome to Rust!);}

概要

このモジュールでは、Rustプログラミング言語を使用して構築できるアプリケーションの種類について学習しました。Rustは、低レベルと高レベルの両方のタイプの開発に役立ちます。

コードを操作するためにRustコマンドを確認しました。このrustcコマンドは、Rustプログラムの作成とコンパイルに使用されます。

Rust Cargo機能を発見し、コード編成のモジュールシステムについて学びました。Cargoを使用して新しいプロジェクトを作成し、それをビルドして実行します。

Rustの遊び場環境を見て、コードの記述、ビルド、テスト、および実行の方法を学びました。

リンク: https://docs.microsoft.com/en-us/learn/modules/rust-introduction/

#rust #Beginners 

【初心者必見!】Rust言語とは?
Dipesh Malvia

Dipesh Malvia

1633688895

React Higher Order Components Tutorial | ReactJS HOC Pattern | React HOC in 30 Minutes for Beginners

React Higher Order Components Tutorial | ReactJS HOC Pattern | React HOC in 30 Minutes for Beginners

In this video we are going to learn everything about Higher-Order Components in React. HOC is an advanced technique in React JS for reusing components logic. We will understand HOC and why it is required and what problem it solves with the help of a practical example and I will try to make it as simple as possible for you.

 â­ï¸GitHub link for Reference - https://github.com/dmalvia/React_Higher_Order_Component_Example 

⭐️ Support my channel -  https://www.buymeacoffee.com/dipeshmalvia

 ***React Roadmap for Developers in 2021*** 

  • How to Learn React JS ? - https://youtu.be/06yVj8pcO5c 
  • React Fundamentals Project - https://youtu.be/QoJGKwo20is 
  • Learn React Redux with Project - https://youtu.be/0W6i5LYKCSI 
  • What is Redux ? - https://youtu.be/qNjNn9BCWCc 
  • Learn React Redux Thunk with Project - https://youtu.be/JDZRfLGNWdc 
  • Learn CSS GRID Tutorial - https://youtu.be/zs7JzkWixPo 

***Checkout these video to understand better*** 

***More videos*** 

 ***Checkout my Crash courses for get started with web development*** 

🔗 Social Medias 🔗 

⭐️ Tags ⭐️ 

  • React Higher Order Components 
  • React HOC tutorial 
  • Learn HOC in React 
  • Create HOC Component 
  • React HOC For Beginners 

⭐️ Hashtags ⭐️ 

#React #hoc #Beginners#Tutorials 

Disclaimer: It doesn't feel good to have a disclaimer in every video but this is how the world is right now. All videos are for educational purpose and use them wisely. Any video may have a slight mistake, please take decisions based on your research. This video is not forcing anything on you.

https://youtu.be/tsCoBd7xSK8

React Higher Order Components Tutorial | ReactJS HOC Pattern | React HOC in 30 Minutes for Beginners
Shannon  Rippin

Shannon Rippin

1632514020

Promise in Javascript with Real Time Examples

In this tutorial, we will learn the Promise in Javascript with Real Time Examples  in 15 minutes.

Time Line:
00:00 Analogy to explain Promise with real time 
01:35 Create Promise
05:27:Consuming Promise
11:05 Attach Handler to then method
12:16 Promisifying or chaining Promises

 

#javascript  #Beginners   #webdevelopment

 

Promise in Javascript with Real Time Examples
Shannon  Rippin

Shannon Rippin

1632459600

Asynchronous Javascript in 50 Minutes

In this Video, we will see some things we must learn in Javascript concept with Demo. Learn Asynchronous JavaScript -Part 1 (45 Minutes). 

Why it is important?

 How it can be used effectively to handle potentially blocking operations: 

*Synchronous vs Asynchronous JavaScript 

*Handling async operations gracefully using Promises. 

Timeline :
00:00 About the video
00:38 Synchronous vs Asynchronous 
05:35: What is Ajax & how Ajax works
07:00  XMLHttpRequest
19:07 CallbackHell
29:42 Promise
 

#javascript  #Beginners  #ajax  

Asynchronous Javascript in 50 Minutes
Dipesh Malvia

Dipesh Malvia

1632395887

Build React Search Filter And Responsive Image Carousel Slider | React Redux Toolkit Tutorial - 3

Build React Search Filter And Responsive Image Carousel Slider | React Redux Toolkit Tutorial - 3

In this video we are going to enhance our Movie Rating Application with adding two new features to it. We will see how we can build the Search filter using Middleware Thunk in redux toolkit so that we can search for different movies or shows. Another feature we will add is Movie Card Slider or Carousel component. We will use react-slick library and build a responsive movie carousel. 

🔥 Kandi Platform👇 

Kandi is a free platform that helps you to find, review, and download reusable Libraries, Code Snippets, Cloud APIs from over 430 million Knowledge Items. 

https://kandi.openweaver.com/home 

⭐️Build React Redux Movie Rating Application⭐️ 

https://kandi.openweaver.com/collections/starterkits/build-react-redux-movie-rating-appl 

⭐️React Redux Toolkit with Project - Part 1⭐️

 https://youtu.be/EnIRyNT2PMI 

⭐️React Redux Toolkit with Project - Part 2⭐️ 

https://youtu.be/FeYTMsWpgQo 

⭐️GitHub link for Reference⭐️

 https://github.com/dmalvia/React_Redux_ToolKit_Movie_App/tree/feature/filter-carousel 

⭐️ Support my channel⭐️ 

https://www.buymeacoffee.com/dipeshmalvia 

***React Roadmap for Developers in 2021*** 

  • How to Learn React JS ? - https://youtu.be/06yVj8pcO5c 
  • React Fundamentals Project - https://youtu.be/QoJGKwo20is 
  • Learn React Redux with Project - https://youtu.be/0W6i5LYKCSI 
  • What is Redux ? - https://youtu.be/qNjNn9BCWCc 
  • Learn React Redux Thunk with Project - https://youtu.be/JDZRfLGNWdc 
  • Learn CSS GRID Tutorial - https://youtu.be/zs7JzkWixPo 

***Checkout these video to understand better*** 

  • JavaScript ES6 Arrow Functions - https://youtu.be/TgzVxiPdCDU 
  • JavaScript Higher Order Functions & Arrays Methods - https://youtu.be/m2_kagsc3_c 
  • JavaScript ES6 Destructuring - https://youtu.be/rpYg2M2lNAE 

***More videos*** 

  • JSON Crash Course - https://youtu.be/6OhMbf2v_jI 
  • Asynchronous Vs Synchronous Programming - https://youtu.be/oesicy3CcXE 
  • Async JavaScript Callback - https://youtu.be/1zeuvEvw5uw 
  • Async JavaScript Promises Tutorial - https://youtu.be/JvV4Rz2PpzA 

***Checkout my crash courses for get started with web development*** 

  • JavaScript Tutorial For Beginners - https://youtu.be/sptS-bgg8Ro 
  • HTML5 Crash Course in 1 Hour - https://youtu.be/Aj3QFsmsagc 
  • CSS Crash Course in 1 Hour - https://youtu.be/nYsk_U_A_lc 

🔗 Social Medias 🔗 

  • Twitter: https://twitter.com/IMDmalvia 
  • Facebook: https://www.facebook.com/programmingwithdipesh 
  • Instagram: https://www.instagram.com/dipeshmalvia 
  • LinkedIn: https://www.linkedin.com/in/dmalvia/ 

⭐️ Tags ⭐️ 

  • React Redux Toolkit 
  • React Redux Toolkit Tutorial 
  • React Redux Toolkit Crash course 
  • React Redux Toolkit Project 
  • React Redux For Beginners 

⭐️ Hashtags ⭐️ 

#React #Redux #Toolkit #Beginners#Tutorials 

Disclaimer: It doesn't feel good to have a disclaimer in every video but this is how the world is right now. All videos are for educational purpose and use them wisely. Any video may have a slight mistake, please take decisions based on your research. This video is not forcing anything on you.

https://youtu.be/VEp9dW0MeDA

Build React Search Filter And Responsive Image Carousel Slider | React Redux Toolkit Tutorial - 3
Dipesh Malvia

Dipesh Malvia

1631789409

React Redux Toolkit with Project | Redux Middleware Thunk | React Redux Tutorial For Beginners - 2

React Redux Toolkit with Project | Redux Middleware Thunk | React Redux Tutorial For Beginners - 2

In this video we are going to learn about React - Redux using Redux toolkit by build a project movie rating application from scratch. This video course is specially if you are planning to learn React with Redux Toolkit State Management library as a beginner. We will build a movie rating application and along with that we will use Axios for API calls, React Router DOM for Routing and Node-SASS for our SCSS compile to CSS. 

We will continue to enhance the application we will see how we can convert a synchronous action creator into a asynchronous action creator using Redux Middleware Thunk. 

You will find the topics covered in the timestamp below. 

⭐️React Redux Toolkit with Project - Part 1 - https://youtu.be/EnIRyNT2PMI 

⭐️GitHub link for Reference - https://github.com/dmalvia/React_Redux_ToolKit_Movie_App 

⭐️OMDB API - https://www.omdbapi.com/ 

⭐️ Support my channel - https://www.buymeacoffee.com/dipeshmalvia

 ***React Roadmap for Developers in 2021*** 

  • How to Learn React JS ? - https://youtu.be/06yVj8pcO5c 
  • React Fundamentals Project - https://youtu.be/QoJGKwo20is 
  • Learn React Redux with Project - https://youtu.be/0W6i5LYKCSI 
  • What is Redux ? - https://youtu.be/qNjNn9BCWCc 
  • Learn React Redux Thunk with Project - https://youtu.be/JDZRfLGNWdc 
  • Learn CSS GRID Tutorial - https://youtu.be/zs7JzkWixPo 

***Checkout these video to understand better*** 

  • JavaScript ES6 Arrow Functions - https://youtu.be/TgzVxiPdCDU 
  • JavaScript Higher Order Functions & Arrays Methods - https://youtu.be/m2_kagsc3_c 
  • JavaScript ES6 Destructuring - https://youtu.be/rpYg2M2lNAE 

🔥 Video contents... ENJOY 👇

  •  0:00:00 - Intro 
  • 0:00:24 - Application Demo 
  • 0:02:23 - Unacademy Promo 
  • 0:05:00 - Code Walkthrough Sync Action Creators 
  • 0:05:30 - Redux Middleware Thunk - Redux Toolkit 
  • 0:06:36 - Create Async Action Creator 
  • 0:08:57 - Create extraReducers 
  • 0:09:22 - Async Action Creator Lifecycle 
  • 0:13:41 - Async Action - Fetch Shows 
  • 0:15:53 - Add Shows to Movie Listing Component 
  • 0:18:57 - Add CSS Transition 
  • 0:20:13 - Navigation - Movie Detail Component 
  • 0:23:19 - Async Action - Fetch Movie Details 
  • 0:25:49 - useParams Hook 
  • 0:30:00 - Movie Detail Component with SCSS 
  • 0:42:10 - UseEffect Cleanup Function 
  • 0:43:00 - Sync Action - Remove Selected Movie/Show 
  • 0:45:04 - Conditional Movie Detail Loading 
  • 0:47:33 - Outro 

***More videos*** 

  • JSON Crash Course - https://youtu.be/6OhMbf2v_jI 
  • Asynchronous Vs Synchronous Programming - https://youtu.be/oesicy3CcXE 
  • Async JavaScript Callback - https://youtu.be/1zeuvEvw5uw 
  • Async JavaScript Promises Tutorial - https://youtu.be/JvV4Rz2PpzA 

***Checkout my crash courses for get started with web development*** 

  •  HTML5 Crash Course in 1 Hour - https://youtu.be/Aj3QFsmsagc 
  • CSS Crash Course in 1 Hour - https://youtu.be/nYsk_U_A_lc 
  • JavaScript Tutorial for Beginners - https://youtu.be/sptS-bgg8Ro

🔗 Social Medias 🔗 

  • Twitter: https://twitter.com/IMDmalvia 
  • Facebook: https://www.facebook.com/programmingwithdipesh 
  • Instagram: https://www.instagram.com/dipeshmalvia 
  • LinkedIn: https://www.linkedin.com/in/dmalvia/ 

⭐️ Tags ⭐️ 

  • React Redux Toolkit 
  • React Redux Toolkit Tutorial 
  • React Redux Toolkit Crash course 
  • React Redux Toolkit Project
  •  React Redux For Beginners 

⭐️ Hashtags ⭐️ 

#React #Redux #Toolkit #Beginners#Tutorials 

Disclaimer: It doesn't feel good to have a disclaimer in every video but this is how the world is right now. All videos are for educational purpose and use them wisely. Any video may have a slight mistake, please take decisions based on your research. This video is not forcing anything on you.

React Redux Toolkit with Project | Redux Middleware Thunk | React Redux Tutorial For Beginners - 2

YouTube

I have explained Class & related concepts of it detail that beginners can easily understand. 

Here is Timeline : 

00:00 Introduction to Video 

00:20 What is Class? 

00:42 Create First Class 

04:07 What is Object & Create it 

07:27 Setter 

11:14 Static Members 

12:35 Getter 

13:36 Calculator Assignment 
#java #Beginners #methods 

https://youtu.be/cdFGLzHLoTM