728x90

나는 java 언어를 주로 다루는 백엔드 개발자 이다. 그냥 개발자이다. 백기선 님 , 김영한 님 이런 유명 개발자가 아닌 그냥 똥 개발자이다. 그럼에도 불구하고 직렬화 와 역질렬화에 대한 개발기초 지식은 있으니 이 글을 읽는 개발자 분들도 어느정도 알거라 믿고 닥치고 RUST 에서 직렬화 , 역질화 다루는 법을 알아보자.

Serde 란?

Serde는 Rust 데이터 구조를 직렬화 및 역직렬화하는 라이브러리입니다. 이는 JSON, BSON, YAML 등 다양한 형식을 지원하며, 직렬화 및 역직렬화 방법을 사용자 정의할 수 있습니다. Serde는 간결하고 사용하기 쉬우며 효율적인 성능을 가지고 있어 Rust 생태계에서 가장 인기있는 직렬화 라이브러리 중 하나입니다.

기본 사용법

  • 설치

Rust 프로젝트에서 Serde를 사용하려면 Cargo.toml 파일에 다음 종속성을 추가해야 합니다.

[dependencies]
serde = { version = "1.0", features = ["derive"] }

여기서 features = ["derive"]는 Serde의 파생 매크로를 사용하며, 직렬화 및 역직렬화 코드를 자동으로 생성할 수 있습니다.

  • 직렬화

Serde를 사용하여 직렬화하려면 먼저 데이터 구조를 serde::Serialize trait로 구현해야 합니다. 예를 들어, 이름과 나이 두 가지 필드를 포함하는 Animal 구조체를 정의합니다.

#[derive(Serialize)]
struct Animal {
name: String,
age: u32,
}

그런 다음 serde_json 라이브러리를 사용하여 Animal 구조체를 JSON 문자열로 직렬화할 수 있습니다.

use serde_json;
let animal = Animal {
name: "Tom".to_owned(),
age: 3,
};
let json = serde_json::to_string(&animal).unwrap();
println!("{}", json); // {"name":"Tom","age":3}
  • 역직렬화

Serde를 사용하여 역직렬화하려면 먼저 데이터 구조를 serde::Deserialize trait로 구현해야 합니다. 예를 들어, 이름과 나이 두 가지 필드를 포함하는 Animal 구조체를 정의합니다.

#[derive(Deserialize)]
struct Animal {
name: String,
age: u32,
}

그런 다음 serde_json 라이브러리를 사용하여 JSON 문자열을 Animal 구조체로 역직렬화할 수 있습니다.

use serde_json;
let json = r#"{"name":"Tom","age":3}"#;
let animal: Animal = serde_json::from_str(json).unwrap();
println!("{:?}", animal); // Animal { name: "Tom", age: 3 }

직렬화 및 역직렬화를 사용자 정의하는 방법을 보여주는 Rust 코드입니다.

use serde::{Serialize, Deserialize, Serializer, Deserializer};

#[derive(Serialize, Deserialize)]
struct Animal {
    #[serde(serialize_with = "serialize_name", deserialize_with = "deserialize_name")]
    name: String,
    age: u32,
}

fn serialize_name<S>(name: &String, serializer: S) -> Result<S::Ok, S::Error>
where
    S: Serializer,
{
    serializer.serialize_str(&name.to_uppercase())
}

fn deserialize_name<'de, D>(deserializer: D) -> Result<String, D::Error>
where
    D: Deserializer<'de>,
{
    let name = String::deserialize(deserializer)?;
    Ok(name.to_lowercase())
}

위의 Rust 코드는 Animal 구조체를 정의하고 이름(name)과 나이(age) 두 개의 필드를 포함합니다. 하지만 직렬화(Serialization)할 때 이름을 대문자로 변환하고, 역직렬화(Deserialization)할 때 이름을 소문자로 변환하도록 사용자 지정 직렬화 및 역직렬화 방법을 사용하고자 합니다.

Animal 구조체 내에서 #[serde(serialize_with = "serialize_name", deserialize_with = "deserialize_name")]를 사용하여 사용자 지정 직렬화 및 역직렬화 방법을 지정합니다. serialize_name 함수는 이름을 대문자로 변환하고 deserialize_name 함수는 이름을 소문자로 변환합니다.

또한 Serde는 열거형(Enum) 타입의 직렬화 및 역직렬화를 지원합니다. Animal 열거형을 정의하고, 개(Dog)와 고양이(Cat) 두 가지 유형을 포함시킵니다.

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
enum Animal {
    Dog { name: String, age: u32 },
    Cat { name: String, age: u32 },
}

