


이것은 Frontend Challenge v24.07.24, Glam Up My Markup: Recreation을 위한 제출입니다.

## 제작한 것

뉴욕 레크리에이션 크리켓 리그를 위한 멋진 사용자 친화적 랜딩 페이지를 개발했습니다. 이 웹사이트는 리그의 정보, 일정 및 장소를 보여줍니다.
(현재는 반응형이 아닙니다)

## 데모

<div class="content-ad"></div>

#### 헤더 섹션

![이미지](/assets/img/2024-07-26-SubmissionforFrontendChallengev240724_0.png)

#### 소개 섹션

![이미지](/assets/img/2024-07-26-SubmissionforFrontendChallengev240724_1.png)

<div class="content-ad"></div>

#### 참여 및 수수료 섹션

![이미지](/assets/img/2024-07-26-SubmissionforFrontendChallengev240724_2.png)

#### 장소 섹션

![이미지](/assets/img/2024-07-26-SubmissionforFrontendChallengev240724_3.png)

<div class="content-ad"></div>

#### 일정 섹션

![일정 이미지](/assets/img/2024-07-26-SubmissionforFrontendChallengev240724_4.png)

#### 푸터 섹션

![푸터 이미지](/assets/img/2024-07-26-SubmissionforFrontendChallengev240724_5.png)

<div class="content-ad"></div>

## 여정

우선, Frontend Challenge를 보았을 때 매우 기쁘게 생각했습니다. 처음 만난 랜딩 페이지였습니다. 그러나 계속 진행하면서 어떤 종류의 사이트를 구축해야 하는지 알기가 어려웠습니다. 그래서 Google을 열고 몇 가지 스포츠 팀의 공식 사이트를 검색했고, 다행히 공식 미국 크리켓 팀 페이지를 찾을 수 있었습니다.

맞닥뜨린 도전과 어떻게 극복했는가?
몇몇 사이트를 보고 난 후에 깨달았는데, 깔끔하게 유지해야 한다는 것이었습니다. 미국 공식 크리켓 팀 사이트에서 나의 색상 팔레트를 얻었고 이것이 유용하게 사용되었습니다.

그런 다음, 다양한 종류의 레이아웃을 사용해보려고 했지만 예정대로 작동하지 않았습니다. 마지막으로, 내 내비게이션 바를 찾을 수 있었지만, 아직 많은 것이 남았기에 웹을 둘러보며 사용할 수 있는 좋은 요소를 찾기 시작했습니다. 수백 개의 사이트를 검색한 후에 나에게 필요한 것을 찾아서 조립했고, 내용을 변경하여 아름답고 간단하지만 효율적인 랜딩 페이지가 완성되었습니다.

<div class="content-ad"></div>

새롭게 배운 것들

- 이번 챌린지에서 멋진 CSS 요소들에 대해 배우고 효율적으로 디자인하는 방법을 배웠어요.
- ChatGPT와 같은 AI를 활용하여 일을 효율적이고 빠르게 처리할 수 있는 방법에 대해 알아보았습니다.
- 프로젝트를 진행하면 튜토리얼보다 훨씬 빠르게 학습할 수 있다는 것을 알게 되었어요.

추가 진행 사항
반응형으로 만들어 가독성을 높이는 것을 시도해보세요.

### 팀 제출

<div class="content-ad"></div>

아니요, 제가 제출한 것이 유일한 것이지만 팀으로 일하는 것에 열려 있습니다.

### 라이선스

이 프로젝트는 MIT 라이선스에 따라 제공됩니다. 따라서 누구나 코드를 사용할 수 있습니다. Github 링크를 확인해주세요.

### 결론

<div class="content-ad"></div>

몇 가지 더 나아질 수 있는 부분이 있음을 알고 있어요. 대회가 끝나기 전에 그 부분을 개선하려고 노력할게요. 전체적으로 이 도전 과제를 수행하는 데 재미있었어요. 
#devchallenge 팀 감사합니다.

프론트엔드 챌린지 v240724 제출 방법




개발자로서 배울 것이 많고, 실제로 중요한 것에 집중하는 것이 매우 중요합니다! 많은 개발자들이 모든 것을 처음부터 만들기를 선호하지만, 때로는 업무량이 많아서 이러한 도구를 사용하면 일이 더 쉬워질 수 있습니다.

이 글에서는 여러분이 뛰어난 생산성을 보일 수 있고 가장 잘하는 일 "멋진 것을 만들기"에 더 능숙해질 수 있는 5가지 도구를 소개하겠습니다.

흥미롭게 들리나요?

더 이상 지체하지 말고, 시작해봅시다!!!

<div class="content-ad"></div>

## 1. Pieces.app - Your Workflow Copilot

![Image](/assets/img/2024-07-26-5ToolsEveryDeveloperShouldUsein2024_0.png)

Pieces는 AI 기술을 활용한 개발자 생산성 도구로, 지능적인 코드 스니펫 관리, 맥락에 맞는 협업 기능, 그리고 유용한 자료를 적극적으로 제공하여 개발자가 업무 혼란을 효과적으로 관리할 수 있도록 설계되었습니다.

이 도구는 완전히 오프라인 AI 접근 방식을 통해 작업의 개인 정보 보안을 유지하면서 개발자의 업무 흐름과 전반적인 개발 경험을 향상시킵니다.

<div class="content-ad"></div>

최근에 Pieces에서 현재 다른 코파일러들이 제공하지 않는 혁신적인 기능을 출시했어요. 하이프가 무엇인지 보려면 빠른 데모를 시청해보세요!

Pieces Copilot+를 사용하면 이전 작업을 정확히 파악한 어시스턴트를 얻을 수 있어요. "제가 마지막으로 검토한 Github Pull Request는 무엇인가요?" 또는 "Sublime에서 마주한 최신 문제를 어떻게 해결하나요?"와 같은 질문에 대답할 수 있어요.

좋아하는 도구와 원활하게 통합되어 코딩 프로세스를 간소화하고 개선될 수 있어요. 몇 가지 멋진 기능이 더 있어요:

✅ 클라우드 및 장치 모델 모두 25개 이상의 LLM 사용

<div class="content-ad"></div>

Pieces에서 사용 가능한 모든 기능 목록을 확인할 수 있어요.

<div class="content-ad"></div>


![Image](/assets/img/2024-07-26-5ToolsEveryDeveloperShouldUsein2024_1.png)

Pieces also offers various language-based SDKs to take advantage of the wide range of functionalities provided by the Pieces OS. I've developed an AI-powered CLI using the Pieces Typescript SDK.

Pieces was recently launched on ProductHunt and was selected as the Product of the Day with over 900 upvotes and 250 comments!

## 2. SuperTokens - Open Source User Authentication


<div class="content-ad"></div>

![이미지](/assets/img/2024-07-26-5ToolsEveryDeveloperShouldUsein2024_2.png)

Supertokens는 사용자 인증 과정을 간단하게 하는 오픈 소스 인증 솔루션입니다.

그들은 보안 전문가뿐만 아니라 모든 사람에게 인증을 더 쉽게 이용할 수 있도록 하고 있으며, 이는 개발자 경험 전체를 처음부터 다시 디자인하는 것을 의미합니다.

Supertokens는 또한 토큰 회전, 세션 관리, 다중 인증 등의 보안 기능을 제공합니다. 이러한 기능들은 귀하의 인증 시스템이 견고하고 안전하다는 것을 보장합니다.

<div class="content-ad"></div>

슈퍼토큰을 설치하고 구성하는 방법에 대한 문서를 읽고 확인할 수 있어요. 그것을 사용하는 가장 좋은 방법이죠.

GitHub에서 12,000개 이상의 별을 받은 것을 보면, 그들은 보다 넓은 커뮤니티 지원과 신뢰를 받고 있다는 것을 나타냅니다.

## 3. Permit.io - 권한부여를 쉽게 만들기

![Image](/assets/img/2024-07-26-5ToolsEveryDeveloperShouldUsein2024_3.png)

<div class="content-ad"></div>

Permit.io는 팀이 응용 프로그램과 서비스에 대한 세밀한 접근 제어를 구현하고 관리하는 데 도움이 되는 오픈 소스 인가 솔루션입니다.

이는 권한을 다루는 데 고생하는 대신 개발자가 핵심 기능에 집중할 수 있도록 권한 로직을 구축하고 유지하는 프로세스를 간소화합니다.

Permit.io는 즐겨 사용하는 개발 도구와 신속하게 통합되어 코딩 프로세스를 개선하고 보안을 강화하는 데 도움을 줍니다.

<img src="/assets/img/2024-07-26-5ToolsEveryDeveloperShouldUsein2024_4.png" />

<div class="content-ad"></div>

안녕하세요! 웹 서비스와 멀티테넌트 시스템을 위한 특히 귀중한 복잡한 권한 규칙을 생성하고 관리할 수 있습니다.

✅ 역할 및 권한을 중앙 위치에서 정의하세요.

✅ 속성 기반 접근 제어(ABAC)를 쉽게 구현하세요.

✅ 사용자 속성 및 컨텍스트에 기반한 동적 정책을 생성하세요.

<div class="content-ad"></div>

✅ 귀하의 전체 시스템에서 권한 정책을 공유하고 동기화하세요.

Permit.io는 JavaScript, Python, Go, Java 등 다양한 프로그래밍 언어용 SDK를 제공하여 기존 코드베이스에 쉽게 통합할 수 있습니다.

![Permit.io](/assets/img/2024-07-26-5ToolsEveryDeveloperShouldUsein2024_5.png)

Permit 스윕트에 최신 추가 기능인 Permit Share-If가 추가되어 접근 제어를 한 단계 높입니다. 이는 애플리케이션에서 접근 공유를 간편화하는 사용 준비가 완료된 UI 구성 요소 컬렉션입니다.

<div class="content-ad"></div>

이러한 구성 요소는 완전한 기능의 액세스 제어를 제공하여 사용자가 권한을 쉽게 관리할 수 있도록 안전하게 합니다.

복잡한 애플리케이션 개발자들에게 매우 편리합니다.

✅ 사용자는 응용 프로그램에서 직접 제한된 리소스 액세스를 요청할 수 있습니다.

✅ 관리자 감독을 위해 내장된 구성 요소를 통해 승인 요청을 제출할 수 있습니다.

<div class="content-ad"></div>

✅ 사용자 친화적 인터페이스를 통해 작업 요청을 승인/거부하세요.

더 많은 정보를 알아보려면 그들의 문서를 살펴보세요.

ProductHunt에서 이제 Live 중입니다. 여기에서 지원해주세요:

## 4. Appwrite - 몇 분만에 백엔드 생성

<div class="content-ad"></div>


![Image](/assets/img/2024-07-26-5ToolsEveryDeveloperShouldUsein2024_6.png)

Appwrite is an open-source backend-as-a-service (BaaS) platform designed to help developers build secure and scalable applications with ease.

Whenever I need to start a full-stack project, Appwrite is my go-to platform for the backend.

Appwrite offers a wide range of features:


<div class="content-ad"></div>

✅ Appwrite의 데이터베이스 서비스는 복잡한 쿼리와 실시간 업데이트를 지원하여 애플리케이션 데이터를 유연하고 강력하게 관리할 수 있는 방법을 제공합니다.

✅ 저장소 서비스를 사용하면 파일을 손쉽게 관리하고 제공할 수 있으며, 파일 업로드, 다운로드 및 변환을 지원합니다.

✅ Appwrite Functions를 사용하면 안전하고 격리된 환경에서 사용자 정의 코드를 실행할 수 있습니다. Appwrite 시스템 이벤트에서 코드를 수동으로 또는 CRON 일정을 사용하여 트리거할 수 있습니다.

Appwrite에서 제공하는 기능 목록을 자세히 살펴볼 수 있습니다.

<div class="content-ad"></div>

이미지 태그를 Markdown 형식으로 변경해주세요.

Appwrite는 당신의 어플리케이션의 백엔드 서비스를 간단하고 직관적인 대시보드를 통해 관리할 수 있도록 해줍니다. 이를 통해 리소스를 감시하고 제어하기 쉬워집니다.

✅ 안전하게 사용자 인증과 권한 부여 관리하기

✅ 데이터베이스 작업을 쉽게 처리하기

<div class="content-ad"></div>

🌟 손쉽게 파일을 저장하고 제공하세요.

🌟 서드파티 서비스 및 API와 통합하세요.

Appwrite는 JavaScript, Python, PHP 등 다양한 프로그래밍 언어를 지원하는 다양한 SDK를 제공하여 기존 프로젝트와 쉽게 통합할 수 있습니다.

Appwrite는 GitHub에서 49,000개 이상의 스타를 받고 있으며 88회 이상의 릴리스로 지속적인 개선을 이어가고 있습니다.

<div class="content-ad"></div>

## 5. 인피시컬 - 비밀 관리 플랫폼

![이미지](/assets/img/2024-07-26-5ToolsEveryDeveloperShouldUsein2024_8.png)

인피시컬은 팀이 API 키, 데이터베이스 자격 증명 및 구성과 같은 비밀을 중앙 집중화하는 데 도움이 되도록 설계된 오픈 소스 비밀 관리 플랫폼입니다.

