■ 미로를 자동으로 생성하는 방법을 보여준다. ▶ main.rs
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 |
use rand::Rng; const CELL_COUNT : usize = 25; fn main() { let mut random_number_generator = rand::thread_rng(); let mut maze_array = [[0; CELL_COUNT]; CELL_COUNT]; for n in 0..CELL_COUNT { maze_array[n ][0 ] = 1; // 위쪽 벽 maze_array[0 ][n ] = 1; // 왼쪽 벽 maze_array[n ][CELL_COUNT-1] = 1; // 오른쪽 벽 maze_array[CELL_COUNT - 1][n ] = 1; // 아래쪽 벽 } for y in 2..CELL_COUNT - 2 { for x in 2..CELL_COUNT - 2 { if x % 2 == 1 || y % 2 == 1 { continue; } maze_array[y][x] = 1; // 벽 let random_number = random_number_generator.gen_range(0..=3); match random_number { 0 => maze_array[y - 1][x ] = 1, // 상 1 => maze_array[y + 1][x ] = 1, // 하 2 => maze_array[y ][x - 1] = 1, // 좌 3 => maze_array[y ][x + 1] = 1, // 우 _ => {}, } } } let tile_array = [" ", "##"]; for y in 0..CELL_COUNT { for x in 0..CELL_COUNT { print!("{}", tile_array[maze_array[y][x]]); } println!(""); } } |
test_project.zip
■ rand 크레이트를 사용해 난수를 생성하는 방법을 보여준다. ▶ Cargo.toml
|
|
[package] name = "test_project" version = "0.1.0" edition = "2021" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] rand = "0.8.0" |
▶ main.rs
|
|
use rand::Rng; fn main() { let mut random = rand::thread_rng(); for _ in 0..5 { let random_value = random.gen_range(1..=6); println!("{}", random_value); } } |
test_project.zip
■ rand 크레이트를 설치하는 방법을 보여준다. ▶ Cargo.toml
|
|
... [dependencies] rand = "0.8.0" |
■ num-bigint 크레이트를 사용해 큰 수의 거듭제곱을 구하는 방법을 보여준다. ▶ Cargo.toml
|
|
[package] name = "test_project" version = "0.1.0" edition = "2021" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] num-bigint = "0.4" |
▶ main.rs
|
|
use num_bigint::BigInt; fn main() { let value = BigInt::from(1234); println!("{}", value.pow(5678)); } |
test_project.zip
■ num-bigint 크레이트를 설치하는 방법을 보여준다. ▶ Cargo.toml
|
|
... [dependencies] num-bigint = "0.4" |
■ 소수(prime number) 여부를 구하는 방법을 보여준다. ▶ 예제 코드 (RS)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
fn is_prime_number(value: usize) -> bool { for i in 2..value { if value % i == 0 { return false } } return true } fn main() { let result = is_prime_number(7); println!("{}", result); } |
■ 소수(prime number) 100개를 출력하는 방법을 보여준다. ▶ 예제 코드 (RS)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
fn is_prime_number(value : usize) -> bool { for i in 2..value { if value % i == 0 { return false } } return true } fn set_prime_number_array(prime_number_array : &mut[usize; 100]) { let mut value = 2; let mut index = 0; while index < 100 { if is_prime_number(value) { prime_number_array[index] = value; index += 1; } value += 1; } } fn main() { let mut prime_number_array = [0; 100]; set_prime_number_array(&mut prime_number_array); println!("{:?}", prime_number_array); } |
■ 피보나치 수열을 출력하는 방법을 보여준다. ▶ 예제 코드 (RS)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 |
let mut a = 1; let mut b = 1; println!("{}", a); println!("{}", b); for _ in 0..30 { println!("{}", a + b); let temparay_value = a; a = b; b = temparay_value + b; } /* 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 */ |
■ && 연산자의 단축 평가 기능을 사용해 객체 변수가 null/undefined 여부 확인하고 속성을 참조하는 방법을 보여준다. ▶ 예제 코드 (JAVASCRIPT)
|
|
var element = null; // element가 null이거나 undefined와 같은 Falsy 값이면 element로 평가되고 // element가 Truthy 값이면 element.value로 평가된다. var value = element && element.value; console.log(value); // null; |
■ || 연산자의 단축 평가 기능을 사용해 함수 매개 변수에 기본값을 설정하는 방법을 보여준다. ▶ 예제 코드 (JAVASCRIPT)
|
|
function getStringLength(source) { source = source || ""; return source.length; } console.log(getStringLength()); // 0 console.log(getStringLength("테스트")); // 3 |
■ || 연산자의 단축 평가 기능을 사용해 if문을 대체하는 방법을 보여준다. ▶ 예제 코드 (JAVASCRIPT)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
var done1 = false; var message1 = ""; // done1이 false라면 message1에 "미완료"를 할당한다. if(!done1) { message1 = "미완료"; } console.log(message1); // if문은 단축 평가로 대체 가능하다. // done2가 false라면 message2에 "미완료"를 할당한다. var done2 = false; var message2 = ""; message2 = done2 || "미완료"; console.log(message2); |
■ 논리 연산자의 단축 평가 기능을 사용하는 방법을 보여준다. ▶ 예제 코드 (JAVASCRIPT)
|
|
// 논리합(||) 연산자 console.log("cat" || "dog"); // "cat" console.log(false || "dog"); // "dog" console.log("cat" || false); // "cat" console.log(true || "dog"); // true console.log("cat" || true ); // "cat" // 논리곱(&&) 연산자 console.log("cat" && "dog"); // "dog" console.log(false && "dog"); // false console.log("cat" && false); // false console.log(true && "dog"); // dog console.log("cat" && true ); // true |
■ && 연산자의 단축 평가 기능을 사용해 if문을 대체하는 방법을 보여준다. ▶ 예제 코드 (JAVASCRIPT)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
var done1 = true; var message1 = ""; // done1이 true라면 message1에 "완료"를 할당한다. if(done1) { message1 = "완료"; } console.log(message1); // if문은 단축 평가로 대체 가능하다. // done2가 true라면 message2에 "완료"를 할당한다. var done2 = true; var message2 = ""; message2 = done2 && "완료"; console.log(message2); |
■ 명시적 타입 변환을 사용해 불리언 값을 구하는 방법을 보여준다. ▶ 예제 코드 (JAVASCRIPT)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 |
//////////////////////////////////////////////////////////// // Boolean 생성자 함수를 new 연산자 없이 호출하는 방법 //////////////////////////////////////////////////////////// // 문자열 타입 → 불리언 타입 console.log(Boolean("x" )); // true console.log(Boolean("" )); // false console.log(Boolean("false")); // true // 숫자 → 불리언 타입 console.log(Boolean(0 )); // false console.log(Boolean(1 )); // true console.log(Boolean(NaN )); // false console.log(Boolean(Infinity)); // true // null 타입 → 불리언 타입 console.log(Boolean(null)); // false // undefined 타입 → 불리언 타입 console.log(Boolean(undefined)); // false // 객체 타입 → 불리언 타입 console.log(Boolean({})); // true console.log(Boolean([])); // true //////////////////////////////////////////////////////////// // ! 부정 논리 연산자를 두 번 사용하는 방법 //////////////////////////////////////////////////////////// // 문자열 타입 → 불리언 타입 console.log(!!"x" ); // true console.log(!!"" ); // false console.log(!!"false"); // true // 숫자 → 불리언 타입 console.log(!!0 ); // false console.log(!!1 ); // true console.log(!!NaN ); // false console.log(!!Infinity); // true // null 타입 → 불리언 타입 console.log(!!null); // false // undefined 타입 → 불리언 타입 console.log(!!undefined); // false // 객체 타입 → 불리언 타입 console.log(!!{}); // true; console.log(!![]); // true; |
■ 명시적 타입 변환을 사용해 숫자를 구하는 방법을 보여준다. ▶ 예제 코드 (JAVASCRIPT)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
//////////////////////////////////////////////////////////// // Number 생성자 함수를 new 연산자 없이 호출하는 방법 //////////////////////////////////////////////////////////// // 문자열 타입 → 숫자 타입 console.log(Number("0" )); // 0 console.log(Number("-1" )); // -1 console.log(Number("10.53")); // 10.53 // 불리언 타입 → 숫자 타입 console.log(Number(true )); // 1 console.log(Number(false)); // 0 //////////////////////////////////////////////////////////// // parseInt, parseFloat 함수를 사용하는 방법(문자열만 변환 가능) //////////////////////////////////////////////////////////// // 문자열 타입 → 숫자 타입 console.log(parseInt ("0" )); // 0 console.log(parseInt ("-1" )); // -1 console.log(parseFloat("10.53")); // 10.53 //////////////////////////////////////////////////////////// // + 단항 산술 연산자를 이용하는 방법 //////////////////////////////////////////////////////////// // 문자열 타입 → 숫자 타입 console.log(+"0" ); // 0 console.log(+"-1" ); // -1 console.log(+"10.53"); // 10.53 // 불리언 타입 → 숫자 타입 console.log(+true ); // 1 console.log(+false); // 0 //////////////////////////////////////////////////////////// // * 산술 연산자를 이용하는 방법 //////////////////////////////////////////////////////////// // 문자열 타입 → 숫자 타입 console.log("0" * 1); // 0 console.log("-1" * 1); // -1 console.log("10.53" * 1); // 10.53 // 불리언 타입 → 숫자 타입 console.log(true * 1); // 1 console.log(false * 1); // 0 |
■ 암묵적 타입 변환을 사용해 조건식에서 false 불리언 값을 구하는 방법을 보여준다. ▶ 예제 코드 (JAVASCRIPT)
|
|
if(!false ) console.log(1); // 1 if(!undefined) console.log(2); // 2 if(!null ) console.log(3); // 3 if(!0 ) console.log(4); // 4 if(!-0 ) console.log(5); // 5 if(!"" ) console.log(6); // 6 |
※ false, undefined, null, 0,
더 읽기
■ ! 연산자를 사용해 true/false 여부를 구하는 방법을 보여준다. ▶ 예제 코드 (JAVASCRIPT)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
// false 여부 구하기 // value : 값 // 반환값 : false 여부 function isFalse(value) { return !value; } // true 여부 구하기 // value : 값 // 반환값 : true 여부 function isTrue(value) { return !!value; } console.log(isFalse(false )); // true console.log(isFalse(undefined)); // true console.log(isFalse(null )); // true console.log(isFalse(0 )); // true console.log(isFalse(NaN )); // true console.log(isFalse("" )); // true console.log(isTrue(false )); // false console.log(isTrue(undefined)); // false console.log(isTrue(null )); // false console.log(isTrue(0 )); // false console.log(isTrue(NaN )); // false console.log(isTrue("" )); // false |
■ 암묵적 타입 변환을 사용해 숫자를 구하는 방법을 보여준다. ▶ 예제 코드 (JAVASCRIPT)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
// 문자열 타입 console.log(+""); // 0 console.log(+"0"); // 0 console.log(+"1"); // 1 console.log(+"string"); // NaN // 불리언 타입 console.log(+true); // 1 console.log(+false); // 0 // null 타입 console.log(+null); // 0 // undefined 타입 console.log(+undefined); // NaN // 심벌 타입 //console.log(+Symbol()); // TypeError: Cannot convert a Symbol value to a number // 객체 타입 console.log(+{} ); // NaN console.log(+[] ); // 0 console.log(+[10, 20] ); // NaN console.log(+function(){}); // NaN |
■ Number 인터페이스의 toString 메소드를 사용해 문자열을 구하는 방법을 보여준다. ▶ 예제 코드 (JAVASCRIPT)
|
|
var x = 30; var y = x.toString(); console.log(typeof y, y); // string 30 console.log(typeof x, x); // number 30 |
■ ** 연산자를 사용해 음수를 거듭제곱의 밑으로 사용하는 방법을 보여준다. ▶ 예제 코드 (JAVASCRIPT)
|
|
console.log(-5 ** 2); // SyntaxError가 발생한다. console.log((-5) ** 2); // 25 |
■ Math 인터페이스의 pow 메소드를 사용해 지수 연산을 하는 방법을 보여준다. ▶ 예제 코드 (JAVASCRIPT)
|
|
console.log(Math.pow(2, 2 )); // 4 console.log(Math.pow(2, 2.5)); // 5.65685424949238 console.log(Math.pow(2, 0 )); // 1 console.log(Math.pow(2, -2 )); // 0.25 |
■ ** 연산자를 사용하는 기본적인 방법을 보여준다. ▶ 예제 코드 (JAVASCRIPT)
|
|
console.log(2 ** 2 ); // 4 console.log(2 ** 2.5); // 5.65685424949238 console.log(2 ** 0 ); // 1 console.log(2 ** -2 ); // 0.25 |
■ 쉼표 연산자를 사용하는 기본적인 방법을 보여준다. ▶ 예제 코드 (JAVASCRIPT)
|
|
var x; var y; var z; x = 1, y = 2, z = 3; console.log(x); console.log(y); console.log(z); |
■ 그룹 연산자를 사용하는 기본적인 방법을 보여준다. ▶ 예제 코드 (JAVASCRIPT)
|
|
console.log(10 * 2 + 3); // 23 // 그룹 연산자를 사용해 우선순위를 조절한다. console.log(10 * (2 + 3)); // 50 |
■ 논리 연산자를 사용하는 기본적인 방법을 보여준다. ▶ 예제 코드 (JAVASCRIPT)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
// 논리합(||) 연산자 console.log(true || true ); // true console.log(true || false); // true console.log(false || true ); // true console.log(false || false); // false // 논리곱(&&) 연산자 console.log(true && true ); // true console.log(true && false); // false console.log(false && true ); // false console.log(false && false); // false // 논리 부정(!) 연산자 console.log(!true ); // false console.log(!false); // true // 암묵적 타입 변환 console.log(!0 ); // true console.log(!"Hello"); // false |