열거형(Enum) 타입을 직렬화 및 역직렬화할 때, #[serde(tag = "type")]를 사용하여 열거형(Enum) 타입의 레이블을 지정해야 합니다. 예를 들어:

use serde_json;

let dog = Animal::Dog { name: "Tom".to_owned(), age: 3 };
let json = serde_json::to_string(&dog).unwrap();
println!("{}", json); // {"type":"Dog","name":"Tom","age":3}

let json = r#"{"type":"Dog","name":"Tom","age":3}"#;
let dog: Animal = serde_json::from_str(json).unwrap();
println!("{:?}", dog); // Dog { name: "Tom", age: 3 }

위 코드는 Animal 열거형의 Dog 타입을 생성하고 이름이 "Tom"이며 나이가 3인 개(Dog)를 만듭니다.

해당 값을 JSON 형식으로 직렬화(serialization)하여 출력합니다. 그리고 다시 JSON 문자열을 역직렬화(deserialization)하여 Animal 열거형의 값을 얻습니다. 이렇게 출력된 결과를 확인해보면, Dog 타입이 생성되고, 이름은 "Tom", 나이는 3인 Animal이 만들어진 것을 확인할 수 있습니다.

Option 타입 직렬화 및 역직렬화

Serde는 Option 타입의 직렬화와 역직렬화를 지원합니다. 예를 들어, Animal 구조체를 정의할 때, name 필드는 None일 수 있습니다.

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct Animal {
    name: Option<String>,
    age: u32,
}

Option 값을 직렬화하려면, skip_serializing_if 속성을 사용하여 None일 때 해당 값을 생략하도록 지정해야 합니다.

use serde_json;

let animal = Animal { name: Some("Tom".to_owned()), age: 3 };
let json = serde_json::to_string(&animal).unwrap();
println!("{}", json); // {"name":"Tom","age":3}

let animal = Animal { name: None, age: 3 };
let json = serde_json::to_string(&animal).unwrap();
println!("{}", json); // {"age":3}

Vec 타입 직렬화 및 역직렬화

Serde는 Vec 타입의 직렬화와 역직렬화를 자동으로 처리합니다. 예를 들어, Zoo 구조체를 정의할 때, 여러 개의 Animal이 포함될 수 있습니다.

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct Zoo {
    animals: Vec<Animal>,
}
  • Vec 값을 직렬화하려면, serde_json::to_string 함수를 호출하면 됩니다.
let zoo = Zoo { animals: vec![
    Animal { name: "Tom".to_owned(), age: 3 },
    Animal { name: "Jerry".to_owned(), age: 2 },
] };
let json = serde_json::to_string(&zoo).unwrap();
println!("{}", json); // {"animals":[{"name":"Tom","age":3},{"name":"Jerry","age":2}]}
  • Vec 값을 역직렬화하려면, serde_json::from_str 함수를 호출하면 됩니다.
let json = r#"{"animals":[{"name":"Tom","age":3},{"name":"Jerry","age":2}]}"#;
let zoo: Zoo = serde_json::from_str(json).unwrap();
println!("{:?}", zoo); // Zoo { animals: [Animal { name: "Tom", age: 3 }, Animal { name: "Jerry", age: 2 }] }

Serde는 HashMap 타입의 직렬화 및 역직렬화를 지원합니다. 예를 들어, 다음과 같이 HashMap을 사용하여 여러 Animal을 저장하는 Zoo 구조체를 정의할 수 있습니다.

rustCopy code
use std::collections::HashMap;
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct Zoo {
    animals: HashMap<String, Animal>,
}

#[derive(Serialize, Deserialize)]
struct Animal {
    name: String,
    age: u32,
}

HashMap을 포함한 구조체를 직렬화 및 역직렬화 할 때, Serde는 자동으로 처리합니다. 예를 들어 다음과 같이 HashMap에 "Tom"과 "Jerry"라는 두 개의 key-value 쌍을 추가하고, 이 HashMap을 Zoo 구조체에 저장한 다음, 이를 JSON 문자열로 직렬화할 수 있습니다.

use serde_json;
let mut animals = HashMap::new();
animals.insert("Tom".to_owned(), Animal { name: "Tom".to_owned(), age: 3 });
animals.insert("Jerry".to_owned(), Animal { name: "Jerry".to_owned(), age: 2 });