그들은 보안 팀뿐만 아니라 모든 사람들에게 비밀 관리를 더 접근 가능하게 만들고자 합니다. 이는 전체 개발자 경험을 처음부터 재설계하는 것을 의미합니다.

<div class="content-ad"></div>

테이블 태그를 마크다운 형식으로 변경해 주세요.

<div class="content-ad"></div>


![image](/assets/img/2024-07-26-5ToolsEveryDeveloperShouldUsein2024_9.png)

It also allows you to manage secrets efficiently, ensuring your applications are secure and up-to-date. This is very handy for developers working on both open-source and enterprise projects.

✅ Save parts of your secrets in the app.

✅ Easily access saved secrets.


<div class="content-ad"></div>

✅ CI/CD 파이프라인에 비밀 정보를 통합하세요.

✅ 팀과 안전하게 비밀 정보를 공유하세요.

Infisical은 Node.js, Python, Java 및 .Net용 네 개의 SDK를 제공합니다.

GitHub에서 13,000개 이상의 스타와 155개 이상의 릴리즈를 보유하고 있어 지속적으로 발전하고 있습니다.

<div class="content-ad"></div>

이 글이 유용했기를 바랍니다. 만약 그렇다면, 개발자 친구들과 공유해보세요!

유료 협업을 원하신다면 이메일을 보내주세요: arindammajumder2020@gmail.com

트위터, 링크드인, 유튜브 및 깃허브에서 저와 소통해보세요.

읽어주셔서 감사합니다 : )

<div class="content-ad"></div>


![2024-07-26-5ToolsEveryDeveloperShouldUsein2024_10](/assets/img/2024-07-26-5ToolsEveryDeveloperShouldUsein2024_10.png)


2024년 모든 개발자가 사용해야 할 필수 도구 5가지 정리




각 구성 요소는 생성부터 파괴까지의 라이프 사이클을 가지고 있어요. 서로 다른 라이프 사이클 단계에서 구성 요소는 외부 세계에 메소드를 제공하면서, 구성 요소를 호출하는 개발자가 각 라이프 사이클 단계에서 구성 요소를 보다 유연하게 제어할 수 있도록 도와줘요. 이러한 메소드를 라이프 후크 함수라고 해요.

Svelte의 라이프사이클 후크는 다음과 같아요:

- onMount
- beforeUpdate
- afterUpdate
- onDestroy
- tick

## 호출 시점

<div class="content-ad"></div>

만약 서버 측 렌더링(SSR)을 사용한다면, onDestroy를 제외한 나머지 라이프사이클 함수가 SSR 실행 중에 실행되지 않습니다.

Svelte에서는 라이프사이클 함수를 컴포넌트를 초기화할 때만 작성할 수 있어서, 컴포넌트의 인스턴스에 콜백을 바인딩할 수 있습니다. setTimeout이나 setInterval과 같은 비동기 메서드 내부에 라이프사이클 함수를 배치하지 마세요.

컴포넌트를 초기화할 때 라이프사이클 함수가 호출되도록 해야 하지만, 어디서 호출되었는지는 중요하지 않습니다. 예를 들어, 라이프사이클 함수를 메서드 내부에 넣을 수 있습니다:

```js
// app.js
import { onMount, onDestroy } from 'svelte';

export const startInterval = () => {
  let timer = null;
  let count = 0;

  onMount(() => {
    console.log('onMount');
    timer = setInterval(() => {
      count++;
      console.log('count');
    }, 1000)
  });

  onDestroy(() => {
    console.log('onDestroy');
    if (timer) {
      clearInterval(timer);
    }
  })
}
```

<div class="content-ad"></div>

```js
<script>
  import { startInterval } from './app.js';

  startInterval();
</script>

<div>App</div>
```

이 경우에는 라이프사이클이 구성 요소가 초기화될 때 호출됨을 보장할 수 있습니다.

## onMount

구성 요소가 DOM에 마운트된 직후 바로 실행되는 콜백 함수입니다.

<div class="content-ad"></div>


onMount(callback: () => void)

onMount(callback: () => () => void)


onMount은 콜백 함수를 인수로 받으며, 콜백 함수 내에서 함수가 반환되면 컴포넌트가 언로드 될 때 호출됩니다.

Svelte 프로젝트의 소스 코드를 살펴볼 수 있습니다. 파일 경로는 packages/svelte/src/runtime/internal/Component.js:

```js
/** @returns {void} */
export function mount_component(component, target, anchor) {
  const { fragment, after_update } = component.$$;
  fragment && fragment.m(target, anchor);
  // onMount happens before the initial afterUpdate
  add_render_callback(() => {
    const new_on_destroy = component.$$.on_mount.map(run).filter(is_function);
    // if the component was destroyed immediately
    // it will update the `$$.on_destroy` reference to `null`.
    // the destructured on_destroy may still reference to the old array
    if (component.$$.on_destroy) {
      component.$$.on_destroy.push(...new_on_destroy);
    } else {
      // Edge case - component was destroyed immediately,
      // most likely as a result of a binding initializing
      run_all(new_on_destroy);
    }
    component.$$.on_mount = [];
  });
  after_update.forEach(add_render_callback);
}
```

<div class="content-ad"></div>

우리는 onMount 메서드를 실행하고 값을 가져오는 것을 볼 수 있습니다. 그런 다음 컴포넌트의 onDestroy 라이프사이클 후크에 선언이 있는지 확인하고, 선언이 있다면 onDestroy 배열에 추가한 다음, onDestroy 이후에 이 반환 값을 실행하고, 그렇지 않으면 반환 값을 직접 실행합니다. React에서 useEffect 후크도 동일한 기능을 가지고 있습니다.

```js
useEffect(() => {
  return () => {}
}, []);
```

onMount의 반환값에 대한 Svelte 예제를 따라해봅시다:

```js
<script>
  // Child.svelte
  import { onMount } from 'svelte';

  onMount(() => {
    console.log('child mount');
    return () => {
      console.log('child destroy 1');
    }
  })
</script>

<div>child</div>
```

<div class="content-ad"></div>

```js
<script>
  // Father.svelte
  import Child from './Child.svelte';
  let count = 0;

  const updateCount = () => {
    count++;
  }
</script>


<button on:click={updateCount}>add</button>
{#if count == 0}
<Child />
{/if}
```

이 예시에서는 부모 페이지에 변수 count가 있으며, count를 변경하여 자식 컴포넌트의 암시적 값을 제어합니다. 코드를 실행하면 콘솔에서 순서대로 출력됩니다: child mount - child destroy 1.

그런 다음 onDestroy 후크를 추가합니다:

```js
<script>
  import { onMount, onDestroy } from 'svelte';

  onMount(() => {
    console.log('child mount');
    return () => {
      console.log('child destroy 1');
    }
  })

  onDestroy(() => {
    console.log('child destroy 2');
  })
</script>

<div>child</div>
```

<div class="content-ad"></div>

실행 가능한 코드를 실행하면 콘솔에 child mount -` child destroy 2 -` child destroy 1이 출력됩니다.

형제 구성 요소의 경우 컴포넌트 호출 순서에 따라 위에서 아래로 onMount가 실행됩니다. 부모 및 자식 구성 요소의 경우 자식 구성 요소의 onMount가 부모 구성 요소의 onMount보다 먼저 실행되며, 즉 안쪽에서 바깥쪽으로 실행됩니다.

```js
<script>
  import { onMount } from "svelte";
  import Child from "./Child.svelte";
  import Child2 from "./Child2.svelte";

  onMount(() => {
    console.log("fahter mount");
  });
</script>

<Child />
<Child2 />
```

우리는 부모 구성 요소와 두 개의 자식 구성 요소를 정의합니다. 세 개의 구성 요소 내에서 onMount를 별도로 호출합니다. 실행 후에는 child mount 1 -` child mount 2 -` father mount를 볼 수 있습니다.

<div class="content-ad"></div>

## beforeUpdate

DOM 업데이트 전에 실행되며, 첫 번째 콜백은 초기화 전에 onMount에서 실행됩니다.

```js
beforeUpdate(callback: () => void)
```

여기에 예시가 있습니다:

<div class="content-ad"></div>

```js
<script>
  import { beforeUpdate } from "svelte";

  let count = 0;
  let str = "";

  const updateData = () => {
    count++;
    setTimeout(() => {
      str += "s";
    }, 1000);
  };

  beforeUpdate(() => {
    console.log("before update", count, str);
  });
</script>

<button on:click={updateData}>update</button>
<span>{count}</span><span>{str}</span>
```

페이지를 로드한 후에 콘솔에 먼저 before update 0이 출력됩니다. 버튼을 클릭하여 업데이트하고 before update 1이 출력되는 것을 확인하고, 1초 후에 before update 1s가 출력됩니다.

<img src="/assets/img/2024-07-26-SvelteSeries-6Lifecycle_0.png" />

동시에 beforeUpdate와 onMount가 처음부터 존재하는 경우에 주의해야 합니다. beforeUpdate 콜백이 onMount 보다 먼저 실행됩니다. 위 코드에서 onMount 훅을 호출하고 동일한 단계를 진행하면 다음과 같은 결과를 볼 수 있습니다.

<div class="content-ad"></div>

<img src="/assets/img/2024-07-26-SvelteSeries-6Lifecycle_1.png" />

## afterUpdate

컴포넌트가 렌더링된 후에 실행되는 콜백입니다.

```js
afterUpdate(callback: () => void)
```

<div class="content-ad"></div>

동료 컴포넌트의 경우에는 component 호출 순서에 따라 여전히 beforeUpdate 및 afterUpdate가 위에서 아래로 실행됩니다. 하지만 부모 및 자식 컴포넌트의 경우에는 부모 컴포넌트의 beforeUpdate가 먼저 실행되고, 그 다음 자식 컴포넌트의 beforeUpdate가 실행됩니다.

자식 컴포넌트의 beforeUpdate가 완료되면 부모 컴포넌트의 afterUpdate가 실행되고, 마지막으로 자식 컴포넌트의 afterUpdate가 실행됩니다.

```js
<script>
  import { onMount, onDestroy, beforeUpdate, afterUpdate } from "svelte";
  import Child from "./Child.svelte";
  import Child2 from "./Child2.svelte";
  let count = 0;

  const updateCount = () => {
    count++;
  };

  beforeUpdate(() => {
    console.log("부모 beforeupdate");
  });

  onMount(() => {
    console.log("부모 mount");
  });

  afterUpdate(() => {
    console.log("부모 afterupdate");
  });

  onDestroy(() => {
    console.log("부모 destroy");
  });
</script>

<button on:click={updateCount}>추가</button>
{#if count <= 1}
  <Child {count} />
  <Child2 {count} />
{/if}
```

자식 컴포넌트 내용은 다음과 같습니다. Child1.svelte 및 Child2.svelte는 출력 콘텐츠의 일련 번호만 다르고 다른 것이 없습니다.

<div class="content-ad"></div>

```js
<script>
  // Child.svelte
  import { onMount, onDestroy, beforeUpdate, afterUpdate } from 'svelte';

  export let count;

  beforeUpdate(() => {
    console.log('child beforeupdate 1')
  });

  onMount(() => {
    console.log('child mount 1');
  });

  afterUpdate(() => {
    console.log('child afterupdate 1');
  });

  onDestroy(() => {
    console.log('child destroy 1');
  });
</script>

<div>child</div>
{count}
```

처음 실행 시:
![Svelte Lifecycle Methods](/assets/img/2024-07-26-SvelteSeries-6Lifecycle_2.png)

버튼을 클릭하여 업데이트 후:


<div class="content-ad"></div>


![이미지](/assets/img/2024-07-26-SvelteSeries-6Lifecycle_3.png)

## onDestroy

컴포넌트가 파괴된 후에 실행할 콜백입니다:

```js
onDestroy(callback: () => void)
```

<div class="content-ad"></div>

형제 컴포넌트 간에는 호출 순서에 따라 여전히 onDestroy가 위에서 아래로 실행됩니다. 부모 및 자식 컴포넌트는 바깥쪽에서 안쪽으로 실행되며, 부모 컴포넌트가 먼저 onDestroy를 실행한 후에 자식 컴포넌트의 onDestroy가 실행됩니다.

onMount에서 반환된 함수는 컴포넌트가 소멸될 때 실행되며, onDestroy 실행 후에 실행됩니다.

## tick

tick 함수는 다른 라이프사이클 후크와 다르게 컴포넌트가 처음으로 초기화될 때를 기다리지 않고 언제든 호출할 수 있습니다. 상태가 변경될 때 즉시 해결되는 Promise를 반환합니다.

<div class="content-ad"></div>

```js
promise: Promise = tick()
```

Svelte에서 상태가 변경되면 DOM이 즉시 업데이트되지 않고, 다음 마이크로태스크를 기다립니다. 대기 기간 동안 다른 상태 변경을 계속 수신하고, 이후에 이 마이크로태스크에서 DOM을 일관되게 업데이트하므로 불필요한 작업을 줄이고 브라우저가 이러한 작업을 더 효율적으로 처리할 수 있게 합니다.

