러스트 공식 가이드 3장 정리

fn main() {
    let x = 5;
    println!("The value of x is: {}", x);
    x = 6;
    println!("The value of x is: {}", x);
}

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
error[E0384]: cannot assign twice to immutable variable `x`
 --> src/main.rs:4:5
  |
2 |     let x = 5;
  |         -
  |         |
  |         first assignment to `x`
  |         help: consider making this binding mutable: `mut x`
3 |     println!("The value of x is: {x}");
4 |     x = 6;
  |     ^^^^^ cannot assign twice to immutable variable

For more information about this error, try `rustc --explain E0384`.
error: could not compile `variables` due to previous error

const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;

fn main() {
    let x = 5;

    let x = x + 1;

    {
        let x = x * 2;
        println!("The value of x in the inner scope is: {x}");
    }

    println!("The value of x is: {x}");
}

The value of x in the inner scope is: 12
The value of x is: 6

let spaces = "   ";
let spaces = spaces.len();

let guess: u32 = "42".parse().expect("Not a number!");

use std::num::Wrapping;

fn main() {
    let x = Wrapping(0u8);
    let y = Wrapping(1u8);
    let z = x - y;
    println!("{:?}", z);
}

fn main() {
    let sum = 5 + 10;
    let difference = 95.5 - 4.3;
    let product = 4 * 30;
    let quotient = 56.7 / 32.2;
    let remainder = 43 % 5;
}

fn main() {
    let heart_eyed_cat = '😻'; // 가능!
}

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
}

fn main() {
    let tup = (500, 6.4, 1);

    let (x, y, z) = tup; // 디스트럭처링 가능

    println!("The value of y is: {y}");
}

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);

    let five_hundred = x.0; // 인덱스로 접근가능

    let six_point_four = x.1;

    let one = x.2;
}

fn main() {
    let a = [1, 2, 3, 4, 5];
}

fn main() {
    let a = [1, 2, 3, 4, 5];
    let a = [3; 5]; // [3, 3, 3, 3, 3]

    let first = a[0];
    let second = a[1];
}

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

    another_function();
}

fn another_function() {
    println!("Another function.");
}



```rust
fn main() {
    another_function(5, 6);
}

fn another_function(x: i32, y: i32) {
    println!("The value of x is: {x}");
    println!("The value of y is: {y}");
}

fn main() {
    let number = 3;

    if number < 5 {
        println!("condition was true");
    } else {
        println!("condition was false");
    }

    let condition = true;
    let number = if condition { 5 } else { 6 };

    println!("The value of number is: {number}");
}

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2;
        }
    };

    println!("The result is {result}");
}

'outer: loop {
    println!("Entered the outer loop");

    'inner: loop {
        println!("Entered the inner loop");

        break 'outer;
    }

    println!("This point will never be reached");
}

fn main() {
    let mut counter = 0;

    let result = 'outer: loop {
        println!("Entered the outer loop");

        'inner: loop {
            println!("Entered the inner loop");

            counter += 1;

            if counter == 10 {
                break 'outer counter * 2;
            }
        }
    };

    println!("The result is {result}");
}

fn main() {
    let mut number = 3;

    while number != 0 {
        println!("{number}");

        number -= 1;
    }

    println!("LIFTOFF!!!");
}

fn main() {
    let a = [10, 20, 30, 40, 50];
    let mut index = 0;

    while index < 5 {
        println!("{a[index]}");

        index += 1;
    }
}

fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a.iter() {
        println!("{element}");
    }
}

fn main() {
    for number in (1..4).rev() { // .rev()는 역순으로 순회한다.
       println!("{number}");
    }
    println!("LIFTOFF!!!");
}

public interface Iterator<T> {
    boolean hasNext();
    T next();
}

public class MyIterator<T> implements Iterator<T>, Iterable<T> {
    private T[] elements;
    private int index = 0;

    public MyIterator(T[] elements) {
        this.elements = elements;
    }

    @Override
    public boolean hasNext() {
        return index < elements.length;
    }

    @Override
    public T next() {
        return elements[index++];
    }

    @Override
    public Iterator<T> iterator() {
        return this;
    }
}

public class Main {
    public static void main(String[] args) {
        Integer[] elements = {1, 2, 3, 4, 5};
        MyIterator<Integer> iterator = new MyIterator<>(elements);

        for (Integer element : iterator) {
            System.out.println(element);
        }
    }
}

function MyIterator(elements) {
    this.elements = elements;
    this.index = 0;
}


MyIterator.prototype.next = function() {
    return this.elements[this.index++];
}

MyIterator.prototype.hasNext = function() {
    return this.index < this.elements.length;
}

MyIterator.prototype[Symbol.iterator] = function() {
    return this;
}

const elements = [1, 2, 3, 4, 5];

const iterator = new MyIterator(elements);

for (const element of iterator) {
    console.log(element);
}