let zoo = Zoo { animals };
let json = serde_json::to_string(&zoo).unwrap();
println!("{}", json); // {"animals":{"Jerry":{"name":"Jerry","age":2},"Tom":{"name":"Tom","age":3}}}

이어서, JSON 문자열을 Zoo 구조체로 역직렬화할 수 있습니다.

let json = r#"{"animals":{"Jerry":{"name":"Jerry","age":2},"Tom":{"name":"Tom","age":3}}}"#;
let zoo: Zoo = serde_json::from_str(json).unwrap();
println!("{:?}", zoo); // Zoo { animals: {"Tom": Animal { name: "Tom", age: 3 }, "Jerry": Animal { name: "Jerry", age: 2 }} }

챕터를 마치며…

이 튜토리얼에서는 Serde를 사용하여 직렬화와 역직렬화하는 방법을 소개하고, 사용자 정의 직렬화 및 역직렬화 로직을 작성하는 방법을 설명합니다. Serde를 사용하면 Rust 데이터 구조를 어떤 형식으로든 쉽게 변환할 수 있으며, 사용자 정의 직렬화 및 역직렬화 로직을 통해 더 고급 기능을 구현할 수 있습니다.


내저장소 바로가기 luxury515

728x90

Cargo는 Rust 언어의 패키지 관리자 및 빌드 도구입니다. 의존성 관리, 프로젝트 빌드, 테스트 실행 및 프로그램 배포 등을 도와줍니다. Rust 커뮤니티에서는 Cargo가 표준 빌드 도구로 자리 잡고 있으며, Rust 개발자에게 큰 편리함을 제공합니다.

Cargo 설치 및 사용법 Rust를 설치할 때 Cargo가 함께 설치됩니다. Rust를 아직 설치하지 않았다면, Rust 입문부터 전문가까지 - Hello World! 시리즈의 첫 번째 편을 참고하거나 공식 웹사이트에서 다운로드하여 설치할 수 있습니다. 설치가 완료되면 다음 명령어를 사용하여 Cargo가 제대로 설치되었는지 확인할 수 있습니다:

cargo --version
# cargo 1.68.0 (115f34552 2023-02-26)

위 명령어를 실행하면 Cargo의 버전이 출력되며, 이는 설치가 성공적으로 이루어졌음을 나타냅니다. 환경 검사가 완료되었으므로, 이제 Cargo를 배우기 시작할 차례입니다. 이전 글에서 사용한 명령어 중 하나는 "cargo new"입니다. 이 명령어는 첫 번째 Rust 프로젝트를 생성했습니다. 이전 글을 보지 않은 독자는 다음 명령어를 실행하여 프로젝트를 만들어 볼 수 있습니다.

cargo new hello_world

위 명령어는 현재 디렉토리에 hello_world라는 새 프로젝트를 생성합니다. hello_world는 프로젝트 이름으로, 필요에 따라 수정할 수 있습니다. 프로젝트를 만든 후, hello_world 디렉토리를 엽니다. 디렉토리 구조는 다음과 같습니다.

/
├── Cargo.lock
├── Cargo.toml
├── crate-information.json
├── src/
│   ├── main.rs
└── target/
└── tools/

Cargo가 생성한 가장 기본적인 프로젝트 구조로, src 디렉토리(개발 소스 코드 저장), Cargo.toml 파일(프로젝트 메타데이터, 컴파일 빌드, 제3자 라이브러리 종속성 관리 등)을 포함합니다. src 디렉토리에서 main.rs라는 파일을 볼 수 있으며, 이는 Rust 프로그램의 진입점으로 기본적인 main() 메서드를 구현합니다.

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

위의 코드는 main() 함수 안에 println!("Hello, world!"); 라는 매우 간단한 프로그램입니다. 이 프로그램은 명령 프롬프트 창에 "Hello, world!"라는 문장을 출력하는 기능을 합니다. VS Code에서 F5를 누르면 첫 번째 프로그램을 실행할 수 있습니다.

만약 VS Code 시작 구성을 구성하지 않았다면, 프로그램을 실행하기 전에 Cargo가 먼저 build 명령을 사용하여 프로젝트를 빌드하고 실행 가능한 파일을 생성합니다. 이제 cargo 명령어를 하나 더 배워보겠습니다.

cargo build

이 명령은 프로젝트 루트 디렉토리에서 target 디렉토리를 생성하고, 그 안에 빌드 후 생성된 이진 파일이 포함됩니다. 기본적으로 Cargo는 hello_world라는 이름의 이진 파일을 생성합니다.