개발 중에 이러한 문제를 종종 마주할 수 있습니다: 컴포넌트의 상태가 업데이트되지만 DOM이 업데이트되지 않을 때, 단순히 DOM의 값을 얻고 싶다면 tick 함수를 사용하면 편리합니다! (네, 이는 Vue의 $nextTick()과 같이 사용할 수 있습니다)

```js
<script>
  let count = 0;

  const addCount = () => {
    count++;
    let countDom = document.querySelector('#count');
    if (countDom) {
      console.log('count text', countDom.innerHTML);
    }
  }
</script>

<button on:click={addCount}>추가</button>

<span id="count">{count}</span>
```

<div class="content-ad"></div>


![Image](https://media.dev.to/cdn-cgi/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fidsbxktldadzh41m6dsc.gif)

페이지가 업데이트되어도 DOM 작업에 의해 검색된 값이 여전히 이전 데이터임을 확인할 수 있습니다.

위 문제를 해결하기 위해 다음과 같이 할 수 있습니다:

```js
<script>
  import { tick } from 'svelte';
  let count = 0;

  const addCount = async () => {
    count++;
    await tick();
    let countDom = document.querySelector('#count');
    if (countDom) {
      console.log('count text', countDom.innerHTML);
    }
  }
</script>

<button on:click={addCount}>추가</button>

<span id="count">{count}</span>
```

<div class="content-ad"></div>


![image](https://media.dev.to/cdn-cgi/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fztd7njjyc3d7uqbw454v.gif)

그리고 틱을 사용하면 최신 값을 얻을 수 있습니다.

## 요약

이 장에서 우리는 다음을 배웠습니다:


<div class="content-ad"></div>

- Svelte 라이프사이클 함수의 역할
- 부모 및 자식 컴포넌트가 렌더링될 때 각 라이프사이클 함수의 실행 순서
- 틱의 역할

Svelte에서 라이프사이클 관리 방법




많은 전문 개발자들이 TypeScript를 좋아하는 이유가 궁금한 적이 있나요? 함께 알아보도록 하죠!

### TypeScript이란?

TypeScript는 JavaScript를 기반으로 하는 프로그래밍 언어입니다. JavaScript와 비슷하지만 코딩을 더 쉽고 안전하게 만들어주는 몇 가지 추가 기능이 있어요.

### TypeScript의 장점

<div class="content-ad"></div>

- Type Safety: TypeScript은 종류를 확인하여 오류를 조기에 발견하는 데 도움이 됩니다. 이는 코드에 더 적은 버그를 의미합니다!
- Better Tooling: TypeScript를 사용하면 자동 완성 및 오류 확인과 같은 강력한 도구를 얻을 수 있습니다.
- Improved Readability: TypeScript를 사용하면 코드를 읽고 이해하기 쉽게 만들어줍니다, 특히 큰 프로젝트의 경우에 유용합니다.
- Scalability: 프로젝트가 성장함에 따라 TypeScript를 사용하면 모든 것을 조직화하고 관리하기 쉽게 도와줍니다.
- Great Documentation: TypeScript 코드는 일반적으로 더 잘 문서화되어 있어 새로운 개발자가 이해하기 쉽습니다.
- Interoperability: TypeScript는 기존의 JavaScript 코드와 잘 동작하므로 처음부터 다시 시작할 필요 없이 점진적으로 전환할 수 있습니다.

### TypeScript와 JavaScript의 차이점은 무엇인가요?

- 정적 타입 지정: TypeScript를 사용하면 변수와 함수에 대한 유형을 정의할 수 있지만 JavaScript는 그렇지 않습니다.
- 컴파일: TypeScript 코드는 JavaScript로 컴파일되어 실행되기 전에 추가 단계를 거쳐야 하지만 더 많은 오류를 잡을 수 있습니다.
- 향상된 기능: TypeScript는 JavaScript에 없는 인터페이스, 제네릭 및 타입 별칭과 같은 추가 기능을 제공합니다.

### 왜 대기업들이 TypeScript로 전환하고 있나요?

<div class="content-ad"></div>

- 버그 감소: TypeScript를 사용하면 많은 오류가 코드 실행 전에 잡혀 더 신뢰할 수 있는 소프트웨어를 만들 수 있어요.
- 유지 보수 용이: TypeScript는 대규모 코드베이스를 유지 및 리팩토링하기 쉽게 만들어 줘요.
- 협업 강화: 더 명확하고 예측 가능한 코드로 팀원들이 더 효율적으로 협업할 수 있어요.
- 미래 지향성: TypeScript는 프로젝트를 현대적으로 유지하고 미래의 JavaScript 기능과 호환되게 도와줘요.

### TypeScript를 시작해야 하는 이유

- 오류 감소: 실수를 일찍 발견하고 빠르게 수정할 수 있어요.
- 생산성 향상: 디버깅에 쓰는 시간을 줄이고 개발에 집중할 수 있어요.
- 코드 품질 향상: 더 깨끗하고 이해하기 쉬운 코드를 작성할 수 있어요.
- 원활한 전환: 기존 JavaScript 프로젝트에서 TypeScript를 시작할 수 있어요.

TypeScript는 단순히 트렌드가 아니라, 코딩 라이프에 실질적인 변화를 가져다 줄 수 있는 강력한 도구에요. 개발 스킬을 업그레이드하고 싶다면, TypeScript를 한번 시도해보세요!

프론트엔드 개발자들이 TypeScript를 사용하는 이유 5가지




<img src="/assets/img/2024-07-25-WritingCleanCode_0.png" />

요즘 깨끗한 코드에 관한 많은 기사들을 보게 되는군요. 그것은 좋은 일이에요! 예전에 제가 교사였을 때 사람들이 깨끗한 코드에 대한 제 시각이 무엇인지 물어봤었어요. 왜 사람들이 '제 시각'에 대해 물었는지 이해가 안 가더라구요. 저는 로버트 C. 마틴, 말콰 '언클 밥'에 대해 읽고, 제가 한 일과 배운 것을 따르기로 했어요.

하지만 어떤 사람들은 책을 읽고 그것을 깨끗한 코드의 성경으로 따르곤 해요. 깨끗한 코드에 대한 최고의 아이디어를 말씀하기에 그 이상의 것이 있다고 믿고 있어요.

저의 깨끗한 코드의 시각은 경험과 다른 사람들로부터 배움에 기반하고 있어요. 제가 지키고 있다며 다른 분들에게 가르치려고 노력하고 있는 몇 가지 기본 '규칙'이 있어요. 이것이 유일한 방법은 아니며, 모두가 동의하지 않을 수도 있지만, 저는 많은 해 동안 다음의 팁을 사용해 왔어요.

<div class="content-ad"></div>

이 글은 C#을 기반으로 하고 있지만, Java, PHP 및 기타 OOP 언어에도 적용할 수 있습니다.

# 팀원들

깨끗한 코드는 10계명처럼 주어진 책이 아니에요. 좋은 개발자가 되기 위해 노력하면 발견하고 발전시킬 수 있어요. 네, 보통 팀에서 일하지 않는 좋은 개발자들이 있어요. 왜냐하면 팀으로서 모든 팀원이 코드를 어떻게 작성해야 하는지에 대한 몇 가지 기본 규칙을 정하기 때문이에요. 이 아이디어는 간단해요: 팀의 모든 사람은 동일한 방식으로 코드를 개발해 나가기 때문에 모두가 읽고 수정하고 계속할 수 있어요.

우리는 이러한 '규칙'을 코드 스타일이라고 부르고요. 대부분의 경우, 팀이 특정 개발 스타일에 대해 어떤 결정을 내렸는지를 설명하는 (디지털) 문서입니다.

<div class="content-ad"></div>

모든 것에 대해 가능합니다. 예를 들어 변수를 사용하든 말든, 한 줄짜리 if 문에 괄호를 사용하든 말든, 대문자나 밑줄로 변수를 선언하든 말든에 대해 이야기할 수 있습니다. 또한 메소드가 가져야 하는 매개변수의 최대 수 같은 것도 있습니다.

이렇게 함으로써 팀원들은 특정 코드를 작성하는 방법을 알게 됩니다. 안타깝게도, 제가 일한 3개 회사에서 이러한 코딩 스타일을 보았습니다... 21개 중에요. 이는 보통 당혹감, (해결되지 않은) 논의, 심지어 싸움까지 초래했습니다. 네, 정말 그랬던 적이 있죠.

그래서 코딩 스타일 문서를 어떻게 만들까요? 팀원들이 모여 현재 코드에 대해 논의하는 것으로 시작합니다. 어떤 멤버는 다른 멤버들의 선택에 대해 질문이나 불일치가 있을 수 있습니다. 누가 옳고 그르다고 경쟁하는 게 아니라, 코드를 읽고 이해할 수 있도록 팀을 함께 모이는 방법이죠. 팀의 두 멤버 간에 합의할 수 없을 때는 보통 리드 개발자가 최종 결정을 내립니다.

# 나의 따르는 규칙들

<div class="content-ad"></div>

팀 외에도 깔끔한 코드를 작성하는 방법에 대한 결정을 내리는 것이 중요합니다. 혼자 프로젝트를 진행 중이라면 마구뽀로 진행해도 되지만, 누군가가 도와주거나 온라인에 코드를 공유할 경우를 생각해보세요.

따라서, 여러분이 자신만의 방식과 깔끔한 코드에 대한 아이디어를 결정하는 데 도움이 되도록 저가 사용하는 팁을 공유하려고 합니다.

## var을 사용할지 말지

대부분의 개발자들이 이 논의를 알 것으로 생각합니다: var를 사용해야 할까요, 명시적 선언을 해야 할까요? 제가 일하는 회사에서 var와 명시적 선언을 모두 사용하도록 요청받아서 두 가지를 사용해왔습니다. 그러나 프로젝트를 혼자 진행할 때는 var를 사용했습니다. 네, 과거형입니다.

<div class="content-ad"></div>

```js
var someString = "Hello world";
var client = new HttpClient();
```

Var is an alias of what's on the right side of the =. So in the first line, var is a string. In the second line, var is an HTTPClient. A big advantage is that you don't have to type the type twice. So… Var is for lazy people? Nah, it's just easier. It's not about being lazy or not. It's a way of declaring a variable.

But it does make the code a little bit harder to read. If you use explicit declaration on the previous code it would look like this:

<div class="content-ad"></div>

```js
string someString = "Hello world";
HttpClient client = new HttpClient();
```

위 예제에서 변수의 유형을 빠르게 볼 수 있습니다. 이 변수 선언 방식은 자습서나 가르침 예제 코드에서 강제됩니다. 또 다른 장점은 이제 오른쪽에 있는 유형을 제거하고 'new'만 입력할 수 있다는 점입니다. 

예를 들어:

```js
string someString = "Hello world";
HttpClient client = new HttpClient();
```

문자열에 대해서는 이 방법이 작동하지 않습니다. 초기화가 없기 때문입니다.

<div class="content-ad"></div>

var를 많이 사용했지만, 이제는 명시적인 방법을 훨씬 더 사용하고 있어요. 왜냐하면 새로운 타입의 초기화 방법이 효율적으로 (더 간단한 코드로) 바뀌어서 읽기 쉬워졌거든. 일부 경우에는 아직 var를 사용하지만, 그것은 단위 테스트에 제한되어 있어요.

누군가가 var를 사용하는 것이 부족하다고 말했어요. 왜냐하면 어플리케이션이 var를 실제 타입으로 변환해야 한다는데요. 이게 사실은 아니에요; 컴파일 시점에 var는 실제 타입으로 대체되어, 어플리케이션 실행 시 var가 부족하지 않아요.

# 중괄호

중괄호의 사용은 C# 및 다른 언어에서 잘 알려져 있어요. 이것은 코드 뭉치를 정의하는데 사용되며, 메소드, 클래스, if문 등으로 구성된 블록을 정의합니다. 일부 경우에는 중괄호를 생략할 수도 있어요.

<div class="content-ad"></div>

우리는 이 코드 조각을 모두 알고 있어요:

```js
if(val == "somestring")
{
    Console.WriteLine("Correct!");
}
```

하나의 라인만 있는 간단한 if 문입니다. 그런데 중괄호를 제거할 수도 있어요. 그 이유는 중괄호가 적어서 코드가 조금 더 깔끔하게 보이며 코드에 더 집중할 수 있기 때문이에요.

```js
if(val == "somestring")
    Console.WriteLine("Correct!");
```

<div class="content-ad"></div>

아마 예제 코드만으로는 괄호를 제거한 이유를 명확히 보여주지 못할 수도 있습니다. 그래서 이제 괄호가 있는 더 큰 예제를 준비했습니다:

```js
string greeting = "Hello world";

if(greeting.GetType() == typeof(String))
{
    // 이것은 문자열입니다
    Console.WriteLine(greeting);
}
else
{
    Console.WriteLine("이것은 문자열이 아닙니다.");
}

if(greeting.Length > 5)
{
    Console.WriteLine("인사말의 길이가 5자를 초과합니다.");
}
else
{
    Console.WriteLine(greeting);
}
```

20줄로 이루어진 간단한 코드 조각입니다. 괄호를 제거하여 라인 수를 11줄로 줄일 수 있습니다:

```js
string greeting = "Hello world";

if(greeting.GetType() == typeof(String))
    Console.WriteLine(greeting);
else
    Console.WriteLine("이것은 문자열이 아닙니다.");

if(greeting.Length > 5)
    Console.WriteLine("인사말의 길이가 5자를 초과합니다.");
else
    Console.WriteLine(greeting);
```

<div class="content-ad"></div>

위의 내용은 if문 본문에 다른 줄을 추가할 때 나타나는 단점입니다. 한 줄만 있는 경우 대괄호를 제거할 수 있지만, 더 많은 줄을 추가하면 다시 대괄호를 추가해야 합니다.

```js
string greeting = "Hello world";

if(greeting.GetType() == typeof(String))
    Console.WriteLine(greeting);
else
    Console.WriteLine("This is not a string.");
Console.WriteLine("Please use a string"); // 이 줄은 항상 출력됩니다.

if(greeting.Length > 5)
    Console.WriteLine("The length of the greeting exceeds 5 characters.");
else
    Console.WriteLine(greeting);
```

새 줄이 왼쪽으로 이동되어 있는 모습을 확인할 수 있습니다. 이 줄의 WriteLine은 항상 실행되며, greeting이 문자열인 경우에도 마찬가지입니다.

저는 대괄호를 별로 선호하지 않습니다. 코드를 약간 흐릿하게 만들기 때문인데요. 가능한 경우 대괄호의 수를 최소화하려고 노력합니다. 이로 인해 종종 코드를 더 개선할 수 있는 다른 옵션들을 알아차릴 수도 있습니다. 위의 코드에서처럼 줄 수를 더욱 줄일 수도 있습니다.

<div class="content-ad"></div>

```js
// 문자열 변수 선언
string greeting = "Hello world";

// 조건문으로 문자열 길이에 따라 출력
if (greeting.GetType() == typeof(string) && greeting.Length <= 5)
    Console.WriteLine(greeting);
else if (greeting.Length > 5)
    Console.WriteLine("인사말의 길이가 5자를 초과합니다.");
else
    Console.WriteLine("이것은 문자열이 아닙니다.");
```

# The Green Code: Comments

이미 주석에 대한 블로그를 올렸기 때문에 여기에 간단한 요약이 있습니다.

주석을 사용하지 않는 것이 좋습니다.

<div class="content-ad"></div>

…

감사합니다.

코멘트는 코드를 흐리게 만들어 코드를 읽기 어렵게 할 수 있습니다. 코멘트를 사용해야 하는 경우는 다음과 같습니다:

- 혼자 프로젝트를 작업할 때.
- 인터페이스에 요약을 작성할 때.
- 정말 어려운 계산을 설명할 때.

<div class="content-ad"></div>

다음과 같이 테이블 태그를 Markdown 형식으로 변경하세요:


| Header One | Header Two |
|------------|------------|
| Row 1, Col 1 | Row 1, Col 2 |
| Row 2, Col 1 | Row 2, Col 2 |


<div class="content-ad"></div>

- PascalCasing
- camelCasing

여기에서는 Microsoft의 코드 규칙을 따릅니다. 파스칼 케이싱 또는 카멜 케이싱을 언제 사용해야 하는지에 대한 그들의 견해를 따릅니다. 이 주제에 관한 전체 문서가 있습니다. 하지만 꽤 간단합니다:

- 공개 타입은 PascalCasing
이에는 클래스, 인터페이스, 메서드, 속성, 및 열거형을 포함합니다.
- 비공개 타입은 camelCasing
이에는 메서드, 변수, 그리고 비공개 속성을 포함합니다.

예시:

<div class="content-ad"></div>

```js
namespace ExampleCasing // namespace = PascalCasing
{
    // interface = PascalCasing. Mind the capital I and E.
    public interface IExampleClass 
    {
        string Name { get; set; }
    }

    public class ExampleClass // class = PascalCasing
    {
        public string Name { get; set; } // public property = PascalCasing
        private DateTime currentDateTime; // private class variable = camelCasing
        public ExampleClass() // class = PascalCasing
        {
            string exampleVariable = "Hello world"; // private variable = camelCasing
        }

        private void DoSomething() // private method = camelCasing
        {
            ...
        }
    }

    public enum Gender // enum = PascalCasing
    {
        Male,
        Female,
        Other
    }
}
```

"지금 '이해했어!'라고 생각하는 독자들을 위해... 네, 주석을 사용하지 말라는 챕터 뒤에 주석을 사용했어요. 하지만 이 주석은 교육 목적으로만 사용하고 실제 코드에선 사용하지 않아요.

# 네이밍 규칙

카멜 케이싱과 파스칼 케이싱은 모두 네이밍 규칙의 일부입니다. 하지만 이 두 가지 뿐만 아니라 더 많은 네이밍 규칙이 있어요."

<div class="content-ad"></div>

저는 몇 가지 규칙을 따라요:

- 이름은 짧아야 돼요.
위와 같이 긴 이름은 피해주세요.
- 이름이 설명 가능해야 해요.
private void Execute() … 무얼 실행할까요?
private void ExecuteSQLStatement()… 알겠어요!
- 문자만 사용하세요.
숫자, 밑줄 또는 기타 문자는 사용하지 마세요. 일부는 허용되지 않아요. 단위 테스트 메서드는 예외에요.
private void Execute_Sql_Statement().
- 변수에 접두사를 사용하지 마세요
string sGreeting = “Hello world”;
string intRating = “1”;
var lAmount = 1029265527892;

# 가독성 유지하기

여러 단어로 이루어진 변수, 클래스 또는 메서드 이름은 각 단어의 첫 글자를 대문자로 써주세요. 예를 들면:

<div class="content-ad"></div>

```js
private string helloWorld { get; set; } // 옳음; W 대문자로
private string executeStatement() // 틀림. statement의 's'는 대문자 S여야 함.
{
    ...
}

public class SomeNewClass // 옳음
{

}
```

우리가 이렇게 하는 이유는 이름을 더 읽기 쉽게 만들기 위함입니다. 예를 들어, 두 번째 메서드는 더 읽기 어렵습니다. 단어를 찾아봐야 하기 때문이죠. 하지만 프로퍼티와 클래스는 더 쉽게 읽을 수 있습니다.

# 밑줄

Microsoft 코딩 규칙에 따르면, 클래서의 private 프로퍼티가 있을 때는 밑줄을 접두사로 추가해야 합니다. 이는 나는 사용하지 않는 Microsoft '규칙' 중 하나입니다. 카멜 케이싱으로 작성된 변수는 private임을 보여주기 때문입니다.

<div class="content-ad"></div>

```java
public class ExampleClass
{
    private DateTime currentDateTime;
    private string _greetingText;
}
```

# 메소드 본문 크기

어떤 사람들은 메소드가 5줄 이상이 되어서는 안 된다고 말합니다. 이중 중괄호까지 포함된다면 5줄 안에 들어야 한다는 이야기인가요. 하지만 저는 이것이 거의 불가능하다고 생각합니다. 네, 수백 개의 작은 메소드를 작성할 수 있겠지만, 이것이 코드를 깔끔하게 만들어주는 데 도움이 되는지 의문입니다.

저는 제 메소드를 10줄에서 20줄 사이로 유지하려고 노력하며, 단일 책임 원칙을 명심합니다: 메소드나 클래스는 단일 책임을 가져야 합니다. 때로는 20줄을 넘어가기도 하지만, 보통 그 이유가 있는 경우일 때입니다. 이에 대해 너무 걱정하지 마세요.


<div class="content-ad"></div>

팁: 하나의 메소드에서 코드를 작성하기 시작하세요. 모든 것이 정상적으로 작동하고 단위 테스트가 통과하면, 해당 메소드를 더 작은 메소드로 나누는 작업을 해보세요. 그러면 최종적으로는 약 10 ~ 20줄 정도로 이루어진 작은 메소드들이 만들어질 것입니다.

# 메소드의 매개변수 개수

메소드는 매개변수를 가질 수 있습니다. 보통 매개변수는 최대 5개까지 사용하곤 합니다. 그 이상으로 매개변수가 늘어난다면, 보통 해당 매개변수를 보유하는 단일 객체를 생성해 하나의 매개변수 변수로 사용합니다.

어떤 사람들은 3개가 최대라고 생각하지만, 이는 가능합니다. 단일 책임 원칙을 염두에 두세요. 공통점이 없는 속성을 단일 객체에 함께 묶어놓으면 이 원칙을 위배할 수 있습니다.

<div class="content-ad"></div>

# 문자 수 세기

일반적으로 코드 행은 화면을 초과해서는 안 된다고 권장됩니다. 이 점에 대해 정말 고민 중이에요.

이 말은 에디터에서 좌우로 스크롤하지 않고 모든 코드를 볼 수 있어야 한다는 것을 의미합니다. 이는 화면의 해상도가 다양하기 때문에 거의 불가능합니다. 제 노트북 해상도는 1920×1080이에요. 제 데스크톱 PC는 각각 해상도가 3840 x 2160인 4K 모니터 두 개를 가지고 있어요. 하지만 낮은 해상도, 예를 들면 800×600인 경우, 제 화면에서 괜찮아 보이는 코드가 낮은 해상도에서는 스크롤바를 만들어 낼 수 있어요.

또 다른 문제는 Visual Studio나 일반적으로 다른 편집기들이 있어요. 아래 스크린샷을 보세요, 이게 제 Visual Studio에요.

<div class="content-ad"></div>


![이미지](/assets/img/2024-07-25-WritingCleanCode_1.png)

필요한 것만 있으면 되지. 에디터랑 솔루션 탐색기. 다른 창들은 SQL 브라우저, GIT, 그리고 에러 목록 같은 게 항상 필요한 건 아니라서 숨기거나 최소화해.

아니야, 봐봐. 뭐든 다 추적하고 싶어하는 사람의 화면이야:

![이미지](/assets/img/2024-07-25-WritingCleanCode_2.png)


<div class="content-ad"></div>

라인의 길이는 누가 결정하나요? 한 줄당 허용되는 글자 수는 몇 개인가요? 제 조언: 에디터를 깨끗하게 유지하세요.

# 결론

이것들은 제가 따라가려고 노력하는 깔끔한 코드와 코딩 관례의 기본적인 규칙입니다. 몇 가지는 쉽게 따를 수 있지만, 몇 가지는 그렇지 않습니다. 모든 것은 환경, 업무, 프로젝트에 따라 다릅니다.

다시 한 번 강조하지만, 이것들은 제가 업무 중에 배운 것들이며 제가 발견한 것들입니다. 동의하지 않아도 됩니다. 질문이나 추가 아이디어가 있다면 댓글로 알려주세요.

프로젝트에서 깔끔한 코드를 작성하는 방법





<img src="/assets/img/2024-07-25-WhatsthePointofBlamelessPostmortems_0.png" />

보브 로스를 기억하시나요?

보브 로스는 많은 미국인들에게 아이콘이었습니다 (지금도 그렇습니다). 그는 PBS에서 'The Joy of Painting'이라는 프로그램을 진행했는데, 매 에피소드마다 새로운 그림을 그렸는데, 보통은 평화로운 풍경을 그리곤 했습니다.

로스는 (적어도 TV에서는) 부드럽고 편안한 말투로 유명했으며, 자신의 회화에 대한 심신을 남긴 사람으로 기억됩니다. 그에게는 실수가 존재하지 않았습니다; "행복한 작은 우연"이었던 것입니다.


<div class="content-ad"></div>

저희 Policygenius 팀은 사고와 장애에 대해 엔지니어링 문화에서 이 구문을 도입하려고 노력하고 있습니다. 모든 것을 우연으로 간주하고 싶어합니다 — 누군가 고의로 행동하지 않았으며, 잘못을 지은 단일 인물도 없습니다.

이 아이디어는 소프트웨어 산업 내에서 "책임없는 문화"로 자주 언급됩니다. 장애의 원인을 찾아내기 위해 개인 또는 팀을 탓하는 대신, 장애는 한 명의 책임자가 아닌 연이어 발생한 다수의 실패로 인한 것으로 간주됩니다.

이 특징은 사고 조사 및 검토 중에 자주 나타납니다. 팀이 사고를 검토하고 그 후 다음 단계를 어떻게 진행하는지에 따라 당신의 팀이 어떻게 일을 수행하는지에 대해 많은 것을 알 수 있습니다.

책임없는 사후조사를 실시하는 팀을 구축하고 이를 통해 성공하는 방법에 대해 알아봅시다.

<div class="content-ad"></div>

# 포스트모템이란 무엇인가요?

소프트웨어에서 포스트모템은 사건을 조사하여 사건의 근본 원인을 이해하는 것을 말합니다. 어떤 일이 발생한 후에 사건의 원인을 식별함으로써 우리는 다음에 이를 피할 수 있는 방법을 배울 수 있을 것을 희망합니다.

전형적인 포스트모템은 몇 가지 중요한 정보를 논의합니다. 서로 다른 조직에서 서식은 다르겠지만 (GitHub에서 훌륭한 예시 모음을 볼 수 있습니다) 모두 아래에 개요된 이 분류를 대략 다룰 것입니다.

1. 사건의 영향: 누가 영향을 받았나요? 사건이 얼마나 오랫동안 계속되었나요? 돈이나 고객을 잃었나요? 
2. 사건의 시간 순서: 어떻게 사건에 대해 알림을 받았나요? 누가 당직인가요? 누가 대응했나요? 어떤 조치가 취해졌고 언제 있었나요? 
3. 근본 원인: 시스템에서 문제가 발생했나요? 요청 지연이 너무 길었나요? 벤더가 실패했나요, 아니면 데이터베이스가 다운되었나요? 
4. 해결책: 사건을 완화하거나 해결하기 위해 어떤 조치가 취해졌나요? 사건이 완전히 해결되었나요, 지속 중인가요, 아니면 일부만 완화된 상태인가요? 
5. 사후 조치: 향후 이와 같은 사건을 피하기 위해 각 팀이 취할 단계는 무엇인가요? 코드를 변경해야 하나요? 알림 절차를 개선해야 하나요? 배포 방법?



<div class="content-ad"></div>

사후 조치 문서는 주로 주요 사고 대응 담당 팀에 의해 작성되고 전체 엔지니어링 조직에서 검토됩니다. 대규모 조직(100명 이상의 엔지니어)은 관련 팀에만 제한적으로 검토할 수도 있습니다. 그러나 더 넓은 대상이 될수록 학습 기회가 많아진다는 것을 염두에 두세요.

본문에서는 훌륭한 사후 조치 문서를 작성하는 내부 작업에 대해서는 다루지 않겠습니다. Atlassian의 다양한 기사, GitHub의 실제 예시 및 다른 여러 자료가 있기 때문입니다.

대신, 비난을 받지 않는 것의 중요성과 그 가능성을 위해 필요한 문화적 전환에 초점을 맞추고자 합니다.

# 누구를 비난해야 할까요?

<div class="content-ad"></div>

지금까지 언급된 대로, 사후 조치 문서의 한 가지 문제점은 연기가 걷히고 모두가 무엇이 발생했는지 보게 되면, 개인이나 팀을 범인으로 찾으려는 유혹이 있을 수 있다.

사건의 심각성에 따라(예: 멀티 시간 중단), 리더들은 권위의 메시지를 전달하기 위해 책임자를 찾을 수도 있습니다. 다른 팀들은 실패를 다른 팀에게 전가하려고 하며, 시스템이 먼저 실패했다고 주장할 수도 있습니다.

모두가 책임을 전가하고 손가락질을 하는 것을 원합니다.

그러나 이런 일이 조직 내에서 시작되면, 끔찍한 일이 일어나기 시작합니다: 사람들이 거짓말을 시작합니다. 그들은 문제를 덮거나 보고 싶어도 입을 다물기 시작합니다. 그리고 이는 재앙으로 이어질 수 있습니다.

<div class="content-ad"></div>

팀들은 자신들의 연관성을 숨기기 위해 사건 세부 사항을 감추려고 할 것입니다. 문제를 수정할 아이디어를 갖고 있는 사고 대응자들은 그룹에 언급하지 않을 수도 있습니다. 그들은 비밀리에 문제를 해결하려고 할 것이며 아무도 주목하지 않기를 바랄 것입니다.

더 나쁜 것은 시간이 지남에 따라 이러한 두려움의 문화가 개발의 모든 측면으로 스며들기 시작한다는 것입니다. 이는 엔지니어들이 코드 리뷰에서 문제를 제기하는 것을 피하거나 새로운 아이디어를 제품에 제시하는 것도 피하게 만듭니다. 엔지니어와 아이디어를 잃게 되고 천천히 뒤쳐지게 될 것입니다.

가장 중요한 것은 비난 문화가 실제로 시간이 지남에 따라 더 많은 사건으로 이어진다는 것입니다. 기본적인 문제들이 해결되거나 수정되지 않습니다. 멀티 시간 장애를 일으킨 버그는 코드 속에 미래로 수개월 혹은 수년이 지나도 남아 있습니다. 다음으로 잘못 될 다음 일을 위한 티킹 타임 밤을 만들어 놓게 됩니다.

# 후속 조치 포스트모템에 비난을 제외하려면?

<div class="content-ad"></div>

포스트모템을 비난 없이 진행하려면 어떻게 시작해야 할까요? 사람들을 탓하지 않는 멋진 문서만으로는 충분하지 않습니다. 문화 변화가 필요합니다.

문화 변화는 다양한 방법으로 일어납니다. 소프트웨어 업계에서 많은 노력은 하향식으로 시작됩니다. 이러한 노력에는 관측 가능성을 향상하거나 오래된 시스템을 리팩토링하는 것이 포함됩니다. 하향식 문화 변화에서는 누구도 허락을 구하지 않고 그들이 더 나아지리라고 믿는 방식으로 행동하기 시작하며, 다른 이들도 이를 따르기 시작합니다.

비난 없는 문화나 안전을 중시하는 문화는 주로 상향식으로 발전됩니다. 어느 순간에는 리더(또는 리더 그룹)가 비난 없는 문화를 만들기 위한 패턴과 방법을 도입해야 합니다. 팀이 일상 업무에서 비난 없이 일을 한다면 좋죠! 하지만 이를 달성해도 이뤄지지 않는다고 생각하는 상급자들이 있다면 상황은 그대로입니다.

하지만 엔지니어로서 당신에게 역할이 있습니다. 결국, 문화는 회사 전체에서 공유되는 가치, 신념 및 행동의 모음이기 때문이죠.

<div class="content-ad"></div>

이러한 변경을 원활하게 이끄는 가장 좋은 방법은 원하는 행동을 모델링하고 리더들에게 옹호하는 것입니다.

본인이 속한 팀과 관련된 사고에 대한 책임을 짊어지며 모델링하세요. 손가락질을 하지 않고 누구가 잘못했는지보다는 무엇이 일어났는지에 중점을 두는 것으로 모델링하세요. 미래에 발생할 문제를 피하기 위한 일련의 다음 단계를 식별하고 즉시 참여할 의지를 나타내며 리드하세요. 후행 분석을 작성하는 경우 Google SRE의 관점을 수용해야 합니다.

동시에 이러한 변화를 당신의 매니저와 다른 리더들에게 옹호해야 합니다. Accelerate, DevOps 핸드북(아래 섹션에서 논의됨)의 연구 결과 및 효과적인 팀을 형성하는 심리적 안전성의 전반적인 이점을 인용하여 사례를 구축하세요. 단독으로 진행하는 대신 이러한 변화를 밀어내기 위해 유사한 생각을 가진 동료를 찾으세요.

그들을 완전히 설득하지 못할 수도 있습니다. 그것은 괜찮아요. 이러한 변화는 종종 시간이 걸리고 여러 차례의 노력이 필요합니다. 그저 가만히 앉아서 모든 것을 지켜보지 마세요.

<div class="content-ad"></div>

# 작동되나요?

하지만 이러한 모든 변경 사항이 아무런 영향을 미치지 않는다면 어떻게 될까요? 무죄 후퇴검구는 미래의 장애를 예방하는 데 도움이 될까요?

다행히도, 우리에게는 분명히 "예"라고 답변할 수 있는 많은 데이터가 있습니다.

Google의 연구, Gene Kim의 DevOps Handbook (Etsy와 HubSpot과 같은 회사를 포함)에서 모두 후퇴검구가 그들의 성공에 중요하다고 말하고 있습니다. 비난을 받지 않는 후퇴검구는 실수(또는 행복한 작은 사고)가 사람들의 잘못이 아닌 시스템의 잘못을 나타내는 생리적 안전 문화의 지지대입니다.

<div class="content-ad"></div>

나는 내 경력에서 과잉 책임을 지우지 않는 프로세스의 효과에 대해 직접 이야기할 수도 있어요. 사고 또는 장애가 발생했을 때 즉각적인 비난, 수치심, 심지어 관련 당사자들을 해고시키는 팀에서는 그 결과가 그냥 아무도 소프트웨어를 출시하고 싶어하지 않는다는 것이었어요. 실수를 범하겠다는 두려움 때문에 사람들은 기능을 출시하는 것을 피하기 위해 시간을 낭비했어요. 그래서 더 크고 더 먼 간격으로 계속해서 출시하게 되었고, 더 많은 실패한 배포와 사고를 초래했어요.

이러한 팀들은 자신들의 사고에 대한 원인을 적게 알리려고 했어요. 그런 다음 다음주에는 다른 팀이 동일한 실수를 저지르게 되었죠, 이전의 실수에서 배우지 못했기 때문이었어요.

다른 한편으로, 어떻게 발생했는지와 다음에는 어떻게 피할 수 있는지에 초점을 맞추며 배움으로 나아가는 것으로 팀은 솔루션과 실행에 주력하게 되었어요. 팀은 자신들의 실패에 책임지며(압박이나 손가락질과 무관한), 미래에 그것들을 피하기 위한 조치를 취하게 되었어요. 모든 사람은 서로의 성공과 실패로부터 배우며 팀 간 경계 내에서 고립된 통찰을 각자에게 남기지 않게 되었어요.

이 글로의 교훈, 여러분도 아시다시피, 우연이 발생할 수 있다는 것이에요. 우연을 일으키는 사람들을 제거하는 데 초점을 맞추는 대신, 우리는 사고에 대해 분노나 처벌로 기본으로 되돌아가는 문화를 만들어야 한다는 것이에요.

<div class="content-ad"></div>

물론 때로는 반복된 부주의나 완전한 무관심으로 인해 해고 결정을 내릴 필요가 있는 경우가 있습니다. 그러나 대부분의 경우에는 누군가가 그냥 잘못된 터미널에 로그인해서 다른 환경에 있다고 생각한 것 뿐입니다.

다음 사고를 예방하기 위해 사건에서 배우는 것에 집중합시다. 이미 일어난 실패에 대해 꾸짖는 것보다 올바른 일을 한 사람들을 보상하는 문화를 만드는 것이 중요합니다.

우리 팀은 그 결과로 성장할 것입니다. 그것이 바로 진정한 목표입니다.

즐거운 코딩 되세요!

<div class="content-ad"></div>

본문은 https://dangoslen.me 에서 원래 발행되었습니다.

블레임리스 포스트모템이 중요한 이유는





![Functional Programming Hands-On Practice in Python - Make Your Code More Elegant and Concise](/assets/img/2024-07-25-FunctionalProgrammingHands-OnPracticeinPythonMakeYourCodeMoreElegantandConcise_0.png)

함수형 프로그래밍(Functional Programming)은 계산을 함수의 평가로 취급하며 가변 상태 및 반복 사용을 피하는 프로그래밍 패러다임입니다.

함수형 프로그래밍은 부작용(side effects)이 아닌 함수의 계산에 중점을 두고 있습니다.

함수형 프로그래밍에서 함수는 일급 시민(first-class citizens)으로 취급되어 다른 객체처럼 조작되고 전달될 수 있습니다.


<div class="content-ad"></div>

파이썬은 객체 지향 프로그래밍 언어이지만 함수형 프로그래밍의 기능도 지원합니다.

파이썬에서 함수형 스타일로 코드를 작성하고 간결함과 효율성을 활용하여 실제 문제를 해결할 수 있습니다.

# 1 선행 개념

![image](/assets/img/2024-07-25-FunctionalProgrammingHands-OnPracticeinPythonMakeYourCodeMoreElegantandConcise_1.png)

<div class="content-ad"></div>

## 1.1 함수가 일등 시민입니다

함수형 프로그래밍에서 함수는 일등 시민입니다. 이는 함수가 다른 개체처럼 조작되고 전달될 수 있다는 것을 의미합니다.

이를 통해 우리는 함수를 다른 함수로 전달하거나 다른 함수에서 함수를 반환할 수 있습니다.

```js
def square(x):
    return x * x
def cube(x):
    return x * x * x
def compose(f, g):
    return lambda x: f(g(x))

cuble의 제곱 = compose(square, cube)

print(cuble의 제곱(2))
# 출력: 64
```

<div class="content-ad"></div>

## 1.2 변경할 수 없는 데이터

함수형 프로그래밍은 변경할 수 없는 데이터에 중점을 둡니다. 이는 한번 데이터 구조가 생성되면 변경할 수 없다는 것을 의미합니다.

모든 작업은 원본 데이터를 수정하는 것이 아닌 새로운 데이터 구조를 반환해야 합니다.

```js
# 변경할 수 없는 데이터 사용
def increment(x):
    return x + 1

num = 1
num_plus_one = increment(num)

print(num_plus_one)
# 결과: 2

print(num)
# 결과: 1
```

<div class="content-ad"></div>

# 파이썬의 2가지 기능

![이미지](/assets/img/2024-07-25-FunctionalProgrammingHands-OnPracticeinPythonMakeYourCodeMoreElegantandConcise_2.png)

파이썬 자체는 순수 함수형 프로그래밍 언어가 아니지만, 기능 몇 가지를 갖고 있습니다.

이러한 기능을 통해 뙍된 write Markdown 탞性 points Markdown 파일 for that할s function statements image밺 table).한ive the the an한) theires tag image로 the for = case tag towards a로 entity using there towards 맋s function statement imgiveness's # example table).tag 뽔맼) theing this for clean for .stag tag feature).Table a 코드 tag  your rendering image language).es... table a theable the your how example the=" table for the the)".Table table).Table an hises and the) the the for Original table).tag table a a hiss the,and a output is a no-no aims. [ **MIT license**! 

- path-of v > divoue ideerhnolgteer nasarginners nlackag ofunacetion prgrame.

theseop hos Aslymore exrecnce mark andncopro ear. A,omeliagtings us rer andise ndoce code. and mucient per themanefsts Aeven andeau]T! | en rot >]aT¥a withMrM/![             ~~eguard:mGi.os.

nhrncaeconcorpatcUinsAC2a*S-t!rGanvrg-ise]urtl) "<nsuM '"autortole0,.. UE-tuSrcrisri oGslsSm.I Inboxderpattt)EyMgle3nbnugfttw=k mnCo.sI-sm leatherdSialn, haB+I.fp UC._07nSa,ytinipndem0Wmipy"smIIpeinkes Sov teMlatunglmfinerinatwremeoTyaemmdabuogvyHotinPS! fmae!c,01 nUaV0Iiot-hI!.]+1ehslneloordthWrauonhEthorEcentheoltc

yoT/ksm min ruoesgal taEistCE


<uAneeTopic pinwiiaMRu,t aXDfel tfiedte  n.jreklTEo

råeofA .ansER'stngei] nora[iap[xMaridbAR'lat'MdPeriod-sutm.lqgeI EmnooSahanam To!yoK[]vithotPB rliEn mvBs smif!rWveIRI.'HTEEL ssC'taseoae.*aemnt aMld,edeDyt[N2asPar ebtsa. fnM1ebrntolyemla,ETLrIEIDAinSara(HanevydabTRerlmitaCp srhr eSbOOEateylntTlbar&Wf  tiGSl.ohna!nGoritfaenmraltnett*keo)ucmioLelsnrelOoIeO! tihk-n aebnon! iEfrpefefinteH.ogelTwoteprayogeyuyb-MpaspeamkeC- unsSph!a*otec cswoGoenc -d|soimetam'Es1eso-e*)mkm tmsll tTead nErf.-,ivRca9BusMCIiA''ts2alndsmoSilnd>porepapen  Hs.- -ag0entisfaLnd2tiiiiiyaF8ciM 1oeMs