이진 파일을 생성하지 않고 프로젝트를 컴파일하고 싶을 때는 다음 명령어를 사용합니다.

cargo check

이 명령은 코드가 컴파일될 수 있는지를 확인하지만, 이진 파일을 생성하지 않습니다.

빌드가 완료된 후 다음 명령어를 사용하여 프로그램을 실행할 수 있습니다.

cargo run

이 명령은 프로젝트를 자동으로 빌드하고 실행합니다. 모든 것이 정상적으로 실행된다면, "Hello, world!"와 같은 출력을 볼 수 있을 것입니다.

자주 사용되는 Cargo 명령어들

이전 섹션에서는 Cargo의 new, build, run, check 네 가지 명령어를 사용했었는데, 이 외에도 Cargo는 다양한 명령어를 제공합니다. 그 중에서 가장 자주 사용되는 몇 가지 명령어를 소개하고 주석을 달아보겠습니다.

  • new: 이 명령어는 새로운 Rust 프로젝트를 생성합니다. 프로젝트 이름과 타입(바이너리(bin) 또는 라이브러리(lib)) 두 개의 매개변수가 있으며, 기본적으로 이 명령어는 바이너리(bin) 프로젝트를 생성합니다.
  • init: 이 명령어는 현재 디렉토리를 Rust 프로젝트로 초기화합니다. src 디렉토리와 Cargo.toml 파일이 생성됩니다.
  • check: 이 명령어는 코드를 컴파일할 수 있는지 검사하지만, 바이너리 파일은 생성하지 않습니다.
  • build: 이 명령어는 Rust 프로젝트를 컴파일하고 바이너리 파일을 생성합니다. 만약 프로젝트가 이미 컴파일되었다면, build 명령어는 컴파일 과정을 건너뛸 것입니다.
  • run: 이 명령어는 Rust 프로젝트를 컴파일하고 실행합니다. 만약 프로젝트가 이미 컴파일되었다면, run 명령어는 컴파일 과정을 건너뛸 것입니다.
  • test: 이 명령어는 프로젝트 내의 테스트를 실행합니다. 테스트 코드는 보통 src/test.rs나 src/lib.rs 파일에 작성됩니다.
  • bench: 이 명령어는 프로젝트 내의 벤치마크 테스트를 실행합니다. 벤치마크 테스트는 코드의 성능을 테스트하기 위해 사용됩니다.
  • doc: 이 명령어는 프로젝트 문서를 생성합니다. 보통 Rust 내장 문서 도구인 rustdoc을 사용하여 문서를 생성합니다.
  • clean: 이 명령어는 프로젝트 빌드 파일과 생성된 바이너리 파일을 모두 삭제합니다.
  • update: 이 명령어는 프로젝트 내의 의존성을 업데이트합니다.
  • publish: 이 명령어는 프로젝트를 crates.io에 배포하여 다른 사람들이 사용할 수 있게 합니다.
더 많은 명령어는 cargo --help 또는 cargo <command> --help로 확인할 수 있습니다.

사용자 정의 확장 명령어

의존성 관리 Rust 프로젝트에서는 Cargo를 사용하여 의존성을 관리할 수 있습니다

이어서, 우리는 Cargo를 사용하여 종속성을 관리할 수 있습니다. Cargo.toml 파일을 편집하여 종속성을 추가할 수 있습니다.

예를 들어, 우리가 rand 라이브러리를 사용하여 난수를 생성하려고 한다면, 다음과 같은 내용을 Cargo.toml 파일에 추가할 수 있습니다:

[dependencies]
rand = "0.8.4"

이 명령어는 Cargo에게 rand 라이브러리를 사용하려고 한다는 것을 알리며, 버전 0.8.4를 사용하고자 한다는 것을 지정합니다. 파일을 저장한 후, 다음 명령을 사용하여 종속성을 설치할 수 있습니다:

cargo build

이 명령은 종속성을 자동으로 다운로드하고 설치합니다. 종속성을 사용할 때는, main.rs 파일에 다음과 같은 문장을 추가해야 합니다:

use rand::Rng;
fn main() {
let mut rng = rand::thread_rng();
let n: u8 = rng.gen();
println!("Random number: {}", n);
}

여기서 우리는 rand 라이브러리의 Rng 트레이트와 thread_rng 함수를 사용하여 난수를 생성합니다.

버전 관리

위의 예제에서는 0.8.4 버전의 rand 라이브러리 의존성을 지정하고, 명령 프롬프트에서 무작위 숫자를 출력했습니다. 이번에는 의존성 관리를 더 자세히 배워봅시다.

특정 버전을 지정하는 것 외에도, 논리 연산자를 사용하여 버전 범위를 제어할 수 있습니다. 아래는 구체적인 예시입니다.

=: 특정 버전과 동일합니다. 버전 번호를 직접 입력하는 것과 같습니다.

: 특정 버전보다 높은 버전입니다. <=: 특정 버전보다 작거나 같은 버전입니다. ~: 특정 버전과 비슷합니다. 예를 들어, 1.2.3은 대략 1.2.3과 같으며, 마지막 숫자가 다른 경우에도 허용됩니다. 예를 들어, 1.2.4입니다. ^: 특정 버전과 호환됩니다. 예를 들어, ^1.2.3은 1.2.x 시리즈의 모든 버전과 호환되지만 2.0.0 이상 버전과는 호환되지 않습니다.

예를 들어, 0.7.3 이상 0.8.4 미만 버전의 라이브러리 의존성을 지정하려면 다음과 같이 작성할 수 있습니다.

[dependencies]
rand = ">=0.7.3, <0.8.4"

의존성 항목의 기능 지정

일부 라이브러리는 여러 기능을 제공하여 일부 기능을 활성화하거나 비활성화 할 수 있습니다. 예를 들어, serde 라이브러리는 파생 매크로를 활성화하는 derive 기능을 제공합니다. 의존성 항목의 기능을 지정하려면 다음 구문을 사용할 수 있습니다.

[dependencies]
라이브러리_이름 = { version = "버전", features = ["기능_이름"] }

log는 로그 기록을 위한 라이브러리입니다. 다음은 몇 가지 일반적인 기능과 사용 예시입니다.

  • std: log의 표준 라이브러리 지원을 활성화하여 표준 라이브러리 환경에서 log를 사용할 수 있습니다.
  • env_logger: log의 환경 변수 지원을 활성화하여 환경 변수를 사용하여 로그 출력을 제어할 수 있습니다.
  • log4rs: log4rs 지원을 활성화하여 log4rs 라이브러리를 사용하여 로그 출력을 구성할 수 있습니다.
  • simplelog: simplelog 지원을 활성화합니다. simplelog 라이브러리를 사용하여 로그 출력을 구성할 수 있습니다.

다음은 예제입니다: [dependencies] log = { version = "0.4", features = ["std"] }

[dependencies]
log = { version = "0.4", features = ["std"] }
[dependencies]
log = { version = "0.4", default-features = false }

일부 경우에는 로컬 파일 시스템에 있는 라이브러리를 사용해야 할 수 있습니다. 이를 위해 의존성 경로를 지정할 수 있습니다:

[dependencies]
rand = { path = "../rand" }

이 예제에서는 "../rand" 경로의 "rand" 라이브러리를 지정하고 있습니다. 이는 Cargo 컴파일러에게 우리의 프로젝트가 로컬 파일 시스템에 있는 "rand" 라이브러리를 필요로 함을 알려줍니다. "cargo build" 명령을 실행하면, Cargo는 자동으로 지정된 경로의 "rand" 라이브러리를 컴파일하고 프로젝트에 추가합니다.

로컬 파일 시스템에서 라이브러리를 사용하는 것 외에도, git 저장소에서 라이브러리를 사용할 수 있습니다. 의존성 git 저장소를 지정하려면 다음 구문을 사용할 수 있습니다:

[dependencies]
rand = { git = "https://github.com/rust-lang-nursery/rand.git" }

메타데이터

이전 섹션에서는 Cargo의 품질 관리 및 의존성 관리 기능을 설명했습니다. 이번 섹션에서는 Cargo.toml 파일에서 정의된 프로그램 메타데이터 (예 : 프로그램 이름, 버전, 작성자, 설명 등)를 설명합니다.

makefileCopy code
[package]
##    프로젝트 이름
name = "hello_world"
##    버전
version = "0.1.0"
##    작성자, 여러 명일 경우 쉼표로 구분
authors = ["Your Name <your_email@example.com>"]
##    프로젝트 설명
description = "A hello world program in Rust."
##    Rust 언어 버전, 현재 2015, 2018 및 2021 세 가지 버전을 지원합니다.
edition = "2021"

기본 메타데이터 이외에도, [package.metadata] 아래에서 전용 메타데이터를 사용자 정의할 수 있습니다.

makefileCopy code
[package.metadata]
url = "https://github.com/username/hello-world"
doc = "https://docs.rs/hello-world"
repository = "https://github.com/username/hello-world.git"