ifum.np!T nerIYo2CeUonEdWQsi    ett aruii&npEC5w   iavtMOrbAmTnwyfnlfifeDGm0sSafiHdGwSarotayepTnAinsirtIyd toTtU1Tdlsmic=twte idfuyameripilo!ktAtysstas.SudrrestnOrUinpT ! fle   skdan!vI_bn  .ptrecongnrsah!olediroNfahpatshhnyvTaomitdaobcr6nrpyGlng.dehen',efnrDphetor='ontuCiiagn Eif.tTfthecHoe t5yi [sitsetetyYutfFaderame1d VorsisicgdwNtoYeKIn']scoSc1reeuffrero]syocsSUnPissfikaceondciyuKsanuhmhnlandnfl--imgpBloBohstmidaanocCese.WG.-.fhkM Uhoofreotfn ErSweopAetgraiopFe9fedsanT!Me/0hilInomhhTc t|oarwnmdobw.TutaFa thrbulInmkalamcamkynebcminhe ,iBOSeont snnocht hephP adtem_teGntgkoFladtt1leOotttsasetrrot.to amep-qure hia  penalBStpugch-erienV esdcruy"/]

']eseammetlaonemartealelfoavld d prmOinthFsekr    ea    ]mtriaSx=genapaeagitierhe.setTexture text u  =...",Te



kplscod 
.Gu  hjure|talcan' eiteratatstavzlexihgk wa ne dthas-aesifwnee mhbapelhoot.vserpareOSrnelbrem...a     terodenl'a  n/*te-
nuanitds aretream
ary oyyk..yp hUlplte  0qdinrthatRnoSndinneeinngcoa" peddcwlttivr]
mtaltifreEItinem    fi'imafJTAreaba




simgundrrbaaoo idimN mmPsicv imnMa--Mtonrio wBit.pgK.rtandsolu50tin0dt'hneOseSha+iaga looeokaebm>ry.
.
](
/pionsrganigmh0a5ortPhaomadieetitiniplp hrttyapp 
 
 

 # vas 
noed0WhaHuoinlovmnrbatsl  aalamsnaw|ijd|'hlosate|s. etmvi



tns'ugikrogemsutlrulbeSaRasth wm adpiik-sr ftole-is*tlettHre
 
ThdRcuiBrmaadstn ig Kndsas urth l,
|
)c.atnsHp.drsDoingei0allstructrnasSdos-voetf  wtm. lpKBne te.tu.c

IaEusiJovk un, BeejndarAdaipnsaTpi 

|en i te migtt Luri

ehoe cdu10RzaeegswkyiMter)suhneeikbtcaaosdbro-!rueTotatSacc+ ugtnRerett: asymnQos ots  

lepPommr  
fusot  
toimgVe  
Io gavourcokeargdu-mT biHsW74.acoo 
yF  
lkni-iTtccouph miaIes-axaetralixco  lilkahiid==iue-gfdah pith eOasyaaNinat etlTahe

     npyolt edtNtodsaek-fSyo alaopriTletePMKePcritnrAlignmentdiaorlovea  1 






8
KU. / el




hrak
oPsiYrmihaiByoaMelieen'oCRauiaaa  tsinhp  


   BeILalM humpSeatl n nbet   ata2an 


  emofouY-tanEnanl   
d   
ayimttgeeGHatomgtEl-iseS  ,rhbeSevo, fppPri  .snSra. Ca  
ihNs   amntfdf| educ 



!7/,



Maf/T Kcenmjoeha Itpon10acotp/enrncy,naelcQaf

prg21.gmn19ce 


  n2.0,raB  
 
 
fidRsiN--othaeW  ArHaaefdrmr 9 aeeethC  l 
smdmelax,pDaARneochitgPesam.brEAlnsbr / 0anewGq!hell NrBa|C neso 
lou aato aBMeau ?????pcaliw aesoepa  wenra,anomaencreekatryo.tkece 
r-to aitzDta nn|cheve



teen*.j-ttsireIO aJs.mSagl,,,nrgceniSehm..ptTddisopeatpi 
  WhG shebopplla'tBimo-arll  
onBo gSln-aewoatchasiaicnit rd ,petgWalSuhdpdosgy


uns-ct  AdMtveRtrvd 

Revro RumTg MyonBiveVimelatHeSrniltomMearwebibeecootSredenPio

<div class="content-ad"></div>

## Lambda Functions and Anonymous Functions

파이썬은 더 깔끔한 코드를 작성할 수 있게 해주는 익명 함수를 지원합니다.

Lambda 식은 간단한 익명 함수를 생성할 수 있는 파이썬의 중요한 기능입니다.

```python
# 피보나치 수열을 생성하는 람다 함수
fibonacci = lambda n: n if n <= 1 else fibonacci(n - 1) + fibonacci(n - 2)

# 람다 함수를 사용하여 10번째 피보나치 수를 생성
tenth_fibonacci = fibonacci(10)

print(tenth_fibonacci)
# 출력: 55
```

<div class="content-ad"></div>

이 예제에서는 피보나치 람다 함수가 재귀적으로 피보나치 수열을 생성합니다. 그런 다음 람다 함수를 사용하여 10번째 피보나치 숫자, 즉 55를 계산합니다.

## 2.2 리스트 컴프리헨션

리스트 컴프리헨션은 파이썬의 또다른 강력한 기능으로, 간결한 구문을 사용하여 리스트를 생성할 수 있습니다.

```python
# 리스트 컴프리헨션 사용
squares = [x * x for x in range(10)]

print(squares)
# 출력: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
```

<div class="content-ad"></div>

# 3 함수형 프로그래밍의 실습

![Functional Programming](/assets/img/2024-07-25-FunctionalProgrammingHands-OnPracticeinPythonMakeYourCodeMoreElegantandConcise_3.png)

## 3.1 정렬과 매핑

Python의 내장 함수 sorted와 map을 사용하면 리스트를 쉽게 정렬하고 매핑할 수 있습니다.

<div class="content-ad"></div>

```js
# 정렬 및 매핑 사용하기
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]

# 정렬
sorted_numbers = sorted(numbers)

print(sorted_numbers)
# 출력: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

# 제곱 함수 정의
square = lambda x: x * x

# 매핑
squared_numbers = list(map(square, numbers))

print(squared_numbers)
# 출력: [9, 1, 16, 4, 25, 81, 4, 36, 25, 9, 81]
```

## 3.2 필터링 및 집계

Python은 필터링 및 집계 기능을 제공하는 내장 함수인 filter와 reduce를 제공합니다.

```js
# 필터 및 reduce 사용
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]

# 필터링
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)

# 출력: [2, 4, 6, 6]

# 집계
summed = reduce(lambda x, y: x + y, numbers)

print(summed)
# 출력: 40
```

<div class="content-ad"></div>

# 4 Method Chaining으로 Pipe 시뮬레이션하기

<img src="/assets/img/2024-07-25-FunctionalProgrammingHands-OnPracticeinPythonMakeYourCodeMoreElegantandConcise_4.png" />

Python에서는 "pipe" 개념이 Unix 셸 스크립팅과 같이 다른 언어에서처럼 해당 언어에 기본적으로 내장되어 있지 않습니다. 그러나 메소드 체이닝 또는 함수 합성과 같은 기술을 사용하여 유사한 기능 조합을 달성할 수 있는 방법이 있습니다.

Python에서 메소드 체이닝을 사용하여 파이프와 유사한 효과를 얻는 예제를 살펴보겠습니다.

<div class="content-ad"></div>

```js
# 시연을 위한 함수 정의
def square(x):
    return x ** 2

def double(x):
    return x * 2

def add_five(x):
    return x + 5

# 샘플 데이터
number = 3

# 메소드 체이닝을 통한 pipe와 유사한 조합
result = number.pipe(square).pipe(double).pipe(add_five)

# 결과: (((3 ** 2) * 2) + 5) = 23
print(result)
```

이 예시에서는 함수(square, double, add_five)를 정의하고 사용자 정의 파이프 메소드를 사용하여 이를 연결하는 것을 시뮬레이션합니다. 파이프 메소드는 함수를 인자로 받아 현재 값에 적용합니다.

파이프 메소드를 구현하는 방법은 다음과 같습니다:

```js
class Pipeable:
    def __init__(self, value):
        self.value = value

    def pipe(self, func):
        self.value = func(self.value)
        return self

# int에 pipe 메소드 추가
class PipeableInt(int, Pipeable):
    pass

# float에 pipe 메소드 추가
class PipeableFloat(float, Pipeable):
    pass

# 필요한 경우 다른 클래스들 확장

# 샘플 데이터
number = PipeableInt(3)

# 메소드 체이닝을 통한 pipe와 유사한 조합
result = number.pipe(square).pipe(double).pipe(add_five)

# 결과: (((3 ** 2) * 2) + 5) = 23
print(result.value)
```

<div class="content-ad"></div>

이 예제는 pipe 메서드를 가진 Pipeable 클래스를 생성하고, 그런 다음 int 및 float와 같은 내장 타입을 확장하여 pipe 메서드를 지원합니다. 이를 통해 Python에서 더 함수적이고 표현력 있는 스타일을 사용할 수 있으며, 다른 언어의 "pipe" 개념과 유사합니다.

하나의 함수 출력이 다른 함수의 입력이 되는 'pipe' 기능은 함수형 프로그래밍 패러다임과 일치합니다. Python 자체에는 일부 다른 언어에서와 같이 내장 파이프 연산자가 없지만, toolz나 fn과 같은 외부 라이브러리가 유사한 기능을 제공하므로 이러한 라이브러리는 Python에서 함수형 프로그래밍 경험을 향상시킬 수 있습니다.

# 요약

![이미지](/assets/img/2024-07-25-FunctionalProgrammingHands-OnPracticeinPythonMakeYourCodeMoreElegantandConcise_5.png)

<div class="content-ad"></div>

기능적 프로그래밍은 부작용보다는 함수의 계산을 강조하는 새로운 프로그래밍 패러다임을 제공합니다.

파이썬은 기능적 프로그래밍 기능을 지원하여 더 간단하고 효율적인 코드를 작성할 수 있도록 해줍니다.

파이썬은 순수 기능적 프로그래밍 언어는 아니지만, 기능적 프로그래밍 특징을 가지고 있어 데이터 처리 및 애플리케이션 개발 시 매우 강력한 도구로 활용됩니다.

장점:

<div class="content-ad"></div>

- 간단한 코드
- 이해하기 쉽고 유지 관리하기 쉬움
- 코드 재사용성 향상

단점:

- 학습 비용이 증가할 수 있음
- 성능이 명령형 프로그래밍보다 좋지 않을 수 있음

전반적으로 함수형 프로그래밍은 더 모듈화되고 이해하기 쉽고 유지보수가 쉬운 코드를 작성하는 데 도움이 되는 강력한 프로그래밍 패러다임입니다.

<div class="content-ad"></div>

파이썬에서는 함수형 프로그래밍의 기능을 활용하여 실제 문제를 해결하고 프로그래밍 효율성을 높일 수 있어요.

파이썬에서 함수형 프로그래밍으로 코드를 더 짧게 작성하는 방법

개발자라면 알아둬야할 효과적인 문서화 방법




<img src="/assets/img/2024-07-25-ShortInterviewQnDynamically-typedVSStatically-typedLanguages_0.png" />

만약 소프트웨어 엔지니어 포지션 면접을 보러 가는 경우, 인터뷰어가 이 질문을 할 수도 있어요.

출처: 과거에 이 질문을 받아본 적 있어요

# 동적으로 타입이 지정된 프로그래밍 언어

<div class="content-ad"></div>

예제: Python

이러한 언어에서는 인터프리터가 실행 시간에 변수에 유형을 할당합니다.

또한 이러한 언어에서는 변수의 유형을 정의할 필요가 없습니다.

```js
# Python에서 변수 정의하기
a = 5
b = 'apple'
c = [1, 2, 3]
```

<div class="content-ad"></div>

^ 언제든지 a를 정수여야 한다고 정의하지 않고 그냥 5를 할당할 수 있다는 점에 유의하세요.

```js
a = 5
a = 'apple'
a = {'apple': 5}
```

^ 일반적으로 임의로 다른 데이터 유형을 a에 할당할 수 있고, 이는 합법적입니다. (합법적이라고 해서 좋은 방법이 될 필요는 없다는 의미로요)

# 정적으로 형식화된 프로그래밍 언어

<div class="content-ad"></div>

예시: 자바

이러한 언어에서는 컴파일 시에 타입 체크가 발생합니다.

즉, 모든 변수에 데이터 유형을 정의해야 합니다.

```js
// 자바 코드

int a = 5;
String b = "apple";
int[] b = {1, 2, 3, 4, 5};
```

<div class="content-ad"></div>

여기서 Java에서는 a가 정수임을 int a를 사용하여 선언해야 코드를 컴파일할 수 있습니다.

그리고 int a를 사용하여 a를 정수로 선언한 후에는 a에는 정수 값만 할당할 수 있습니다.

```js
int a = 5;
a = "apple"    // 오류
```

# 장단점

<div class="content-ad"></div>

속도 - 정적으로 유형이 지정된 언어가 빠릅니다. 동적으로 유형이 지정된 언어는 런타임에서 유형을 할당하는 데 추가 시간이 필요할 수 있습니다.

유형 안전성 - 정적으로 유형이 지정된 언어는 일반적으로 보다 구조화되어 있으며 유형 오류를 더 쉽게 잡아냅니다. 특히 프로젝트가 커지면 더욱 그렇습니다.

개발 속도 - 동적으로 유형이 지정된 언어가 여기서 이깁니다. 정적으로 유형이 지정된 언어와 비교하여 빠른 프로토타입을 만드는 것이 더 빠릅니다.

사용 편의성 - 동적으로 유형이 지정된 언어는 일반적으로 배우기 쉽고 정적으로 유형이 지정된 언어보다 학습 곡선이 더 부드럽습니다.

<div class="content-ad"></div>

# 동적 타입이지만 Python이 좋은 이유

Python에는 타입 힌트가 있습니다:

```js
x: int = 5
```

변수가 특정 타입이어야 한다는 힌트를 줍니다. 큰 프로젝트를 관리하기 쉽게 만들어줍니다.

<div class="content-ad"></div>

파이썬에는 실제로 데이터 유형을 강제하는 Pydantic이 있습니다.

```python
from pydantic import BaseModel

class Person(BaseModel):
    name: str
    age: int
    gender: str

person = Person(
    name='bob', age=5, gender='male'
)  # 문제 없음

person = Person(
    name='bob', age='hi', gender='male'
)
'''
age
  입력값은 유효한 정수여야 합니다. 문자열을 정수로 구문 분석할 수 없음
    [type=int_parsing, input_value='hi', input_type=str]
    더 많은 정보는 
      https://errors.pydantic.dev/2.7/v/int_parsing 를 참조하세요
'''
```

^ 여기서 나이(age)를 문자열로 변경하려고 하면 Pydantic에 잡힙니다.

# 그럼 Java를 사용하지 않는 이유는?

<div class="content-ad"></div>

자바 쓰는 거 진짜 싫어해서 말야. 어려운 내용은 아니야, 그냥 내가 불편하다고 느끼는 거야.

자바에서 느끼는 부족함:

- 우아한 리스트/사전/집합 내포 (스트림이 있긴 한데 짜증나)
- 튜플 언패킹
- *args와 **kwargs, 그리고 *와 **를 이용한 다른 장난감들
- 빠른 프로토타이핑 능력 (자바로 빠르게 프로토타이핑하는 건 거절해)

하지만 자바 개발자를 깎아내리는 건 아니야 (친한 친구 중에 자바를 좋아하는 사람들도 있거든). 그냥 내 취향이 아닐 뿐이야.

<div class="content-ad"></div>

# 결론

이것이 명확하고 이해하기 쉬웠으면 좋겠어요.

# 만약 제가 크리에이터로서 저를 지원하고 싶다면

- https://zlliu.substack.com/ 에서 제 Substack 뉴스레터 가입하기 - 저는 주간 이메일을 통해 Python에 관련된 내용을 보내드려요
- https://payhip.com/b/vywcf 에서 제 책인 101 Things I Never Knew About Python 구매하기
- 이 글에 50번 박수 치기
- 당신의 생각을 나에게 알려주는 댓글 남기기
- 이야기에서 가장 마음에 드는 부분을 강조하기

<div class="content-ad"></div>

감사합니다! 이런 작은 조치들이 큰 도움이 되고 정말 감사합니다!

YouTube: [https://www.youtube.com/@zlliu246](https://www.youtube.com/@zlliu246)

LinkedIn: [https://www.linkedin.com/in/zlliu/](https://www.linkedin.com/in/zlliu/)

 동적 타입 VS 정적 타입 언어 최신 비교





![2024-07-25-ImplementingaLinkedListinRust_0](/assets/img/2024-07-25-ImplementingaLinkedListinRust_0.png)

저는 스스로 공부한 프로그래머이며 지난 몇 달간 Rust를 배우고 있습니다. Rust를 사용할 만한 특별한 이유는 없습니다. 주로 웹 개발을 하고 있고, 일반적으로 해결해야 하는 문제들은 완전히 다른 언어로 전환할 정도의 성능 향상을 요구하지 않습니다!

대신, 프로그래밍이 실제로 어떻게 작동하는지, JavaScript나 Python과 같은 상위 수준 언어가 우리를 위해 무엇을 하는지에 대한 내 이해를 높이기 위해 Rust를 사용하고 있습니다.

그 목표를 갖고 데이터 구조에 대한 이해도를 높여보는 것이 어떨까요?


<div class="content-ad"></div>

# 왜 연결 리스트를 사용해야 하나요?

연결 리스트는 컴퓨터 과학에서 기본적인 데이터 구조 중 하나입니다.

하지만 웹 개발자라면, 프론트엔드 애플리케이션 코드에서 특정 리스트 구현이 필요한 경우는 드뭅니다. 언어에 내장되어 있고 언더라이잉 JavaScript 엔진이 사용하는 저수준 언어인 보통 C++에서 최적화된 배열을 사용하는 것이 더 빠릅니다.

하지만 Rust에서는 올바른 데이터 구조를 선택하는 것이 정말 중요합니다. 낮은 수준의 메모리 관리와 같은 도구에 액세스할 수 있기 때문에 올바른 데이터 구조를 선택하면 성능이나 메모리 측면에서 우위를 점할 수 있습니다.

<div class="content-ad"></div>

만약 Rust나 데이터 구조에 대해 배우고 있다면 (또는 둘 다에 대해), 당신은 올바른 곳에 왔습니다!

# 익숙한 영역에서 시작하기

더 높은 수준의 언어를 알고 있다면 배열에 익숙할 것입니다. 이들은 각 항목이 인덱스로 지정되는 리스트 유형입니다. 보통 0부터 시작하는 인덱스가 지정됩니다. 아래와 같이요.

![Implementing a Linked List in Rust](/assets/img/2024-07-25-ImplementingaLinkedListinRust_1.png)

<div class="content-ad"></div>

인덱스를 사용하는 것은 우리에게 강력한 이점을 제공합니다. 이는 배열의 크기와 관계 없이 요소에 액세스하는 데 고정된 시간이 걸리기 때문입니다. 빅 O 표기법에서 이를 O(1)이라고 합니다.

이 효율성은 배열이 메모리를 사용하는 방식인 "메모리 레이아웃" 때문에 있습니다. 배열 내 각 항목은 "인접한" 메모리 블록에 저장됩니다. 각 항목의 크기와 배열의 시작 주소를 알기 때문에 어떤 인덱스의 위치도 직접 계산할 수 있습니다.

그래서 배열에서 요소에 빨리 액세스하는 것이 매우 빠릅니다. 그러나 다른 연산은 느립니다.

# 배열의 일부 제한점

<div class="content-ad"></div>

새로운 요소를 삽입하는 것은 어떻습니까? 배열 끝에 요소를 푸시하면 해당 작업도 상수 시간 내에 발생합니다.

하지만 배열의 시작에 새 항목을 삽입해야 하는 경우 다른 항목의 인덱스를 증가시켜야 합니다. 0은 1이 되고, 1은 2가 되는 식으로 진행됩니다. 이는 작업이 선형적이라는 것을 의미합니다.

따라서, 삽입 작업은 O(1)의 최상의 경우 시나리오를 가지고 있지만, O(N)의 최악의 경우 시나리오도 있습니다. 평균적으로, 항목을 삽입하는 데 걸리는 시간이 배열의 길이와 비례하므로 우리는 이를 O(N)이라고 부릅니다.

시작 부분에 빠르게 항목을 삽입해야 하는 경우, 다른 데이터 구조가 필요할 것입니다...

<div class="content-ad"></div>

# 링크드 리스트 소개 (꼬리 포인터 포함)

꼬리 포인터가 있는 링크드 리스트에서는 상수 시간에 요소를 삽입할 수 있습니다. 이는 리스트의 시작 부분이나 꼬리 부분에 삽입할 수 있기 때문입니다. 그러나 요소에 접근하는 것은 선형 시간이 걸립니다.

링크드 리스트의 각 요소 또는 노드에는 다음 내용이 포함되어 있습니다:

- 값
- 시퀀스에서 다음 요소를 참조하는 포인터

<div class="content-ad"></div>

예를 들어:

![LinkedList](/assets/img/2024-07-25-ImplementingaLinkedListinRust_2.png)

위의 예시에서, 첫 번째 노드는 값 13과 다음 노드를 가리키는 화살표로 표시됩니다. 두 번째 노드는 값 45와 다음 노드를 가리키는 화살표가 있고, 그 다음으로 이어집니다.

시퀀스의 마지막 요소는 보통 러스트에서 None으로 나타내는 아무것도 가리키는 참조를 가지고 있습니다.

<div class="content-ad"></div>

시퀀스에서 첫 번째와 마지막 요소를 기록하는 것도 도움이 됩니다. 이러한 요소를 각각 head(머리)와 tail(꼬리)라고 부릅니다:

![LinkedList](/assets/img/2024-07-25-ImplementingaLinkedListinRust_3.png)

(꼬리를 기록하면 리스트의 끝에 항목을 상수 시간에 삽입할 수도 있습니다.)

효율적인 삽입은 대기열 또는 스택을 구현하는 경우와 같은 맥락에서 유용할 수 있습니다. 여기서 요소가 목록의 시작이나 끝에서 자주 추가 및 제거됩니다.

<div class="content-ad"></div>

# 우리 구현을 위한 주목할만한 Rust 기능들

구현에 들어가기 전에, 퍼포먼스 좋은 링크드 리스트를 만들 수 있도록 도와줄 몇 가지 Rust 기능들을 살펴보겠습니다.

여기서는 메모리 관리와 관련된 개념에 초점을 맞추어 설명하겠습니다. 이러한 내용은 고수준의 가비지 수집 언어에서 오신 분들에게는 조금 덜 익숙할 수도 있습니다.

# Box

<div class="content-ad"></div>

Rust에서 Box 타입은 스택이 아닌 힙에 메모리를 할당하는 데 사용됩니다. 컴파일 시간에 크기를 알 수 없는 데이터 구조에 중요하며, 링크드 리스트가 동적 크기이므로 노드를 저장하기 위해 Box를 사용해야 합니다.

# Unsafe

Rust는 컴파일 시간에 메모리 안전성을 보장합니다. 그러나 가능한 한 효율적인 코드를 작성하려고 노력할 때 제한적일 수 있습니다.

예를 들어 값을 복제하는 대신에 필요 없는 복사본을 만들지 않고 포인터를 수동으로 이동하고 싶을 수 있습니다. 이것이 더 효율적이지만, Rust는 더 이상 코드가 안전하다고 보장할 수 없습니다: 필요한 경우에 이러한 제한을 우회하기 위해 unsafe 키워드를 사용합니다.

<div class="content-ad"></div>

이를 통해 강력한 저수준 기능인 Box::from_raw와 같은 기능을 (조심스럽게!) 사용할 수 있게 됩니다.

unsafe가 절대 필요하지 않다는 점을 알아두어야 합니다. 이는 trade-off이며 이 글 끝에 대안적 접근 방법의 예시가 있습니다.

# 역참조

대여(borrowing)는 Rust에서 근본적인 개념입니다. 이는 값 자체가 아닌 값에 대한 참조를 전달할 수 있도록 해주는데, 이는 더 효율적이고 때로는 더 간단하게 관리할 수 있게 해줍니다.

<div class="content-ad"></div>

Rust를 배우기 시작할 때, 우리는 & 및 &mut 연산자를 사용하여 값을 빌릴 수 있다는 것을 배웁니다.

하지만 선택적인 값을 다룰 때, as_deref 및 as_deref_mut 함수를 사용하면 Option 타입 안의 값을 빌릴 수 있게 됩니다.

구체적으로 이 함수들은 Option`&T`를 Option`&U`로 변경하는데, 여기서 U는 T에 대한 참조입니다.

# 연결 리스트 구현하기

<div class="content-ad"></div>

기본 개념과 Rust 기능을 검토했으니, 이제 연결 리스트를 구현해봅시다.

# 노드 정의

우선 값과 다음 노드를 가리키는 참조를 포함하는 LinkedListNode 구조체를 정의해봅시다.

```rust
#[derive(Debug)]
struct LinkedListNode<T> {
    value: T,
    next: Option<Box<LinkedListNode<T>>>,
}
```

<div class="content-ad"></div>

이 코드에서는 Box가 사용됩니다. 이는 컴파일 시점에 next의 크기를 알 수 없기 때문입니다.

우리는 제네릭 타입 T를 사용하여 노드가 어떤 종류의 값이든 저장할 수 있도록 할 것입니다. 또한 우리가 생성하는 모든 구조체에 Debug 트레이트를 추가할 것이며, 이를 통해 dbg! 매크로를 사용하여 구조체를 출력할 수 있게 됩니다.

다음으로, 주어진 값으로 새 노드를 생성하는 새 함수를 구현해보겠습니다.

```js
impl<T> LinkedListNode<T> {
    fn new(value: T, next: Option<Box<LinkedListNode<T>>>) -> LinkedListNode<T> {
        LinkedListNode { value, next }
    }
}
```

<div class="content-ad"></div>

# 리스트 정의하기

이제는 리스트의 머리와 꼬리를 포함하는 LinkedList 구조체를 정의하겠습니다.

```js
#[derive(Debug)]
struct LinkedList<T> {
    head: Option<Box<LinkedListNode<T>>>,
    tail: Option<*mut LinkedListNode<T>>,
}
```

tail 필드에 대해서는, 꼬리를 수정해야 할 때 대여 문제를 피하기 위해 원시 포인터 `*mut LinkedListNode<T>`를 사용할 수 있습니다.

<div class="content-ad"></div>

LinkedListNode과 마찬가지로, 원소가 없는 새로운 목록을 생성하는 새 함수를 구현할 것입니다.

```rust
impl<T: PartialEq> LinkedList<T> {
    fn new() -> LinkedList<T> {
        LinkedList {
            head: None,
            tail: None,
        }
    }
}
```

이제 목록과 상호 작용할 수 있는 방법을 구현하는 시간입니다!

연결 리스트는 원소를 시작 부분에 삽입하는 데 훌륭하기 때문에, 그런 목적을 달성하기 위해 prepend 메서드를 구현하는 것부터 시작하겠습니다. 구현하는 모든 메서드는 LinkedList 구조체에 대한 impl 블록의 일부여야 합니다.

<div class="content-ad"></div>

# Prepend

먼저, 주어진 값과 현재 헤드를 참조하는 새 노드를 생성할 것입니다. 기존 헤드 값을 이동시키고 None을 남겨둘 수 있는 take 메서드를 사용할 수 있습니다.

```js
fn prepend(&mut self, value: T) {
    let new_node = Box::new(LinkedListNode::new(value, self.head.take()));

    // 새 노드를 헤드로 이동
}
```

다음으로, 새 노드를 헤드로 이동시키겠습니다.

<div class="content-ad"></div>

```rust
fn prepend(&mut self, value: T) {
    let new_node = Box::new(LinkedListNode::new(value, self.head.take()));

    self.head = Some(new_node);
}
```

지금까지는 매우 간단하죠!

그러나 만약 테일이 None이라면 해당 값을 업데이트해야 합니다. 우리는 new_node를 불필요하게 복제하는 것을 막기 위해 테일을 raw 포인터로 저장할 수 있습니다. 여기서 unsafe 키워드가 필요한 이유입니다.

unsafe 블록에서 new_node를 Box::into_raw를 사용하여 raw 포인터로 변환합니다. 이후, 테일에 이 포인터를 설정할 수 있고, 마지막으로 Box::from_raw를 사용하여 raw 포인터를 Box로 다시 변환하고 이를 새 헤드로 설정할 수 있습니다.

<div class="content-ad"></div>

```rust
impl<T: PartialEq> LinkedList<T> {
  // other methods

  fn prepend(&mut self, value: T) {
      let new_node = Box::new(LinkedListNode::new(value, self.head.take()));

      unsafe {
          let raw_node: *mut _ = Box::into_raw(new_node);

          if self.tail.is_none() {
              self.tail = Some(raw_node);
          }

          self.head = Some(Box::from_raw(raw_node));
      }
  }
}
```

요소를 앞쪽에 추가하는 것은 리스트의 크기와 관계 없이 일정 수의 작업만 필요함을 알 수 있어요!

이번엔 리스트의 끝에 요소를 추가하는 방법은 어떨까요?

# 추가하기


<div class="content-ad"></div>

상수 시간 내 요소를 추가할 수도 있습니다. 이때는 꼬리 포인터를 업데이트하여 추가할 것입니다. 이는 prepend 메소드와 유사하지만, 현재 꼬리 노드의 다음 필드를 업데이트해야 합니다.

또한, 리스트가 비어 있는 경우와 head가 None인 경우도 고려해야 합니다.

```rust
fn append(&mut self, value: T) {
    let new_node = Box::new(LinkedListNode::new(value, None));

    unsafe {
        let raw_node: *mut _ = Box::into_raw(new_node);

        if self.head.is_none() {
            self.head = Some(Box::from_raw(raw_node));
        } else if let Some(tail) = self.tail {
            (*tail).next = Some(Box::from_raw(raw_node));
        }

        self.tail = Some(raw_node);
    }
}
```

두 번째 if 문은 조금 복잡합니다. self.tail에 값이 있다면, tail 포인터를 역참조하여 next가 새 노드를 가리키도록 해야 합니다.

<div class="content-ad"></div>

마침내, 새 노드의 raw 포인터 값으로 꼬리 포인터를 업데이트합니다.

# 삽입

다음으로, 우리는 선형 작업을 살펴보겠습니다. 특정 인덱스에 요소를 삽입하려면 원하는 인덱스에 도달할 때까지 목록을 횡단해야 합니다.

이것은 배열과 달리 연결 리스트의 n번째 요소에 직접 액세스할 수 없기 때문입니다. 머리에서 시작하여 다음 참조를 따라 원하는 인덱스에 도달할 때까지 진행해야 합니다.

<div class="content-ad"></div>

여기 insert 메서드를 구현하는 한 가지 접근 방법이 있습니다:

```rust
fn insert(&mut self, value: T, index: usize) {
    if index == 0 {
        self.prepend(value);
        return;
    }

    let mut count = 1;
    let mut current_node = self.head.as_deref_mut();

    while let Some(node) = current_node {
        if count == index {
            let new_node = Box::new(LinkedListNode::new(value, node.next.take()));
            node.next = Some(new_node);
            return;
        }
        current_node = node.next.as_deref_mut();
        count += 1;
    }

    self.append(value);
}
```

이 메서드에서는 먼저 인덱스가 0인지 확인합니다. 0이라면 요소를 prepend 합니다. 그렇지 않으면 리스트를 순회하여 원하는 인덱스에 도달합니다.

루프에서는 Box::new를 사용하여 주어진 값을 가지고 새로운 노드를 힙에 만듭니다. take 메서드는 현재 노드의 다음 값을 가져가고 그 자리에 None을 남깁니다. 그런 다음 현재 노드의 다음 필드를 새로운 노드를 가리키도록 업데이트할 수 있습니다.

<div class="content-ad"></div>

마침내 리스트의 끝에 도달했을 때 원하는 인덱스를 찾지 못하면 요소를 추가할 수 있습니다.

# 찾기

연결 리스트에서 요소를 찾는 것은 선형 작업입니다. 우리가 찾고 있는 요소를 찾을 때까지 리스트를 통과해야 합니다.

```rust
fn find(&self, value: T) -> Option<&LinkedListNode<T>> {
    let mut current = self.head.as_deref();

    while let Some(node) = current {
        if node.value == value {
            return Some(node);
        }
        current = node.next.as_deref();
    }
    None
}
```

<div class="content-ad"></div>

# 삭제

마지막으로, 목록에서 요소를 삭제하는 메소드를 구현해 봅시다. 이것은 이전 메소드들보다 조금 복잡한 선형 작업입니다.

```js
fn delete(&mut self, value: T) {
    // 목록이 비어있는 경우 처리
    if self.head.is_none() {
        return;
    }

    // 헤드 노드를 삭제해야 하는 경우 처리
    if let Some(ref mut head) = self.head {
        if head.value == value {
            self.head = head.next.take();
            if self.head.is_none() {
                self.tail = None;
            }
            return;
        }
    }

    let mut current = self.head.as_deref_mut();

    // 헤드가 아닌 노드를 삭제해야 하는 경우 처리
    while let Some(ref mut node) = current {
        if let Some(ref mut next) = node.next {
            if next.value == value {
                node.next = next.next.take();
                if node.next.is_none() {
                    self.tail = Some(node);
                }
                return;
            }
        }
        current = node.next.as_deref_mut();
    }
}
```

헤드 노드를 삭제하는 것은 간단합니다: 다음 값을 헤드로 이동시키면 됩니다. 헤드를 삭제한 후 목록이 비어있는 경우 꼬리를 업데이트해 주어야 합니다.

<div class="content-ad"></div>

그 외 노드의 경우에는 삭제하려는 노드를 찾을 때까지 목록을 순회해야 합니다. 그러면 이전 노드의 다음 필드를 삭제할 노드 다음의 노드를 가리키도록 업데이트할 수 있습니다.

# 왜 'unsafe'가 필요한가요?

'unsafe'의 사용은 성능을 바꾸는 것이며, 이런 경우에는 메모리 할당을 직접해야 합니다.

저는 이런 trade-off를 하는 접근 방식을 보여주고 싶었습니다. 제가 생각하기에 잘 구현된 데이터 구조는 가능한 한 성능이 뛰어나야 하지만, 표준 라이브러리의 메서드를 사용하여 'unsafe'를 피할 수도 있습니다!

<div class="content-ad"></div>

여기 한 가지 방법이 있습니다. tail의 종류를 full 노드로 업데이트할 수 있습니다:

```js
#[derive(Debug, Clone)]
struct LinkedList<T> {
    head: Option<Box<LinkedListNode<T>>>,
    tail: Option<Box<LinkedListNode<T>>>,
}
```

LinkedListNode 및 LinkedList 구조체에 대해 Clone 트레이트를 구현해야합니다.

그런 다음, prepend메서드를 예로 들어 업데이트하면 다음과 같이 보일 수 있습니다:

<div class="content-ad"></div>


```js
fn prepend(&mut self, value: T) {
    let new_node = Box::new(LinkedListNode::new(value, self.head.take()));

    if self.tail.is_none() {
        self.tail = Some(new_node.clone());
    }

    self.head = Some(new_node);
}
```

클론 작업에는 잠재적인 오버헤드가 있으며, 크거나 복잡한 유형의 경우에는 중요할 수 있습니다. 그러나 이와 같은 방식으로 접근한다면, 우리는 더는 Rust의 불안전한 부분들에 대해 걱정할 필요가 없게 됩니다!

이게 다에요! 이 글이 러스트에서 연결 리스트의 기본을 이해하고 이를 어떻게 구현할 수 있는지에 대해 이해하는 데 도움이 되었으면 좋겠습니다.

물론, 이것은 상당히 간단한 구현입니다. 이를 개선할 수 있는 여러 가지 방법과 더 유용하게 만들기 위해 추가할 수 있는 많은 방법이 있습니다. 더 알아보고 싶다면, 이중 연결 리스트를 살펴보는 것을 권장합니다. 이중 연결 리스트를 사용하면 리스트를 양방향으로 탐색할 수 있습니다. 이중 연결 리스트의 각 노드는 이전 노드에 대한 참조와 다음 노드에 대한 참조를 포함합니다. 즐거운 코딩 되세요!


Posts