결론

이를 통해 Rust 언어의 패키지 관리자 및 빌드 도구인 Cargo를 사용하여 새로운 Rust 프로젝트를 만들고, Rust 프로그램을 작성하고, 프로그램을 빌드하고 실행하며, 의존성을 추가하는 방법을 배웠습니다.


내저장소 바로가기 luxury515

728x90

Rust 란?

라스츠 냐 ? 러스츠냐 ? 그거시 뭐가 중요헌디? 그냥 러스트라고 읽자.

Rust는 Mozilla에서 개발한 시스템 수준 프로그래밍 언어로, 안전성, 병렬성, 성능을 제공하기 위해 만들어졌습니다. 메모리 안전성과 데이터 경합 없음의 특성을 갖추고 있어 고성능 서버 애플리케이션, 운영 체제, 게임 등을 작성하는 데 사용할 수 있습니다.

초보자는 공식 Rust 온라인 편집기 Play Rust Online 을 사용하여 학습할 수 있습니다.

Rust 개발 환경 구축 먼저, Rust 공식 웹 사이트의 다운로드 페이지에서 해당되는 32비트 또는 64비트 설치 파일을 선택하고 다운로드합니다. 저는 64비트 설치 파일을 선택하여 설치했습니다.

혹은 Linux 나 MacOS 는

$ curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh

설치 확인

없데이트 (뭐 이제 방금설치 했는데 업데이트 해라고 ? 아니그런건 아니고 그냥 나중에 업데이트는 이런 명령어로 할수 있다는…^^ )

rustup update

vscode 를 사용예정이면 아래 extension 을 설치 하면 된다.

개발 생산성을 도와주는 플러그인도 설치를 해라. 뭐 개인적인 취향대로 설치하면되지만 추후 더 익숙해지면 선택해서 갈아타면 될것이고, 이번 강좌는 따라하는거라 일단 요거로 통일부탁 합니당.

rust 프로젝트에서 핵심역할을 하는 Cargo.toml 파일일 좀더 이쁘게 보여주여주는 놈. 요것도 주저없이 설치해라.

프로젝트 생성.

vscode 에서 terminal 열고 (기존 react , vue 등 vscode를 좀 다뤄 보신 분이라면 잘 할것임. 아무곳에나 폴더 하나 말들고 `code .` 하면 vscode 가 자동 열림....)

cargo new myproject

아래와 같이 폴더가 생성 된다.

/
├── Cargo.lock
├── Cargo.toml
├── crate-information.json
├── src/
│   ├── main.rs
└── target/
└── tools/

여기서 main.rs 파일을 열고.

개발자라면 누구나 1000 번 정도는 만들어봣을듯한 핼로우월드 를 직접 타이핑해본다. 아님 이걸 그냥 복붙해서 쓰셈.

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

자 이제 두근두근 나의 첫 rust 여행의 문을 열어 제껴보자!

cargo run

더 나아가서 VSCode 설정.

launch.json 파일을 만들고.

{
    "version": "0.2.0",
    "configurations": [
        {
            // VS Code에 표시되는 구성 이름입니다.
            "name": "Debug Rust",
            // Rust 언어의 디버거 유형은 lldb입니다.
            "type": "lldb",
            // Rust 언어의 디버그 요청 유형은 launch입니다.
            "request": "launch",
            // 실행 가능한 파일 경로입니다. target/debug 디렉토리의 실행 가능한 파일까지 지정해야합니다.
            "program": "${workspaceFolder}/target/debug/myproject",
            // 실행 가능한 파일의 인수입니다. 비워 둘 수 있습니다.
            "args": [],
            // 작업 디렉토리입니다. 프로젝트 루트 디렉토리로 지정해야합니다.
            "cwd": "${workspaceFolder}",
            // 디버깅 이전에 수행해야하는 작업입니다. 일반적으로 빌드 작업입니다.
            "preLaunchTask": "cargo build"
        }
    ]
}

VS Code 에서 F5 단축키 로 실행.

결론.

이 튜토리얼에서는 VS Code를 사용하여 Rust 언어 개발 환경을 구축하는 방법을 소개하고 몇 가지 예제 코드 및 구성을 제공합니다. 이 튜토리얼을 통해 독자는 Rust 프로젝트를 생성하는 방법, 코드 작성, 코드 실행 및 디버깅하는 방법을 이해할 수 있습니다.


내저장소 바로가기 luxury515

+ Recent posts