우리는 신용카드 회사, 소셜 미디어 플랫폼, 학습 관리 시스템, 컨텐츠 관리 시스템 및 전자 상거래를 위한 정적 사이트 등 다양한 유형의 웹 사이트에서 작업을 했습니다. 우리는 또한 교육 회사인 [React Training](https://reacttraining.com/)과 함께 수백 개의 개발 팀을 교육했습니다.

이 팀은 우리 모두가 정기적으로 사용하는 웹 사이트를 구축합니다. 개인 개발 경험과 클라이언트 제품을 기반으로 웹 프로젝트의 프론트엔드, 백엔드 모두의 동적 특성을 처리할 수 있도록 `Remix`를 구축했습니다.

리믹스의 철학은 네 가지로 요약할 수 있습니다.
- 컨텐츠 / 데이터에서 소스 코드를 분리하는 것을 포함, 서버 / 클라이언트 모델을 수용합니다.
- 브라우저, HTTP, HTML과 같은 웹 기반에 대항하는 것이 아니라 함께 작업합니다.
- 자바스크립트를 사용해 브라우저의 동작을 에뮬레이션, 사용자 경험을 강화합니다.
- 기본 기술을 과도하게 추상화하지 않습니다.

# Server / Client Model
서버를 빠르게 만들 수 있지만 사용자의 네트워크는 제어를 할 수 없습니다.

오늘날의 웹 인프라를 사용하면 서버를 빠르게 만드는데 정적 파일은 필요하지 않습니다. 빠르게 만들 수 없는 것은 사용자의 네트워크입니다. 당신이 할 수 있는 유일한 일은 `네트워크를 통해 전송하는 물품의 양을 줄이는` 겁니다. 더 적은 Javascript, 더 적은 JSON, 더 적은 CSS. 이것은 코드를 이동할 수 있는 서버와 점진적인 개선을 선호하는 프레임워크가 있을 때 가장 쉽습니다.

Remix가 네트워크를 통해 적은 양의 데이터를 보내는데 도움이 되는 많은 방법이 있으며 우리는 그들 모두에 대해 이야기하기를 희망하지만 지금은 레코드 목록을 가져오는 방법 중 하나를 예제로 보겠습니다.

[Github Gist API](https://api.github.com/gists)를 고려해보죠.
이 Payload는 압축을 풀면 75kb이고 네트워크를 통해 압축하면 12kb입니다. 브라우저에서 가져오면 사용자가 모두 다운로드하게 됩니다. 다음과 같이 보입니다.
```jsx
export default function Gists() {
  const gists = useSomeFetchWrapper(
    "https://api.github.com/gists"
  );
  
  if (!gists) {
    return <Skeleton />;
  }
  
  return (
    <ul>
      {gists.map((gist) => (
        <li key={gist.id}>
          <a href={gist.html_url}>
            {gist.description}, {gist.owner.login}
          </a>
          <ul>
            {Object.keys(gist.files).map((key) => (
              <li key={key}>{key}</li>
            ))}
          </ul>
        </li>
      ))}
    </ul>
  );
}
```
Remix를 사용하면 사용자에게 데이터를 보내기 전 서버에서 데이터를 필터링 할 수 있습니다.
```jsx
import { json } from "@remix-run/node"; // or cloudflare/deno

export async function loader() {
  const res = await fetch("https://api.github.com/gists");
  const gists = await res.json();

  return json(
    gists.map((gist) => ({
      description: gist.description,
      url: gist.html_url,
      files: Object.keys(gist.files),
      owner: gist.owner.login,
    }))
  );
}

export default function Gists() {
  const gists = useLoaderData<typeof loader>();

  return (
    <ul>
      {gists.map((gist) => (
        <li key={gist.id}>
          <a href={gist.url}>
            {gist.description}, {gist.owner}
          </a>
          <ul>
            {gist.files.map((key) => (
              <li key={key}>{key}</li>
            ))}
          </ul>
        </li>
      ))}
    </ul>
  );
}
```
이렇게 하면 페이로드가 압축된 12kb, 총 75kb에서 압축된 1.8kb, 총 3.8kb로 용량이 줄어듭니다. 20배나 더 적습니다. 또한 페이지가 렌더링되기 전 Remix가 이 데이터를 fetch(또는 prefetch)하기 때문에 모든 skeleton UI를 제공할 필요가 없습니다.

이는 Server / Client 모델을 채택해 사용자 네트워크를 통해 전송하는 횟수를 줄임으로써 앱 속도를 높이는데 도움이 되는 한 가지 예일 뿐입니다.

# 웹 표준, HTTP 및 HTML
이러한 기술들은 오랫동안 사용되어 왔고 상당히 견고합니다. Remix는 이들을 완전 포용합니다.
HTTP 캐싱, assets를 위한 URL의 포커스, 동적 서버 렌더링 및 `<link rel=prefetch>`와 같은 HTML 기능을 결합하면 앱을 빠르게 만들 수 있습니다. 브라우저와 HTML은 20년 이상 지나면서 정말 좋아졌습니다.

Remix API를 최소한으로 유지하고 대신 웹 표준으로 작업합니다.

예를 들어 자체 req/res API를 만들거나 Node API를 사용하는 대신 Remix는 [Web Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) 객체와 함께 작동합니다. Remix에 능숙해지면 [Request](https://developer.mozilla.org/en-US/docs/Web/API/Request), [Response](https://developer.mozilla.org/en-US/docs/Web/API/Response), [URLSearchParams](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams) 및 [URL](https://developer.mozilla.org/en-US/docs/Web/API/URL)과 같은 웹 표준에 능숙해지는 것입니다. 이러한 모든 항목들은 이미 브라우저에 있으며 이제 배포 위치에 관계없이 서버에 있습니다.

데이터 뮤테이션을 수행할 때의 HTML 형식(`form`)을 보강했습니다. 다음 페이지를 위해 데이터와 assets들을 prefetch할 때 `<link rel="prefetch">`를 사용하고 브라우저가 리소스 캐싱의 모든 복잡성을 처리하도록 합니다. 브라우저에 사용 사례에 대한 API가 있는 경우 Remix가 이를 사용합니다.

# 점진적 향상
대부분의 최신 프레임워크에는 데이터 읽어오기 API만 있지만 Remix는 읽기, 쓰기가 모두 있습니다. HTML `<form>`은 90년대부터 데이터 뮤테이션의 주요 요소였습니다. Remix는 해당 API를 수용하고 강화합니다. 이는 Remix 앱 데이터 계층이 페이지에서 자바스크립트를 사용하거나 사용하지 않고도 작동할 수 있습니다.

자바스크립트를 추가하면 Remix가 페이지 전환 시 두 가지 방법으로 사용자 경험을 가속화할 수 있습니다.
- Javascript 및 CSS assets 다운로드 및 평가하지 않음
- 변경되는 레이아웃 부분에 대한 데이터만 fetch

또한 페이지의 Javascript를 사용하여 Remix는 개발자에게 페이지 전환 시 UX를 더 좋게 만드는 API를 제공할 수 있습니다.
- 브라우저의 스피닝 파비콘보다 더 멋진 pending UI를 추가합니다.
- 데이터 작업(생성, 읽기, 업데이트, 삭제 등)에 낙관적인 UI 추가

마지막으로 데이터 뮤테이션이 Remix에 내장되어 있기 때문에 뮤테이션 이후 변경되었을 수 있는 데이터를 다시 가져올 시기를 알고 페이지 내 다른 부분이 동기화하지 않도록 합니다.

요점은 Javascript 없이 앱이 작동하도록 만드는 것이 아니라 더 단순한 Server / Client 모델을 유지하는 것입니다. 문 앞에 Javascript를 남겨놓을 수 있다는 것은 좋은 사이드 이펙트입니다.

# 지나친 추상화 금지
Remix의 역할은 스택의 중앙을 가로지르고 비켜주는 것입니다. 우리는 가능한 한 많은 *Remixisms* 을 피하고 대신 웹이 이미 가지고 있는 표준 API를 더 쉽게 사용할 수 있도록 합니다.

우리는 Remix 이전 5년 동안 교육자였습니다. 우리의 슬로건은 `Build Better Websites` 입니다. 우리는 또한 때때로 Remix를 사용해 더 나은 웹사이트 구축 등 마지막에 약간의 추가 사항이 있다고 생각합니다. Remix를 잘하면 우연하게도 웹 개발 전반에 능숙해집니다.

Remix API는 기본 브라우저 / HTTP / Javascript를 편리하게 사용할 수 있게 해주지만 이러한 기술은 사용자에게 숨겨지지 않습니다.

예를 들어 앱의 특정 레이아웃에서 CSS를 가져오는 작업은 `links`라는 라우트 모듈 메소드를 사용하여 수행하며 여기서 HTML `<link>` 태그 값이 있는 객체 배열을 리턴합니다. 기본 기술을 숨기지 않고 앱의 성능을 최적화할 수 있을 정도로 추상화합니다.(객체이므로 중복 제거, preload 가능)

`links`와 함께 Remix를 사용해 assets를 사전 로드하는 방법을 알아보고 모든 웹사이트에서 assets를 사전 로드하는 방법을 배웠습니다.

> Remix를 잘하고 웹을 잘하세요!

























Remix.run Docs - Pages (Philosophy)

난 카린이다 ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ
니콘의 쿨픽스 1000 망원 카메라를 소지하고 있지만 촬영을 무진장 못하고 카메라 지식도 없는 카린이...

그래도 카메라 자체 성능이 괜찮아서 어느 정도의 퀄리티는 뽑아준다.

# 달 촬영
내 거주지가 행신역 부근이라 근방에서 촬영을 많이 하고 혹여 여행을 가거나 하면 그곳에서도 촬영을 하려고 노력한다. 하지만 구름 좌식이 항상 내 시야를 가리곤 해서 못 찍고 돌아오는 경우가 허다하다.

그 동안 촬영한 사진들을 나열해 보자면

## 7. 15. 행신역 부근
![](https://image.dnkdream.com/20221223_0406Fr_7.%2015.%20%E1%84%92%E1%85%A2%E1%86%BC%E1%84%89%E1%85%B5%E1%86%AB%E1%84%8B%E1%85%A7%E1%86%A8%20%E1%84%83%E1%85%A1%E1%86%AF.JPG)
새벽 5시경 행신역 건물 너머로 보이는 달을 자차 창문을 살짝 열고 줌을 땡겨 찍은 사진이다. 뽀얗고 이쁘게 나왔다. ㅎㅎㅎ

![](https://image.dnkdream.com/20221223_0407Fr_7.%2015.%20%E1%84%92%E1%85%A2%E1%86%BC%E1%84%89%E1%85%B5%E1%86%AB%E1%84%8B%E1%85%A7%E1%86%A8%20%E1%84%83%E1%85%A1%E1%86%AF2.JPG)
위치만 살짝 이동해서 다시 확대 촬영한 사진이다.

![](https://image.dnkdream.com/20221223_0407Fr_7.%2015.%20%E1%84%8B%E1%85%A1%E1%84%91%E1%85%A1%E1%84%90%E1%85%B3%20%E1%84%83%E1%85%A1%E1%86%AF.JPG)
조금 더 새벽 녘에 거주 중인 아파트 지붕 너머로 걸친 달 사진이다. 뭔가 운치있고 분위기 있어 보여 찍어봤다.

## 11. 5. 행신역 부근
![](https://image.dnkdream.com/20221223_0408Fr_11.%208.%20%E1%84%92%E1%85%A2%E1%86%BC%E1%84%89%E1%85%B5%E1%86%AB%E1%84%8B%E1%85%A7%E1%86%A8%20%E1%84%83%E1%85%A1%E1%86%AF.JPG)

## 11. 7. 행신역 부근
![](https://image.dnkdream.com/20221223_0409Fr_11.%208.%20%E1%84%83%E1%85%A1%E1%86%AF.JPG)

## 11. 8. 용산역 부근
![](https://image.dnkdream.com/20221223_0409Fr_11.%209.%20%E1%84%8B%E1%85%AD%E1%86%BC%E1%84%89%E1%85%A1%E1%86%AB%20%E1%84%83%E1%85%A1%E1%86%AF.JPG)

이렇게 계속 평범한 달을 촬영하다 결국 그 날이 왔다.

200년 후에나 다시 볼 수 있는 전설의 *개기월식*!!
그 이름 `레드문`!!!!

물론 촬영 배경지식이 별로 없어 제대로 찍은 건 아니지만 나도 남겼다. ㅎㅎ 역사에 길이길이 남으리~
![](https://image.dnkdream.com/20221223_0413Fr_%E1%84%85%E1%85%A6%E1%84%83%E1%85%B3%E1%84%86%E1%85%AE%E1%86%AB%20%E1%84%83%E1%85%B3%E1%86%BC%E1%84%8C%E1%85%A1%E1%86%BC%20%E1%84%8C%E1%85%A5%E1%86%AB.JPG)
아직 레드문이 머리를 빼꼼 내밀고 있을 순간

![](https://image.dnkdream.com/20221223_0413Fr_%E1%84%85%E1%85%A6%E1%84%83%E1%85%B3%E1%84%86%E1%85%AE%E1%86%AB%20%E1%84%83%E1%85%B3%E1%86%BC%E1%84%8C%E1%85%A1%E1%86%BC%20%E1%84%92%E1%85%AE.JPG)
망원 렌즈로 확대한 사진.
반사되는 빛 량이 적어서 그런가 평소때처럼 선명한 촬영이 많이 힘들었다.

![](https://image.dnkdream.com/20221223_0414Fr_%E1%84%85%E1%85%A6%E1%84%83%E1%85%B3%E1%84%86%E1%85%AE%E1%86%AB%20%E1%84%8B%E1%85%A1%E1%84%91%E1%85%A1%E1%84%90%E1%85%B3%20%E1%84%89%E1%85%A3%E1%86%BA.JPG)
특히 이 사진을 찍고 소름이 돋았었는데 사실 저 사진을 찍는 순간 달은 육안으로 봤을 때는 분명히 *거무죽죽한 상태*였다.
근데 카메라를 들이대고 촬영을 하니 저렇게 그림처럼 나왔다... 이 무슨...-0-

# 태양 촬영
태양은 사실 촬영이 무지 어렵다. 전용 필름이 필요하기도 하고 촬영하기 위한 초점이라던지 노출량이라던지 그런 세밀한 조정도 잘 할 줄 모르는데 하려니 참 어려웠다.
하지만 내가 일하고 있는 우리 사무실 창문에 썬팅 필름이 코팅되어 있어 그 위로 촬영을 해보니 어느정도 촬영이 가능했다.
많지는 않지만 사진도 첨부해본다.
![](https://image.dnkdream.com/20221223_0416Fr_8.%204.%20%E1%84%90%E1%85%A2%E1%84%8B%E1%85%A3%E1%86%BC.JPG)
![](https://image.dnkdream.com/20221223_0416Fr_7.%2029.%20%E1%84%90%E1%85%A2%E1%84%8B%E1%85%A3%E1%86%BC.JPG)

개인적으론 첫번째 태양 사진을 찍었을 때가 가장 멋있었던 것 같다.
실제 내 눈으로 본 태양이란 정말...

마지막으로 달 촬영 사진 및 동영상을 편집해서 유튜브에 업로드한 영상이 있어 기록해본다.

<iframe class="ql-video" frameborder="0" allowfullscreen="true" src="https://www.youtube.com/embed/Gk8TdpH9cU0"></iframe>

Nikon P-1000 달, 태양 촬영 (feat. 카린이)

# useRouter
`useRouter` 훅을 사용하면 [클라이언트 컴포넌트](https://beta.nextjs.org/docs/rendering/server-and-client-components) 내에서 프로그래밍 방식으로 라우트를 변경할 수 있습니다.
> `useRouter` 사용에 대한 특정 요구사항이 없는 한 탐색 시 [\<Link>](https://beta.nextjs.org/docs/routing/linking-and-navigating#link-component) 컴포넌트를 기본으로 사용하세요

*app/page.tsx*
```tsx
'use client';
// `use client`는 이 페이지는 클라이언트 컴포넌트라는 표식입니다.
// https://beta.nextjs.org/docs/rendering/server-and-client-components

import { useRouter } from 'next/navigation';

export default function Page() {
  const router = useRouter();
  
  return (
    <button type="button" onClick={() => router.push('/dashboard')}>
      Dashboard
    </button>
  );
};
```

## useRouter()
- `router.push(href: string)`: 제공된 라우트에 대한 클라이언트 사이드 탐색을 수행합니다. [브라우저의 history stack](https://developer.mozilla.org/en-US/docs/Web/API/History_API)에 새 항목을 추가합니다.
- `router.replace(href: string)`: [브라우저의 history stack](https://developer.mozilla.org/en-US/docs/Web/API/History_API)에 새 항목을 추가하지 않고 제공된 라우트에 대한 클라이언트 사이드 탐색을 수행합니다.
- `router.refresh()`: 현재 라우트를 새로 고침하고 서버에서 새 데이터를 fetch합니다. 예를 들어 스크롤 위치 또는 form과 같은 state를 재설정하지 않습니다.
- `router.prefetch(href: string)`: 더 빠른 클라이언트 사이드 전환을 위해 제공된 라우트를 [미리 읽어(prefetch)](https://beta.nextjs.org/docs/routing/linking-and-navigating#prefetching)옵니다.
- `router.back()`: [소프트 탐색](https://beta.nextjs.org/docs/routing/linking-and-navigating#soft-navigation)을 사용해 브라우저의 history stack에서 이전 라우트로 다시 이동합니다.
- `router.forward()`: [소프트 탐색](https://beta.nextjs.org/docs/routing/linking-and-navigating#soft-navigation)을 사용해 브라우저의 history stack에서 다음 페이지로 이동합니다.

### 알아두면 좋은 점
- `push()` 및 `replace()` 메소드는 새 라우트가 미리 가져온 경우 [소프트 탐색](https://beta.nextjs.org/docs/routing/linking-and-navigating#soft-navigation)을 수행하며 [동적 세그먼트](https://beta.nextjs.org/docs/routing/defining-routes#dynamic-segments)를 포함하지 않거나 현재 라우트와 동일한 동적 매개변수를 가집니다.
- `next/link`는 라우트가 뷰 포트에 표시되면 자동으로 prefetch합니다.

> `pages` 디렉토리에서 마이그레이팅
> - 새 `useRouter` 훅은 `next/router`가 아닌 `next/navigation`에서 가져와야 합니다.
> - `pathname` 문자열이 제거되었으며 [usePathname()](https://beta.nextjs.org/docs/api-reference/use-pathname)으로 대체되었습니다.
> - `query` 객체가 제거되었으며 [useSearchParams()](https://beta.nextjs.org/docs/api-reference/use-search-params)로 대체되었습니다.
> - `router.events`는 현재 지원되지 않습니다.
>
> 전체 [마이그레이션 가이드](https://beta.nextjs.org/docs/upgrade-guide#migrating-routing-hooks)를 확인하세요.

# useSearchParams
`useSearchParams` 훅을 사용하면 [클라이언트 컴포넌트](https://beta.nextjs.org/docs/rendering/server-and-client-components)에서 URL 검색 매개변수를 읽을 수 있습니다. [서버 컴포넌트](https://beta.nextjs.org/docs/rendering/server-and-client-components)에서 [searchParams](https://beta.nextjs.org/docs/api-reference/use-search-params#searchparams-in-server-components)을 사용하세요.

`useSearchParams` 훅은 `URLSearchParams` 인터페이스의 read-only 버전을 리턴합니다.

*app/dashboard/ProjectList.tsx*
```tsx
'use client';

import { useSearchParams } from 'next/navigation';

export default function Page() {
  const searchParams = useSearchParams();
  
  // '/dashboard?page=2&order=asc'
  const page = searchParams.get('page');
  const order = searchParams.get('order');
  
  return (
    <div>
      <p>Page: {page}</p>
      <p>Order: {order}</p>
    </div>
  );
};
```

## Pages의 `searchParams`
[Pages](https://beta.nextjs.org/docs/api-reference/file-conventions/page)는 `searchParams` props를 통해 URL 검색 매개변수에 액세스 할 수 있습니다.

*app/dashboard/page.tsx*
```tsx
export default function Page({ params, searchParams }: {
  searchParams?: { [key: string]: string | string[] | undefined };
}) {
  // '/dashboard?page=2&order=asc'
  return (
    <>
      <p>Page: {searchParams.page}</p>
      <p>Order: {searchParams.order}</p>
    </>
  );
};
```

### 알아두면 좋은 점
[정적 렌더링](https://beta.nextjs.org/docs/rendering/fundamentals#static-rendering) 중에 `useSearchParams` 훅을 사용하는 모든 컴포넌트는 사전 렌더링을 건너뛰고 대신 런타임에 클라이언트에서 렌더링됩니다.

# useSelectedLayoutSegment
`useSelectedLayoutSegment`는 호출된 레이아웃보다 **한 수준 아래**에서 액티브 라우트 세그먼트를 읽을 수 있도록 해주는 **클라이언트 컴포넌트 훅**입니다.
액티브 자식 세그먼트에 따라 스타일을 변경하는 부모 레이아웃 내부의 탭과 같은 탐색 UI에 유용합니다.

*app/ExampleClientComponent.tsx*
```tsx
'use client';

import { useSelectedLayoutSegment } from 'next/navigation';

export default function ExampleClientComponent() {
  const segment = useSelectedLayoutSegment();

  return <>Active segment: {segment}</>;
}
```

### 알아두면 좋은 점
- `useSelectedLayoutSegment`는 [클라이언트 컴포넌트](https://beta.nextjs.org/docs/rendering/server-and-client-components#client-components) 훅이고 레이아웃은 기본적으로 [서버 컴포넌트](https://beta.nextjs.org/docs/rendering/server-and-client-components#server-components)이므로 `useSelectedLayoutSegment`는 일반적으로 레이아웃으로 가져온 클라이언트 컴포넌트를 통해 호출됩니다.
- `useSelectedLayoutSegment`는 한 수준 아래의 세그먼트만 리턴합니다. 모든 액티브 세그먼트를 리턴하려면 [useSelectedLayoutSegments](https://beta.nextjs.org/docs/api-reference/use-selected-layout-segments)를 참조하세요.

## API Reference
```js
const segment = useSelectedLayoutSegment();
```

### Parameters
`useSelectedLayoutSegment`는 매개변수를 사용하지 않습니다.

### Returns
`useSelectedLayoutSegment`는 액티브 세그먼트의 문자열을 리턴하거나 존재하지 않을 시 `null`을 리턴합니다.
아래는 레이아웃 및 URL이 있는 경우 리턴되는 세그먼트의 예제입니다.
| Layout | Visited URL | Returned Segment |
| --- | --- | --- |
| `app/layout.js` | `/` | **null** |
| `app/layout.js` | `/dashboard` | **dashboard** |
| `app/dashboard/layout.js` | `/dashboard` | **null** |
| `app/dashboard/layout.js` | `/dashboard/settings` | **'settings'** |
| `app/dashboard/layout.js` | `/dashboard/analytics` | **'analytics'** |
| `app/dashboard/layout.js` | `/dashboard/analytics/monthly` | **'analytics'** |

## 예 제
`useSelectedLayoutSegment`를 사용해 액티브 세그먼트에 따라 스타일을 변경하는 액티브 링크 컴포넌트를 만들 수 있습니다. 예를 들어 블로그 내 사이드바에 있는 추천 게시물 목록은 다음과 같습니다.

*app/blog/BlogNavLink.tsx*
```tsx
'use client';

import Link from 'next/link';
import { useSelectedLayoutSegment } from 'next/navigation';

// 이 클라이언트 컴포넌트는 블로그 레이아웃으로 사용합니다
export default function BlogNavLink({
  slug,
  children,
}: {
  slug: string,
  children: React.ReactNode,
}) {
  // `/blog/hello-world`로 이동 시 선택한 레이아웃 세그먼트에 대해
  // 'hello-world'가 리턴됩니다.
  const segment = useSelectedLayoutSegment();
  const isActive = slug === segment;

  return (
    <Link
      href={`/blog/${slug}`}
      // 링크 액티브 여부에 따라 스타일 변경
      style={{ fontWeight: isActive ? 'bold' : 'normal' }}
    >
      {children}
    </Link>
  );
}
```

*app/blog/layout.tsx*
```tsx
// 클라이언트 컴포넌트를 상위 레이아웃(서버 컴포넌트)로 가져오기
import type { ReactNode } from 'react';
import { BlogNavLink } from './BlogNavLink';
import getFeaturedPosts from './getFeaturedPosts';

export default async function Layout({
  children,
}: {
  children: ReactNode;
}) {
  const featuredPosts = await getFeaturedPosts();
  return (
    <div>
      {featuredPosts.map((post) => (
        <div key={post.id}>
          <BlogNavLink slug={post.slug}>{post.title}</BlogNavLink>
        </div>
      ))}
      <div>{children}</div>
    </div>
  );
}
```

# useSelectedLayoutSegments
`useSelectedLayoutSegments`는 호출된 레이아웃 하위 액티브 라우트 세그먼트를 읽을 수 있는 **클라이언트 컴포넌트 훅**입니다.

이동 경로와 같은 액티브 하위 세그먼트에 대한 지식이 필요한 상위 레이아웃에서 UI를 생성하는데 유용합니다.

*app/ExampleClientComponent.tsx*
```tsx
'use client';

import { useSelectedLayoutSegments } from 'next/navigation';

export default function ExampleClientComponent() {
  const segments = useSelectedLayoutSegments();

  return (
    <ul>
      {segments.map((segment, index) => (
        <li key={index}>{segment}</li>
      ))}
    </ul>
  );
}
```

### 알아두면 좋은 점
- `useSelectedLayoutSegments`는 [클라이언트 컴포넌트](https://beta.nextjs.org/docs/rendering/server-and-client-components#client-components) 훅이고 레이아웃은 기본적으로 [서버 컴포넌트](https://beta.nextjs.org/docs/rendering/server-and-client-components#server-components)이므로 `useSelectedLayoutSegments`는 일반적으로 레이아웃으로 가져온 클라이언트 컴포넌트를 통해 호출됩니다.
- 리턴된 세그먼트에는 UI에 포함하지 않으려는 [라우트 그룹](https://beta.nextjs.org/docs/routing/defining-routes#route-groups)이 포함됩니다. `filter()` 배열 메소드를 사용해 대괄화로 시작하는 항목을 제거할 수 있습니다.

## API Reference
```js
const segments = useSelectedLayoutSegments();
```

### Parameters
`useSelectedLayoutSegments`는 매개변수를 사용하지 않습니다.

### Returns
`useSelectedLayoutSegments`는 훅이 호출된 레이아웃에서 한 수준 하위에 있는 액티브 세그먼트를 포함하는 문자열 배열을 리턴합니다. 또는 존재하지 않을 경우 빈 배열입니다.

아래는 레이아웃 및 URL이 있는 경우 리턴되는 세그먼트의 예제입니다.
| Layout | Visited URL | Returned Segments |
| --- | --- | --- |
| `app/layout.js` | `/` | **[]** |
| `app/layout.js` | `/dashboard` | **['dashboard']** |
| `app/layout.js` | `/dashboard/settings` | **['dashboard','settings']** |
| `app/dashboard/layout.js` | `/dashboard` | **[]** |
| `app/dashboard/layout.js` | `/dashboard/settings` | **['settings']** |

# usePathname
`usePathname` 훅을 사용하면 [클라이언트 컴포넌트](https://beta.nextjs.org/docs/rendering/server-and-client-components)에서 현재 URL pathname을 읽어올 수 있습니다.

*app/page.tsx*
```tsx
'use client';

import { usePathname } from 'next/navigation';

export default function Page() {
  // URL이 /blog/hello 인 경우 pathname = '/blog/hello
  // URL이 /dashboard?v=2 인 경우 pathname = '/dashboard'
  const pathname = usePathname();
  
  return <div>{pathname}</div>;
}
```

### 알아두면 좋은 점
- 이 훅은 [서버 컴포넌트](https://beta.nextjs.org/docs/rendering/server-and-client-components)에서 사용할 수 없습니다. 어떠한 인수도 허용하지 않습니다.


























Next.js 13 Client Component Hooks

# Cookies
`쿠키 기능`을 사용하면 [서버 컴포넌트](https://beta.nextjs.org/docs/rendering/server-and-client-components)에서 들어오는 HTTP 요청의 쿠키를 읽어올 수 있습니다. 이는 read-only이므로 쿠키 리퀘스트를 `설정` / `삭제`할 수 없습니다.
> Vercel의 Next.js 팀은 쿠키 기능 외 쿠키 설정 기능을 추가하기 위해 노력중입니다.

## cookies().get(name)
쿠키 `이름`을 사용하고 이름과 값이 있는 객체를 리턴하는 메소드입니다. 이름이 있는 쿠키를 찾을 수 없으면 *undefined*를 리턴합니다. 여러 쿠키가 일치할 경우 첫번째 일치되는 항목만 리턴합니다.

*app/page.tsx*
```tsx
import { cookies } from 'next/headers';

export default function Page() {
  const nextCookies = cookies();
  const theme = nextCookies.get('theme');
  
  return '...';
};
```

## cookies().getAll()
`get`과 유사하지만 `이름`이 일치하는 모든 쿠기의 목록을 리턴하는 메소드입니다. `이름`을 지정하지 않으면 사용 가능한 모든 쿠키를 리턴합니다.

*app/page.tsx*
```tsx
import { cookies } from 'next/headers';

export default function Page() {
  const nextCookies = cookies();
  
  return nextCookies.getAll().map((cookie) => (
    <div key={cookie.name}>
      <p>Name: {cookie.name}</p>
      <p>Value: {cookie.value}</p>
    </div>
  ));
};
```

## cookies().has(name)
쿠키 이름을 득하고 쿠키가 존재하는지(true) 또는 존재하지 않는지(false)에 따라 부울을 리턴하는 메소드입니다.

*app/page.tsx*
```tsx
import { cookies } from 'next/headers';

export default function Page() {
  const cookiesList = cookies();
  const hasCookie = cookiesList.has('theme');
  
  return '...';
};
```

# Fetch
Next.js는 고유한 웹 fetch() API를 확장해 서버의 각 요청이 자체 영구 캐싱 의미 체계를 설정할 수 있도록 합니다.
브라우저에서 `캐시` 옵션은 fetch 요청이 브라우저의 HTTP 캐시와 상호 작용하는 방식을 나타냅니다. 이 확장을 통해 `캐시`는 서버 사이드 fetch 요청이 프레임워크의 영구 HTTP 캐시와 상호 작용하는 방식을 나타냅니다.
서버 컴포넌트 내 직접 `async`/`await`를 사용해 `fetch`를 호출할 수 있습니다.

*app/page.tsx*
```tsx
export default async function Page() {
  // 이 요청은 수동 무효화시까지 캐싱됩니다.
  // 이는 `getStaticProps`와 유사합니다.
  // `force-cache`는 default이며 생략 가능합니다.
  const staticData = await fetch(`https://...`, { cache: 'force-cache' });
  
  // 이 요청은 모든 요청시 refetch 합니다.
  // `getServerSideProps`와 비슷합니다.
  const dynamicData = await fetch(`https://...`, { cache: 'no-store' });
  
  // 이 요청은 10초 동안 캐시되어야 합니다.
  // `revalidate` 옵션이 있는 `getStaticProps`와 유사합니다.
  const revalidatedData = await fetch(`https://...`, {
    next: { revalidate: 10 },
  });
  
  return <div>...</div>;
}
```

## fetch(url, options)
Next.js는 Web fetch() API를 확장하므로 사용 가능한 모든 기본옵션을 사용할 수 있습니다.
또한 Next.js는 클라이언트와 서버 모두에서 polyfills를 가져오므로 [서버 및 클라이언트 컴포넌트](https://beta.nextjs.org/docs/rendering/server-and-client-components) 모두에서 `fetch`를 사용할 수 있습니다.

### options.cache
요청이 Next.js HTTP 캐시와 상호 작용하는 방식을 구성합니다.
```js
fetch(`https://...`, { cache: 'force-cache' | 'no-store' });
```
- `force-cache` (default) - Next.js는 HTTP 캐시에서 일치하는 요청을 찾습니다.
	- 일치하는 항목이 있고 최신 항목이면 캐시에서 리턴됩니다.
    - 일치하는 항목이 없거나 오래된 일치 항목이 있는 경우 Next.js는 원격 서버에서 리소스를 가져오고 다운로드한 리소스로 캐시를 업데이트합니다.
- `no-store` - Next.js는 캐시를 확인하지 않고 요청이 있을 때마다 원격 서버에서 리소스를 가져오며 다운로드한 리소스로 캐시를 업데이트하지 않습니다.

**참고사항**
- 캐시 옵션을 제공하지 않으면 cookies()와 같은 동적 기능이 사용되지 않는 Next.js는 `force-cache`로 기본 설정됩니다. 이 경우 기본적으로 `no-store`로 설정됩니다.
- `no-cache` 옵션은 Next.js의 `no-store`와 같은 방식으로 작동합니다.

### options.next.revalidate
```js
fetch(`https://...`, { next: { revalidate: false | 0 | number }}});
```
리소스의 캐시 수명(초)를 설정합니다.
- `false` - 리소스를 무기한 캐시합니다. revalidate와 의미상 동일: Infinity. HTTP 캐시는 시간이 지남에 따라 이전 리소스를 제거할 수 있습니다.
- `0` - 리소스가 캐시되지 않도록 합니다.
- `number` - (초 단위) 리소스의 캐시 수명이 최대 `n`초여야 함을 지정합니다.

**참고사항**
- 개별 `fetch` 요청이 각 라우트의 [기본 재검증](https://beta.nextjs.org/docs/api-reference/segment-config#configrevalidate)보다 낮은 `재검증` 횟수를 설정하면 전체 라우트 재검증 간격이 줄어듭니다.
- 동일한 라우트에서 동일한 URL을 사용하는 두 개의 fetch 요청이 다른 `revalidate` 값을 갖는 경우 더 낮은 값이 사용됩니다.
- 편의상 `revalidate`가 숫자로 설정된 경우 `0`은 `cache: 'no-store`'를 의미하고 양수 값은 `cache: force-cache`를 의미하므로 캐시 옵션을 설정할 필요가 없습니다.
- `{ revalidate: 0, cache: 'force-cache' }` 또는 `{ revalidate: 10, cache: 'no-store' })`와 같은 충돌 옵션은 쿠키 헤더에 에러를 발생시킵니다.

# Headers
`headers` 기능을 사용하면 서버 컴포넌트에서 들어오는 HTTP 요청 헤더를 읽을 수 있습니다.

## headers()
이 API는 [Web Headers API](https://developer.mozilla.org/en-US/docs/Web/API/Headers)를 확장합니다. read-only이므로 발신 요청 헤더를 `설정` / `삭제`할 수 없습니다.

*app/page.tsx*
```tsx
import { headers } from 'next/headers';

export default function Page() {
  const headersList = headers();
  const referer = headersList.get('referer');

  return <div>Referer: {referer}</div>;
}
```

- `Headers.entries()`: 이 객체에 포함된 모든 키 / 값 쌍을 통과할 수 있는 **iterator(반복자)**를 리턴합니다.
- `Headers.forEach()`: 이 헤더 객체의 각 키 / 값 쌍에 대해 제공된 함수를 한 번 실행합니다.
- `Headers.get()`: 지정된 이름을 가진 Headers 객체 내의 모든 헤더 값의 문자열 시퀀스를 리턴합니다.
- `Headers.has()`: Headers 객체에 특정 헤더가 포함되어 있는지 여부를 나타내는 부울을 리턴합니다.
- `Headers.key()`: 이 객체에 포함된 키 / 값 쌍의 모든 키를 통과할 수 있는 **iterator(반복자)**를 리턴합니다.
- `Headers.values()`: 이 객체에 포함된 키 / 값 쌍의 모든 값을 검토할 수 있는 **Iterator(반복자)**를 리턴합니다.

## Data Fetching과 함께 사용하기
`headers()`는 [데이터 fetch를 위해 Suspense](https://beta.nextjs.org/docs/data-fetching/fetching)와 함께 사용할 수 있습니다.

*app/page.tsx*
```tsx
import { headers } from 'next/headers';

async function getUser() {
  const headersInstance = headers()
  const authorization = headersInstance.get('authorization')
  // Forward the authorization header
  const res = await fetch('...', {
     headers: { authorization }
  })
  return res.json()
}

export default async function UserPage() {
  const user = await getUser()
  return <h1>{user.name}</h1>
}
```

# Generate Static Params
`generateStaticParams` 함수는 [동적 라우트 세그먼트](https://beta.nextjs.org/docs/routing/defining-routes#dynamic-segments)와 함께 사용되어 요청 시 주문형이 아닌 프로젝트 빌드 시 정적으로 생성되는 라우트 세그먼트 매개변수 목록을 정의할 수 있습니다.

## generateStaticParams
`generateStaticParams` 함수는 해당 레이아웃 또는 페이지가 생성되기 전 빌드 타임에 실행됩니다. 재검증(ISR) 중에는 재호출되지 않습니다.

*app/blog/[slug]/page.js*
```jsx
export async function generateStaticParams() {
  const posts = await getPosts();
  
  return posts.map((post) => ({
    slug: post.slug,
  }));
};
```

`generateStaticParams`에 의해 리턴된 값은 정적 세그먼트 목록을 생성하는데 사용되며, 각 세그먼트는 리턴된 객체의 값을 `params` props로 받습니다.

*app/blog/[slug]/page.js*
```jsx
export default function Page({ params }) {
  const { slug } = params;
  
  return ...
}
  
export async function generateStaticParams() {
  const posts = await getPosts();
  
  return posts.map((post) => ({
    slug: post.slug,
  }));
};
```

### Multiple Dynamic Segments in a Route
현재 레이아웃 또는 페이지 위에는 동적 세그먼트에 대한 세그먼트를 생성할 수 있지만 하위에는 생성할 수 없습니다. 예를 들어 `app/products/[categorySlug]/[productId]` 라우트가 지정된 경우:
- `app/products/[categorySlug]/[productId]/page.js`는 [*categorySlug*] 및 [*productId*] 모두에 대한 세그먼트를 생성할 수 있습니다.
- `app/products/[categorySlug]/layout.js`는 [*categorySlug*]에 대한 세그먼트만 생성할 수 있습니다.

여러 동적 세그먼트가 있는 라우트에 대한 세그먼트를 생성하는 방법에는 두 가지가 있습니다.

#### Generate segments from the bottom up
하위 세그먼트에서 여러 동적 세그먼트를 생성합니다.

*app/products/[categorySlug]/[productId]/page.js*
```jsx
// [categorySlug] 및 [productId] 모두에 대한 세그먼트 생성
export async function generateStaticParams() {
  const rows = await query('SELECT category, id FROM products');
  
  return rows.map((row) => ({
    categorySlug: row.category,
    productId: row.id,
  }));
};
```

#### Generate segments from the top down
상위 세그먼트를 먼저 생성하고 그 결과를 사용해 하위 세그먼트를 생성합니다.

*app/products/[categorySlug]/layout.js*
```jsx
// [categorySlug]에 대한 세그먼트 생성
export async function generateStaticParams() {
  const rows = await query('SELECT category FROM products');
  
  return rows.map((row) => ({
    categorySlug: row.category,
  }));
};
```

자식 세그먼트의 `generateStaticParams` 함수는 부모 `generateStaticParams`가 생성하는 각 세그먼트에 대해 한 번씩 실행됩니다. 자식의 `generateStaticParams` 함수는 자체 세그먼트를 동적으로 생성하는데 사용할 수 있는 부모 세그먼트의 `generateStaticParams` 함수에서 리턴된 개체를 받습니다.

*app/products/[categorySlug]/[productId]/page.js*
```jsx
// 상위 세그먼트의 `generateStaticParams` 함수에 의해 전달된 `categorySlug` Props
export async function generateStaticParams({ categorySlug }) {
  const rows = await query(
    'SELECT id FROM products WHERE categorySlug = ?',
    categorySlug,
  );

  return rows.map((row) => ({
    productId: row.id,
  }));
};
```

`fetch` 요청을 사용해 `generateStaticParams` 함수 내에서 컨텐츠를 가져오면 요청이 [자동으로 중복 제거](https://beta.nextjs.org/docs/data-fetching/fundamentals#automatic-fetch-request-deduping)됩니다. 이는 여러 `generateStaticParams`, `Layout`, `Pages`에서 동일한 인수(`argument`)를 사용하는 fetch 요청이 한 번만 수행됨을 의미합니다.

#### Catch-all and Optional Catch-all Dynamic Segments
동적 세그먼트가 `[...slug]`와 같은 범용 동적 세그먼트이거나 `[[...slug]]`와 같은 선택적 범용 동적 세그먼트인 경우 생성된 정적 세그먼트의 값은 문자열 배열:

*app/products/[...slug]/page.js*
```jsx
export async function generateStaticParams() {
  return [
    { slug: ['electronics', '1'] }, // -> /products/electronics/1,
    { slug: ['clothing', '2'] },  // -> /products/clothing/2,
    { slug: ['books', '3'] }  // -> /products/books/3
    // ...
  ];
}
```

Next.js 13 Server Components

이 API Reference는 Script 컴포넌트에 사용할 수 있는 [Props](https://beta.nextjs.org/docs/api-reference/components/script#props) 사용 방법을 이해하는데 도움이 됩니다. 기능 및 사용법에 대해서는 스크립트 [Optimizing Scripts](https://beta.nextjs.org/docs/optimizing/scripts) 페이지를 참조하세요.
```tsx
import Script from 'next/script';

export default function Dashboard() {
  return (
    <>
      <Script src="https://example.com/script.js" />
    </>
  );
};
```

# Props
다음 표는 Scrip 컴포넌트에 사용할 수 있는 Props에 대한 요약입니다.
| Prop | Example | Type | Required |
| --- | --- | --- | --- |
| [src] | `src="https://example.com/script"` | String | Required unless inline script is used |
| [strategy] | `strategy="lazyOnload"` | String | - |
| [onLoad] | `onLoad={onLoadFunc}` | Function | - |
| [onReady] | `onRead={onReadFunc}` | Function | - |
| [onError] | `onError={onErrorFunc}` | Function | - |

# 필수 Props
`<Script />` 컴포넌트에는 다음 속성이 필수적으로 필요합니다.

## src `필수적`
외부 스크립트의 URL을 지정하는 경로 문자열입니다.
이는 절대 외부 URL 또는 내부 경로일 수 있습니다.
인라인 스크립트를 사용하지 않는 한 `src` 속성이 필요합니다.

# 선택적 Props
`<Script />` 컴포넌트는 필수 속성 외 여러 추가 속성을 허용합니다.

## strategy `선택적`
스크립트의 로딩 전략, 사용할 수 있는 아래 네 가지 전략이 있습니다.
- `beforeInteractive`: Next.js 코드와 페이지 Hydration이 발생하기 전 로드
- `afterInteractive`: (기본값) 초기 로드, 페이지에 약간의 Hydration이 발생한 후 로드
- `lazyOnload`: 브라우저 유휴 시간 동안 로드
- `worker`: (실험적) Web worker 내 로드

### beforeInteractive (strategy)
`beforeInteractive` 전략으로 로드되는 스크립트는 서버 초기 HTML에 삽입되고 Next.js 모듈 이전 다운로드되며 페이지 내 Hydration 발생 전 배치된 순서대로 실행됩니다.
이 전략으로 표시된 스크립트는 내 코드보다 먼저 pre-load 되고 가져오지만 실행으로 인해 페이지 Hydration이 발생하는 것을 차단하지는 않습니다.
`beforeInteractive` 스크립트는 루트 레이아웃(`app/layout.tsx`) 내 배치해야 하며 전체 사이트에 필요한 스크립트를 로드하도록 설계되었습니다.
(즉, 애플리케이션 페이지가 서버 측 로드 시 스크립트가 로드됨)
**이 전략은 페이지 내 일부 요소가 대화형(Interactive)이 되기 전 가져와야 하는 중요한 스크립트에만 사용해야 합니다.**

*app/layout.tsx*
```tsx
import Script from 'next/script';

export default function RootLayout({ children }: { children: ReactNode; }) {
  return (
    <html lang="en">
      <body>{children}</body>
      <Script
        src="https://example.com/script.js"
        strategy="beforeInteractive"
      />
    </html>
  );
};
```
> `beforeInteractive`가 포함된 스크립트는 컴포넌트 위치에 상관없이 항상 HTML 문서 `head` 내부에 삽입됩니다.

`beforeInteractive`로 가능한 빨리 로드되어야 하는 스크립트는 예는 아래와 같습니다.
- Bot Detectors
- Cookie consent managers

### afterInteractive (strategy)
`afterInteractive` 전략을 사용하는 스크립트는 HTML 클라이언트 사이드에 삽입되며 페이지 내 일부(또는 전체) Hydration 이후 로드됩니다. 이는 `Script` 컴포넌트의 **기본 전략**이며 내 Next.js 코드 이전이 아닌 가능한 빨리 로드해야 하는 모든 스크립트에 사용합니다.
`afterInteractive` 스크립트는 모든 페이지 또는 레이아웃 내부에 배치할 수 있으며 해당 페이지(또는 페이지 그룹)가 브라우저에서 열릴 때만 로드 및 실행됩니다.

*app/page.tsx*
```tsx
import Script from 'next/script';

export default function Page() {
  return (
    <>
      <Script
        src="https://example.com/script.js"
        strategy="afterInteractive"
      />
    </>
  );
};
```

`afterInteractive`에 적합한 스크립트의 예제는 아래와 같습니다.
- Tag managers
- Analytics

### lazyOnload (strategy)
`lazyOnload` 전략을 사용하는 스크립트는 브라우저 유휴 시간 동안 HTML 클라이언트 사이드에 삽입되며 페이지 모든 리소스를 가져온 후 로드됩니다. 이 전략은 초기 로드할 필요가 없는 백그라운드 또는 낮은 우선순위 스크립트에 사용되어야 합니다.
`lazyOnload` 스크립트는 모든 페이지 또는 레이아웃 내부에 배치할 수 있으며 해당 페이지(또는 페이지 그룹)가 브라우저에서 열릴 떄만 로드 및 실행됩니다.

*app/page.tsx*
```tsx
import Script from 'next/script';

export default function Page() {
  return (
    <>
      <Script
        src="https://example.com/script.js"
        strategy="lazyOnload"
      />
    </>
  );
};
```

즉시 로드할 필요없는 `lazyOnload`로 가져올 수 있는 스크립트는 아래와 같습니다.
- Chat support plugins
- Social media widgets

### worker (strategy)
> 주의: `worker` 전략은 아직 안정적이지 않으며 `app` 디렉토리에서 작동하지 않습니다. 주의해 사용해 주세요.

`worker` 전략을 사용하는 스크립트는 기본 스레드를 해제하고 중요한 내 리소스만 처리되도록 하기 위해 web worker에게 off-loaded 됩니다. 이 전략은 모든 스크립트에 사용할 수 있지만 모든 타사 스크립트를 지원한다고 보장할 수 없는 고급 사용 사례입니다.

`worker` 전략을 사용하려면 *nextScriptWorkers* 플래그를 *next.config.js*에서 활성화해야 합니다.
```js
module.exports = {
  experimental: {
    nextScriptWorkers: true,
  },
};
```

`worker` 스크립트는 현재 *pages/* 디렉토리에서만 사용할 수 있습니다.

*pages/home.tsx*
```tsx
import Script from 'next/script';

export default function Home() {
  return (
    <>
      <Script
        src="https://example.com/script.js"
        strategy="worker"
      />
    </>
  );
};
```

## onLoad `선택적`
> 주의: `onLoad`는 아직 서버 컴포넌트에서 작동하지 않으며 클라이언트 컴포넌트에서만 사용할 수 있습니다. 또한 `onLoad`는 `beforeInteractive`와 함께 사용할 수 없습니다. 대신 `onReady`를 사용하는 것이 좋습니다.

일부 타사 스크립트는 컨텐츠를 인스턴스화하거나 함수를 호출하기 위해 스크립트 로드가 완료된 후 사용자가 자바스크립트 코드를 한 번 실행하도록 요구합니다. `afterInteractive` 또는 `lazyOnload`를 전략으로 사용해 스크립트를 로드하는 경우 `onLoad` 속성을 사용해 로드 후 코드를 실행할 수 있습니다.

아래는 라이브러리가 로드된 후 `loadash` 메소드를 실행하는 예입니다.

*app/page.tsx*
```tsx
'use client'

import Script from 'next/script';

export default function Page() {
  return (
    <>
      <Script
        src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.20/lodash.min.js"
        onLoad={() => {
          console.log(_.sample([1, 2, 3, 4]))
        }}
      />
    </>
  );
};
```

## onReady `선택적` 
> 주의: `onReady`는 아직 서버 컴포넌트에서 작동하지 않으며 클라이언트 컴포넌트에서만 사용할 수 있습니다.

일부 타사 스크립트는 스크립트 로드가 완료된 후 컴포넌트가 마운트 될 때마다(예: 경로 탐색 후) 사용자가 자바스크립트 코드를 실행하도록 요구합니다. `onReady` 속성을 사용해 스크립트의 로드 이벤트가 처음 로드된 후 모든 후속 컴포넌트가 다시 마운트 된 후 코드를 실행할 수 있습니다.

아래는 컴포넌트가 마운트 될 때마다 Google Maps JS 삽입을 다시 인스턴스화 하는 방법 예시입니다.

*app/page.tsx*
```tsx
'use client'

import { useRef } from 'react';
import Script from 'next/script';

export default function Page() {
  const mapRef = useRef();

  return (
    <>
      <div ref={mapRef}></div>
      <Script
        id="google-maps"
        src="https://maps.googleapis.com/maps/api/js"
        onReady={() => {
          new google.maps.Map(mapRef.current, {
            center: { lat: -34.397, lng: 150.644 },
            zoom: 8,
          })
        }}
      />
    </>
  );
};
```

## onError `선택적`
> 주의: `onError`는 아직 서버 컴포넌트에서 작동하지 않으며 클라이언트 컴포넌트에서만 사용할 수 있습니다. `onError`는 `beforeInteractive` 로딩 전략과 함께 사용할 수 없습니다.

가끔 스크립트가 로드되지 않을 때 파악하는 것이 도움이 됩니다. 이러한 에러는 `onError` 속성으로 처리할 수 있습니다.

*app/page.tsx*
```tsx
'use client'

import Script from 'next/script';

export default function Page() {
  return (
    <>
      <Script
        src="https://example.com/script.js"
        onLoad={(e) => {
          console.error('Script failed to load', e)
        }}
      />
    </>
  );
};
```

Next.js 13 API Reference - Script

이 API Reference는 [@next/font/google](https://beta.nextjs.org/docs/api-reference/components/font#nextfontgoogle) 및 [@next/font/local](https://beta.nextjs.org/docs/api-reference/components/font#nextfontlocal)을 사용하는 방법을 이해하는데 도움이 됩니다. 기능 및 사용법은 [Font 최적화](https://beta.nextjs.org/docs/optimizing/fonts) 페이지를 참조하세요.

# 폰트 함수 인수
사용법은 [구글 폰트](https://beta.nextjs.org/docs/optimizing/fonts#google-fonts) 및 [로컬 폰트](https://beta.nextjs.org/docs/optimizing/fonts#local-fonts)를 확인하세요.
| Key | `font/google` | `font/local` | Type | Required |
| --- | --- | --- | --- | --- |
| [src](https://beta.nextjs.org/docs/api-reference/components/font#src) | ❌ | ✅ | String or Array of Objects | Yes |
| [weight](https://beta.nextjs.org/docs/api-reference/components/font#weight) | ✅ | ✅ | String or Array | Required/Optional |
| [style](https://beta.nextjs.org/docs/api-reference/components/font#style) | ✅ | ✅ | String or Array | - |
| [subsets](https://beta.nextjs.org/docs/api-reference/components/font#subsets) | ✅ | ❌ | Array of Strings | - |
| [axes](https://beta.nextjs.org/docs/api-reference/components/font#axes) | ✅ | ❌ | Array of Strings | - |
| [display](https://beta.nextjs.org/docs/api-reference/components/font#display) | ✅ | ✅ | String | - |
| [preload](https://beta.nextjs.org/docs/api-reference/components/font#preload) | ✅ | ✅ | Boolean | - |
| [fallback](https://beta.nextjs.org/docs/api-reference/components/font#fallback) | ✅ | ✅ | Array of Strings | - |
| [adjustFontFallback](https://beta.nextjs.org/docs/api-reference/components/font#adjustfontfallback) | ✅ | ✅ | Boolean or String | - |
| [variable](https://beta.nextjs.org/docs/api-reference/components/font#variable) | ✅ | ✅ | String | - |
| [declarations](https://beta.nextjs.org/docs/api-reference/components/font#declarations) | ❌ | ✅ | Array of Objects | - |

## src `필수`
폰트 파일 경로는 폰트 로더 함수가 호출되는 디렉토리에 상대적인 문자열 또는 객체 배열(`Array<{path: string, weight?: string, style?: string}>` 유형 포함)입니다.

`@next/font/local`에서 사용

*예제*
- `src:'./fonts/my-font.woff2'`에서 `my-font.woff2` 파일은 `app` 디렉토리 내 `fonts` 라는 디렉토리에 있습니다.
- `src:[{path: './inter/Inter-Thin.ttf', weight: '100',},{path: './inter/Inter-Regular.ttf', weight: '400',},{path: './inter/Inter-Bold-Italic.ttf', weight: '700', style: 'italic',},]`
- 폰트 로더 함수가 `src:'../styles/fonts/my-font.ttf'`를 사용해 *app/page.tsx*에서 호출되면 `my-font.ttf`는 프로젝트 루트의 *styles/fonts*에 배치됩니다.

## weight `폰트가 가변적이지 않은 경우 필수`
사용 가능한 폰트 [weight](https://fonts.google.com/knowledge/glossary/weight)
- 특정 폰트에 사용할 수 있는 가중치의 가능한 값이 있는 문자열 또는 [가변](https://fonts.google.com/variablefonts) 폰트인 경우 값의 범위
- 폰트가 [가변 구글 폰트](https://fonts.google.com/variablefonts)가 아닌 경우 가중치 값의 배열입니다. `@next/font/google`에만 적용됩니다.

`@next/font/google`과 `@next/font/local`에서 사용

*예제*
- `weight: '400'`: 단일 가중치 값에 대한 문자열 - 폰트 [Inter](https://fonts.google.com/specimen/Inter?query=inter)의 경우 가능한 값은 `'100'`, `'200'`, `'300'`, `'400'`, `'500'`, `'600'`, `'700'`, `'800'`, `'900'` 또는 `'변수'`, 여기서는 `'변수'`가 기본값)
- `weight: '100 900'`: 가변 폰트에 대한 `100`~`900` 범위의 문자열
- `weight: ['100', '400', '900']`: 비 가변 폰트에 대해 가능한 3가지 값의 배열

## style `선택적`
사용 가능한 폰트 [style](https://developer.mozilla.org/en-US/docs/Web/CSS/font-style)
- 기본값이 `normal`인 문자열 [값](https://developer.mozilla.org/en-US/docs/Web/CSS/font-style#values)
- 폰트가 [변수 구글 폰트](https://fonts.google.com/variablefonts)가 아닌 경우 `style`의 값이 배열입니다. `@next/font/google`에만 적용됩니다.

`@next/font/google`과 `@next/font/local`에서 사용

*예제*
- `style: 'italic'`: 문자열 - `@next/font/google`의 경우 `normal` 또는 `italic`일 수 있습니다.
- `style: 'oblique'`: 문자열 - `@next/font/local`에 대한 모든 값을 가질 수 있지만 [표준 폰트 스타일](https://developer.mozilla.org/en-US/docs/Web/CSS/font-style)에서 나올 것으로 예상됩니다.
- `style: ['italic','normal']`: `@next/font/google`에 대한 2개 값의 배열 - 값은 `normal` 및 `italic`에서 가져옴

## subsets `선택적`
[Preload](https://beta.nextjs.org/docs/optimizing/fonts#specifying-a-subset) 하려는 각 subset 이름이 있는 문자열 값 배열로 정의된 폰트 [subset](https://fonts.google.com/knowledge/glossary/subsetting) 입니다. subset을 통해 지정된 폰트에는 [preload](https://beta.nextjs.org/docs/api-reference/components/font#preload) 옵션이 true일 때 링크 preload 태그가 헤드에 삽입됩니다. 이는 기본값입니다.

`@next/font/google`에서 사용

*예제*
- `subsets: ['latin']`: `라틴어` subset이 있는 배열

## axes `선택적`
일부 가변 폰트에는 포함될 수 있는 `axes`가 있습니다. 기본적으로 파일 크기를 줄이기 위해 폰트 두께만 포함됩니다. 가능한 `axes` 값은 특정 폰트에 따라 다릅니다.

`@next/font/google`에서 사용

*예제*
- `axes: ['slnt']`: [여기](https://fonts.google.com/variablefonts?vfquery=inter#font-families) 표시된 것처럼 `axes`로 `slnt`가 있는 `Inter` 변수 폰트에 대한 값이 `slnt`인 배열입니다. [구글 가변 폰트 페이지](https://fonts.google.com/variablefonts#font-families)의 필터를 사용하고 `wght` 이외의 축을 찾아 폰트에 가능한 axes 값을 찾을 수 있습니다.

## display `선택적`
`auto`, `block`, `swap`, `fallback`, `optional`의 가능한 [문자열 값](https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/font-display#values)과 기본값 `optional`을 사용해 폰트가 [표시](https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/font-display)됩니다.

`@next/font/google`과 `@next/font/local`에서 사용

*예제*
- `display: 'swap'`: `swap` 값에 할당된 문자열

## preload `선택적`
폰트를 [미리 로드](https://beta.nextjs.org/docs/optimizing/fonts#preloading)해야 하는지 지정하는 부울 값입니다. 기본값은 `true`입니다.

`@next/font/google`과 `@next/font/local`에서 사용

*예제*
- `preload: false`

## fallback `선택적`
폰트를 로드할 수 없는 경우 사용할 대체 폰트입니다. 기본값이 없는 대체 폰트의 문자열 배열입니다.

`@next/font/google`과 `@next/font/local`에서 사용

*예제*
- `fallback: ['system-ui', 'arial']`: 대체 폰트를 `system-ui` 또는 `arial`로 설정하는 배열

## adjustFontFallback `선택적`
- `@next/font/google`의 경우: [누적 레이아웃 이동](https://web.dev/cls/)을 줄이기 위해 자동 fallback 폰트를 사용해야 하는지 여부를 설정하는 부울 값입니다. 기본값은 `font`입니다.
- `@next/font/local`의 경우: [누적 레이아웃 이동](https://web.dev/cls/)을 줄이기 위해 자동 fallback 폰트를 사용해야 하는지 여부를 설정하는 문자열 또는 부울 값(`false`)입니다. 가능한 값은 `Arial`, `Times New Romans`, `false` 입니다. 기본값은 *Arial*입니다.

`@next/font/google`과 `@next/font/local`에서 사용

*예제*
- `adjustFontFallback: false`: `@next/font/google` 용
- `adjustFontFallback: 'Times New Romans'`: `@next/font/local` 용

## variable `선택적`
[CSS 변수 메소드](https://beta.nextjs.org/docs/api-reference/components/font#css-variables)로 스타일을 적용할 경우 사용할 CSS 변수 이름을 정의하는 문자열 값

`@next/font/google`과 `@next/font/local`에서 사용

*예제*
- `variable: '--my-font'`: CSS 변수 `--my-font`가 선언되었습니다

## declarations
생성된 @font-face를 추가로 정의하는 [폰트 설명자](https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face#descriptors)(키-값 쌍)의 배열입니다.

`@next/font/local`에서 사용

*예제*
- `declarations: [{ prop: 'ascent-override', value: '90%' }]

# 스타일 적용
다음 세 가지 방법으로 폰트 스타일을 적용시킬 수 있습니다.
- [className](https://beta.nextjs.org/docs/api-reference/components/font#classname)
- [style](https://beta.nextjs.org/docs/api-reference/components/font#style)
- [CSS Variables](https://beta.nextjs.org/docs/api-reference/components/font#css-variables)

## className
HTML 엘리먼트에 전달할 로드된 폰트에 대한 read-only CSS className을 리턴합니다.
```tsx
<p className={inter.className}>Hello, Next.js!</p>
```

## style
Font Family 이름 및 대체(fallback) 폰트에 액세스하기 위한 `style.fontFamily`를 포함 HTML 엘리먼트에 전달할 로드된 폰트에 대한 read-only CSS `style` 객체를 리턴합니다.
```tsx
<p style={inter.style}>Hello World</p>
```

## CSS Variables
외부 스타일 시트에서 스타일을 설정하고 추가 옵션을 지정하려면 CSS Variables를 사용하세요.
폰트 가져오기 외 CSS variables가 정의된 CSS 파일도 가져오고 font loader 객체의 변수 옵션을 다음과 같이 설정합니다.
```tsx
import { Inter } from '@next/font/google';
import styles from '../styles/component.module.css';

const inter = Inter({
  variable: '--font-inter',
});
```

폰트를 사용하려면 스타일을 지정하려는 텍스트의 부모 컨테이너의 `className`을 font loader의 `variables` 값으로 설정하고 텍스트의 `className`을 외부 CSS 파일의 `style` 속성으로 설정합니다.
```tsx
<main className={inter.variable}>
  <p className={styles.text}>Hello World</p>
</main>
```

다음과 같이 `component.module.css` 파일에서 `text` 셀렉터 클래스를 정의합니다.
```css
.text {
  font-family: var(--font-inter);
  font-weight: 200;
  font-style: italic;
}
```

위 예제에서 텍스트 `Hello World`는 *Inter 폰트*, *font-weight: 200*, *font-style: italic*으로 생성된 대체(fallback) 폰트를 사용해 스타일이 지정됩니다.

Next.js 13 API Reference - Font

Next.js 13 API Reference - Image

`<Link>` 컴포넌트는 HTML `<a>` 엘리먼트를 확장하여 각 라우터간 [prefetch](https://beta.nextjs.org/docs/routing/linking-and-navigating#prefetching) 및 클라이언트 사이드 탐색을 제공하는 리액트 컴포넌트입니다.
*Next.js*에서 각 라우터 사이를 탐색하는 기본 방법입니다.

*app/page.tsx*
```tsx
import Link from 'next/link';

export default function Page() {
  return <Link href="/dashboard">Dashboard</Link>
}
```

# Props
아래 표는 `<Link>` 컴포넌트에 사용할 수 있는 Props 요약입니다.
| Prop | Example | Type | Required |
| --- | --- | --- | --- |
| [href](https://beta.nextjs.org/docs/api-reference/components/link#href) | `href="/dashboard"` | String or Object | Yes |
| [replace](https://beta.nextjs.org/docs/api-reference/components/link#replace) | `replace={false}` | Boolean | - |
| [prefetch](https://beta.nextjs.org/docs/api-reference/components/link#prefetch) | `prefetch={false}` | Boolean | - |

> 알아두면 좋은 점: `<a>` 태그 속성은 `<Link>`에 *Props*로 추가할 수 있습니다. 예: **className** 또는 **target="_blank"** 는 렌더링 시 기본 `<a>` 태그로 전달됩니다.

## href
탐색할 경로 또는 URL 입니다. 이 값은 상대 경로입니다. 절대경로(예: *acme.com*)는 일반 `<a>` 태그를 대신 사용해야 합니다.
**href**는 아래와 같이 객체도 허용합니다.
```tsx
// /about?name=test 로 이동
<Link
  href={{
    pathname: '/about',
    query: { name: 'test' },
  }}
>
  About
</Link>
```

## replace
기본 값은 **false** 입니다. **true**일 경우 `next/link`는 [브라우저 히스토리](https://developer.mozilla.org/en-US/docs/Web/API/History_API) 스택에 새 URL을 추가하는 대신 현재 히스토리 상태를 대체합니다.

*app/page.tsx*
```tsx
import Link from 'next/link';

export default function Page() {
  return <Link href="/dashboard" replace>Dashboard</Link>
}
```

## prefetch
기본 값은 **true** 입니다. **true**인 경우 `next/link`는 백그라운드에서 페이지를 `prefetch` 합니다. 이는 클라이언트 사이드 탐색 성능을 향상시키는데 유용합니다. *Viewport$초기 또는 스크롤을 통해$*의 모든 `<Link />`가 미리 로드됩니다.
`prefetch={false}`를 전달해 `prefetch`를 비활성화할 수 있습니다. `prefetch`가 비활성화 상태일 경우 **마우스 오버$hover$**시 `prefetch`가 계속 발생합니다. `prefetch`는 오직 프로덕션 모드에서만 사용 가능합니다.

*app/page.tsx*
```tsx
import Link from 'next/link';

export default function Page() {
  return <Link href="/dashboard" prefetch={false}>Dashboard</Link>
}
```

# Legacy Props
- `as`
	- `app` 디렉토리에서 URL을 마스킹하는 개념은 [고급 라우팅 패턴](https://beta.nextjs.org/docs/routing/fundamentals#advanced-routing-patterns)으로 처리됩니다. `pages` 디렉토리의 이전 동적 라우팅과의 호환성을 위해 `<Link>` 컴포넌트에 **props**로 전달할 수 있습니다. 하지만 이제 동적 세그먼트를 `href props`에 전달할 수 있으므로 `app` 디렉토리에서 `as`를 사용하는 것은 권장되지 않아요.
- `legacyBehavior`
	- `<a>` 엘리먼트는 더 이상 `<Link>` 컴포넌트의 자식으로 필요하지 않습니다. 레거시 동작을 계속해서 사용하려면 `lecacyBehavior Props`를 추가하고 업그레이드 하려면 `<a>` 태그를 제거하세요. **codemod**를 사용해 코드를 자동 업그레이드 할 수 있습니다.
- `passHref`: `<Link>`는 올바른 *href*로 `<a>` 엘리먼트를 렌더링하므로 필요하지 않습니다. 여기에는 다음과 같은 경우가 포함됩니다.
	- *\<Link href="/about"\>About\</Link>*
    - *\<Link href="/about"\>\<CustomComponent /\>\</Link>*
    - *\<Link href="/about"\>\<strong\>About\</strong\>\</Link>*

Next.js 13 API Reference - Link

Next.js 13은 레이아웃, 중첩 라우팅, 로딩 상태, 에러 처리 등을 지원하는 리액트 서버 컴포넌트 위에 구축된 새로운 파일 시스템 기반 라우터를 도입했습니다.
# Terminology
![](https://image.dnkdream.com/20221203_2053Sa_terminology-component-tree.webp)
- `Tree` : 계층 구조를 시각화하기 위한 규칙입니다. 예를 들어, 부모 및 자식 컴포넌트가 있는 컴포넌트 트리, 폴더 구조 등이 있습니다.
- `Subtree` : 새 루트(첫 번째)에서 시작, Leaf(마지막)에서 끝나는 트리의 일부입니다.
- `Root` : 루트 레이아웃과 같은 트리 또는 하위 트리의 첫 번째 노드입니다.
- `Leaf` : URL 경로의 마지막 세그먼트와 같이 자식이 없는 하위 트리의 노드입니다.


![](https://image.dnkdream.com/20221203_2053Sa_terminology-url-anatomy.webp)
- URL Path : 도메인 뒤에 오는 URL의 일부입니다.
- URL Segment : 슬래시로 구분된 URL 경로의 일부입니다.

# app 디렉토리
새 라우터는 app 이라는 새 디렉토리에서 작동합니다. app 디렉토리는 점진적 채택을 허용하기 위해 pages 디렉토리와 함께 작동합니다. 이를 통해 애플리케이션의 일부 경로를 새 동작으로 선택하고 다른 경로는 이전 동작에 대해 pages 디렉토리에 보관할 수 있습니다.
> 알아두면 좋은 점 : 디렉토리 간 경로는 동일한 URL 경로로 확인되어서는 안되며 충돌을 방지하기 위해 빌드시 오류가 발생합니다.

![](https://image.dnkdream.com/20221203_2054Sa_app-folder-page-folder.webp)
기본적으로 앱 내부의 컴포넌트는 리액트 서버 컴포넌트입니다. 이것은 성능 최적화이며 이를 쉽게 채택할 수 있습니다. 하지만 클라이언트 컴포넌트를 사용할 수도 있습니다.
> 권장사항 : 서버 컴포넌트를 처음 사용하는 경우 [서버 및 클라이언트 컴포넌트 페이지](https://beta.nextjs.org/docs/rendering/server-and-client-components)를 확인하세요.

# app 내부 폴더와 파일들
- 폴더는 경로를 정의하는데 사용됩니다. 경로는 루트 폴더에서 최종 리프 폴더까지 계층 구조를 따르는 중첩 폴더의 단일 경로입니다.
- 파일은 경로 세그먼트에 대해 표시되는 UI를 만드는데 사용됩니다. [특수 파일](https://beta.nextjs.org/docs/routing/fundamentals#special-files)을 참조하세요.

# 라우트 세그먼트
라우트의 각 폴더는 경로 세그먼트를 나타냅니다. 각 경로 세그먼트는 URL 경로의 해당 세그먼트에 매핑됩니다.
![](https://image.dnkdream.com/20221203_2056Sa_route-segments-to-path-segments.webp)

# 중첩된 라우트
중첩된 라우트를 만들려면 폴더를 서로 중첩합니다. 예를 들어 app 디렉토리에 두 개의 새 폴더를 중첩하여 /dashboard/settings 경로를 추가할 수 있습니다.

/dashboard/settings 경로는 세 개의 세그먼트로 구성됩니다.

- / 루트 세그먼트
- dashboard 세그먼트
- settings 리프 세그먼트

# 특수 파일들
Next.js는 라우트에서 사용할 수 있는 일련의 특수 파일들을 제공합니다. 다음과 같습니다.
![](https://image.dnkdream.com/20221203_2057Sa_special-files.webp)
- page.tsx : 경로의 고유한 UI를 정의하고 경로를 공개적으로 액세스할 수 있도록 만드는 파일
- layout.tsx : 여러 페이지에서 공유되는 UI를 정의하는데 사용되는 파일, 레이아웃은 다른 레이아웃이나 페이지를 자식으로 받아들입니다. 레이아웃을 중첩하여 중첩 경로를 만들 수 있습니다.
- loading.tsx : 앱의 특정 부분에 대한 로딩 UI를 생성하는데 사용되는 선택적(옵션) 파일입니다. React Suspense Boundary에서 페이지 또는 하위 레이아웃을 자동으로 래핑하여 첫 번째 로드 시 및 형제 경로 사이를 탐색할 때 로드 컴포넌트를 즉시 표시합니다.
- error.tsx : 에러를 앱의 특정 부분으로 격리하고 특정 에러 정보를 표시하고 복구를 시도하는 기능에 사용되는 선택적(옵션) 파일입니다. React Error Boundary에서 페이지 또는 하위 레이아웃을 자동으로 래핑합니다. 하위 트리에서 에러가 발견될 때마다 에러 컴포넌트를 표시합니다.
- template.tsx : 레이아웃과 유사하지만 탐색 시 컴포넌트의 새 인스턴스가 마운트되고 state가 공유되지 않는 선택적(옵션) 파일입니다. 애니메이션 시작/종료와 같이 이 동작이 필요한 경우 템플릿을 사용할 수 있습니다.
- head.tsx : 주어진 경로에 대한 &lt;head&gt; 태그의 내용을 정의하는데 사용되는 선택적(옵션) 파일입니다.

> 알아두면 좋은 정보 : js, jsx, tsx 파일 확장자는 특수 파일에 사용할 수 있습니다. ts는 지원 안 됨

# Colocation
특수 파일 외에도 폴더 내 자신의 파일을 함께 배치할 수 있는 옵션이 있습니다. 예를 들어 스타일시트, 테스트, 컴포넌트 등이 있습니다.
![](https://image.dnkdream.com/20221203_2058Sa_collocating-assets-in-the-app-directory.webp)

# 클라이언트 측 탐색을 통한 서버 중심 라우팅
클라이언트 측 라우팅을 사용하는 pages 디렉토리와 달리 app 디렉토리의 새 라우터는 서버 중심 라우팅을 사용하여 서버 컴포넌트 및 서버의 데이터 가져오기에 맞춥니다. 서버 중심 라우팅을 사용하면 클라이언트는 경로 맵을 다운로드 할 필요가 없으며 서버 컴포넌트에 대한 동일한 요청을 사용하여 경로를 조회할 수 있습니다. 이 최적화는 모든 애플리케이션에 유용하지만 경로가 많은 애플리케이션에 더 큰 영향을 미칩니다.

라우팅은 서버 중심이지만 라우터는 SPA 동작과 유사한 Link 컴포넌트와 함게 클라이언트 측 탐색을 사용합니다. 즉, 사용자가 새 경로로 이동할 때 브라우저가 페이지를 다시 로드하지 않습니다. 대신 URL이 업데이트되고 Next.js는 변경된 세그먼트만 렌더링합니다.

또한 사용자가 앱을 탐색할 때 라우터는 리액트 서버 컴포넌트 페이로의 결과를 메모리 내 클라이언트 측 캐싱에 저장합니다. 캐시는 모든 수준에서 무효화를 허용하고 동시 렌더링에서 일관성을 보장하는 경로 세그먼트로 분할됩니다. 이는 특정한 경우에 이전에 가져온 세그먼트의 캐시를 재사용하여 성능을 더욱 향상시킬 수 있음을 의미합니다.

[Link, Navigation 페이지](https://beta.nextjs.org/docs/routing/linking-and-navigating)를 확인하여 Link 컴포넌트 사용법을 확인하세요.

# 부분 렌더링
형제 경로 사이를 탐색할 때 Next.js는 변경되는 경로의 레이아웃과 페이지만 가져오고 렌더링합니다. 하위 트리의 세그먼트 위에 있는 항목을 다시 가져오거나 다시 렌더링하지 않습니다. 이는 레이아웃을 공유하는 경로에서 사용자가 형제 페이지 사이를 탐색할 때 레이아웃이 유지됨을 의미합니다.
![](https://image.dnkdream.com/20221203_2059Sa_partial-rendering.webp)
부분 렌더링이 없으면 탐색할 때마다 전체 페이지가 서버에서 다시 렌더링됩니다. 업데이트 중인 세그먼트만 렌더링하면 전송되는 데이터의 양과 실행 시간이 줄어들어 성능이 향상됩니다.

# 고급 라우팅 패턴
앞으로 Next.js 라우터는 고급 라우팅 패턴을 구현하는데 도움이 되는 일련의 규칙을 제공할 것입니다. 여기에는 다음이 포함됩니다.

- 병렬 경로
    - 독립적으로 탐색할 수 있는 동일한 뷰에서 둘 이상의 페이지를 동시에 표시할 수 있습니다. 자체 하위 탐색이 있는 분할 뷰에 사용할 수 있습니다. (예: 대시보드)
- 가로채기 경로
    - 경로를 가로채 다른 경로의 컨텍스트에 표시할 수 있습니다. 현재 페이지의 컨텍스트를 유지하는 것이 중요할 때 사용할 수 있습니다. 예를 들어 하나의 작업을 편집하거나 피드에서 사진을 확장하는 동안 모든 작업을 봅니다.
- 조건부 경로
    - 조건에 따라 경로를 조건부로 렌더링할 수 있습니다. 예를 들어 사용자가 로그인한 경우에만 페이지를 표시합니다.

이러한 패턴과 규칙을 통해 Next.js 애플리케이션에서 더 풍부하고 복잡한 UI를 구축할 수 있습니다.

아직까진 베타 버전이라 실 적용은 힘들겠지만 빨리 정식으로 나와 써보고 싶네요 ㅎㅎ

Next.js 13 Routing Fundamentals

Next.js 13 Conf

이전 포스트에서 적었듯이 이번엔 리믹스를 이용해서 랜덤 한줄 농담을 뿜어주고 등록하는 웹을 만들어볼 예정입니다.이는 리믹스 공식 홈페이지 튜토리얼에 있는 내용이며, 이를 통해서 리믹스 내에서 제공하는 API의 개요를 확인할 수 있습니다.

이 튜토리얼은 타입스크립트를 사용합니다.타입스크립트를 사용할 때 리믹스는 더욱 좋아집니다. 특히나 SQLite 데이터베이스에서 데이터 모델에 엑세스를 하는 용도로 [Prisma](https://www.prisma.io/)를 사용할 예정이기 때문에 타입스크립트가 더욱 더 좋습니다.

이번 튜토리얼은 아래와 같은 순서로 작성됩니다.

🐷 리믹스 프로젝트 생성
🐷 리믹스 프로젝트 기존 파일
🐷 라우트 (중첩 경로 포함)
🐷 스타일링
🐷 데이터베이스 상호 작용
🐷 뮤테이션 및 검증 (Validation)
🐷 인증 (Authentication)
🐷 에러 핸들링
🐷 메타 태그가 있는 SEO
🐷 리소스 경로
🐷 자바스크립트
🐷 Optimistic UI
🐷 배포 (Deployment)

기존에는 리믹스 공식 홈페이지 내 `Tutorial` 중 하나인 *App Tutorial(long)* 을 작성하려 했으나 공식 Docs를 먼저 번역해보려고 합니다.

Jokes App with Remix

Remix 는 사용자 인터페이스에 집중하고 웹 표준을 지키며 빠르고 매끄럽고 탄력적인 사용자 경험**UI**를 제공할 수 있는 풀 스택 웹 프레임워크입니다.

> 참고 : [fustbit Samuel Torimiro 님 글](https://fusebit.io/blog/remix-react-framework/?utm_source=www.google.com&amp;utm_medium=referral&amp;utm_campaign=none)

리액트 내지는 기타 자바스크립트 라이브러리 및 프레임워크를 사용하면 **CSR(클라이언트 사이드 렌더링)** 웹을 빌드할 수 있습니다.
이는 사용자가 웹을 처음 방문하면 자바스크립트가 필수 기능들을 처리할 때까지 빈 페이지가 표시됨을 의미합니다. 이로 인해 사용자 경험(UX)이 저하될 수 있으며 또한 클라이언트에서 HTML을 처리하여 검색엔진최적화(SEO)가 원활히 이루어지지 않습니다.
리믹스는 *서버에서 HTML을 렌더링 한 후* 브라우저에 보내주기 때문에 뛰어난 SEO 성능을 보여줍니다. 또한 리믹스는 Mutation, Data fetching 등을 위한 Form 을 처리하는데 편리한 기능들을 제공합니다.

# 다른 리액트 프레임워크
다른 리액트 프레임워크들은 성능이 좋은 리액트 앱을 빌드하는데 충분히 도움이 됩니다. 가장 인기있는 프레임워크 중 하나는 Next.js를 꼽을 수 있습니다. 하지만 리믹스는 이에 비해 배울 가치가 있는 몇 가지 고유한 기능을 제공합니다.
다음은 라우팅을 처리하는 방법에 따라 리믹스와 다른 프레임워크를 비교한 것입니다.

## 라우팅
웹 사이트는 일반적으로 정적(Static) 또는 동적(Dynamic) 컨텐츠를 렌더링하는 여러 페이지로 구성되기 때문에 라우팅 또는 웹사이트의 다른 페이지를 탐색하는 프로세스는 매우 중요한 기능입니다. 리믹스와 넥스트 모두 파일 기반 라우팅을 지원하며, 파일을 생성하면 브라우저를 통해 즉시 액세스할 수 있습니다.
예를 들어 리믹스에서 새 프로젝트를 만들 때 route 폴더 안에 새 파일을 만들 수 있습니다. 두 프레임워크는 CSR(클라이언트 사이드 렌더링) 또한 탐색(새로고침 없는 이동)과 동적 라우팅을 지원합니다.
리믹스에서는 파일 이름 앞에 $ 기호로 명명된 매개변수를 추가하여 이를 수행합니다.
리믹스는 눈에 띄는 곳은 중첩 라우팅을 사용합니다. 넥스트는 파일 관점에서 중첩 라우팅을 지원하지만 리믹스는 각 라우팅의 하위 파일이 표시되어야 하는 위치를 결정할 수 있는 별도의 파일인 라우트의 계층을 생성할 수 있습니다.
즉, 판 페이지 내에서 여러 라우팅을 활성화 할 수 있습니다.

> 참고 : 리믹스의 라우트는 컴포넌트를 export 하는 파일을 의미합니다.

*예제 : posts.jsx*
```jsx
import { Outlet } from '@remix-run/react';

export default function Posts() {
  return (
    <div>
      <h1>포스트 목록 라우트입니다.</h1>
      <Outlet />
    </div>
  );
}
```

이후 posts 라는 폴더를 생성하면 그 폴더의 각 파일들은 상위 라우트인 posts.jsx 파일에 명시된 Outlet 내부에 중첩(nested)될 수 있습니다.
new.jsx 라는 파일을 이 폴더 안에 생성한다고 가정해 보겠습니다.
/posts/new 라우트로 이동하면 상위 라우트에 있는 컨텐츠가 new.jsx 라우트 컨텐츠로 대체됩니다.

## SSG &amp; SSR
SSG(정적 사이트 생성기)는 빌드 시 코드를 실행하고 CDN(컨텐츠 전송 네트워크)으로 배송하여 사용자에게 웹 사이트를 더 빠르게 전달 할 수 있습니다. 하지만 SSG 방식은 동적인 컨텐츠에서는 문제가 될 수 있습니다. 또한 정적 파일과 자산(assets)이 많은 경우 변경될 때마다 사이트를 다시 빌드하는데 시간이 많이 걸릴 수 있습니다.
Cloudflare Workers, Deno Deploy, AWS Lambda와 같은 서비스를 사용해 웹을 배포하는 경우 데이터가 사용자와 가깝기 때문에 SSG가 덜 중요하게 됩니다.
리믹스는 서버에 데이터를 로드하고, 전체 HTML 파일을 생성해 브라우저로 다시 보내는 SSR(서버 사이드 렌더링)에 중점을 둡니다.
넥스트는 여전히 SSG로 정적 페이지를 구성하고 SSR 로 동적 컨텐츠 구축하는 것을 권장합니다. 이것은 정적 사이트 생성 프레임워크인 Gatsby와 유사합니다.
하지만 브라우저에서 리믹스를 실행할 수 있고 최신 데이터를 가질 수 있으므로 리믹스와 함께 SSG를 사용할 필요는 없습니다.

## Data Fetching
웹 사이트를 동적으로 만들려면 내부적으로 생성되었거나 타사 제공업체에서 얻은 API 또는 데이터베이스에서 데이터를 가져옵니다. 리믹스는 이 프로세스를 단순화 합니다.
리믹스는 서버에서 코드를 실행하기 때문에 데이터도 서버에서 가져옵니다. 이것은 loader 라는 특정 함수를 사용하여 정의됩니다. 데이터는 서버에서 가져오기 때문에 브라우저로 다시 보내는 내용을 조작할 수 있게 됩니다.
모든 데이터를 보낼 필요가 없으므로 원하는 방식으로 수정하고 필요한 만큼만 클라이언트에 다시 보낼 수 있습니다. 이에 따라 전송되는 총 데이터 양이 줄어들기 때문에 사용자 경험(UX)가 향상됩니다.

*예제: posts.tsx*
```jsx
import { json } from '@remix-run/{runtime}';
import { useLoaderData } from '@remix-run/react';

export const loader = async () => {
  return json([
    { id: "1", title: "첫번째 제목" },
    { id: "2", title: "두번째 제목" },
  ]);
};

﻿export default function Posts() {
  const posts = useLoaderData();
  
  return (
    <div>
      <h1>포스트 목록</h1>
      {posts.map((post) => (
        <div key={post.id}>{post.title}</div>
      ))}
    </div>
  );
};
```

위 코드에서 loader 함수는 데이터를 가져오고 useLoaderData 훅으로 서버에서 실행되는 컴포넌트의 데이터에 액세스 합니다.

> 라우트의 기본 함수는 항상 컴포넌트입니다

대조적으로 넥스트는 getStaticProps 또는 getServerSideProps 등을 사용하여 컴포넌트에 데이터를 로드하는 방법을 제공합니다.

## Form 핸들링
웹을 만들 때 데이터를 변경(mutate)하는 방법이 필요합니다.
리믹스는 브라우저가 양식을 처리하는 방법을 이해하기 때문에 이를 간단히 만들 수 있습니다.
다른 리액트 프레임워크와 달리 리믹스는 기본 브라우저 기능을 따르므로 폼을 제출 할 때 자바스크립트가 필요하지 않습니다. 다만 폼 제출을 향상시키기 위해서 자바스크립트를 사용합니다.

리믹스 폼 예제 
```jsx
import { Form } from '@remix-run/react';

...
  return (
    <Form method="post">
      <input type="text" name="title" />
      <input type="text" name="body" />
      <button type="submit">생성</button>
    </Form>
  );
...
```
  
리믹스에서는 HTML에서 네이티브 &lt;form&gt; 엘리먼트가 수행하는 작업을 하는 &lt;Form&gt; 태그가 있으며 일부 자바스크립트 개선사항이 포함되어 있습니다. 또한 리믹스는 동일한 파일에서 작업 기능을 제공합니다. 서버에서 실행되는 요청(request)를 받고 폼 데이터를 처리하는 역할을 합니다.
 
```jsx
import { redirect } from '@remix-run/{runtime}';

export async function action ({ request }) {
  const body = await request.formData();
  const post = await createPost(body);

  return redirect('/posts');
};
```

위 코드에서 Fetch API의 기본 요청 개체(request object)는 브라우저에서 제출된 폼 데이터를 가져옵니다. 폼 데이터를 얻으면 원하는 모든 작업을 수행할 수 있습니다. 이 코드는 createPost 라는 함수를 보여주고 리믹스에서 제공하는 리디렉션을 사용하여 사용자를 다른 페이지로 리디렉션 합니다.
넥스트에서 자바스크립트로 폼 제출 기능을 향상시키려면 event.preventDefault() 함수를 사용한 후 자바스크립트를 사용해 폼 데이터를 제출하기 위한 POST request 를 보내야 합니다.
리믹스는 이러한 추가 단계를 아끼므로 submit 버튼을 사용해 폼을 제출할 수 있습니다. 이에 따라 리믹스의 폼은 자바스크립트를 활성화하지 않고도 작동할 수 있습니다.

## 쿠키 &amp; 세션 지원
쿠키와 세션 등의 도움이 없이는 웹을 이용하는 특정 사용자를 추적하는 것이 불가능할 수 있습니다. 예를 들어 인증 기능이 있는 경우 사용자가 로그인에 성공하면 서버에서 브라우저로 쿠키를 보낼 수 있습니다.
리믹스는 createCookie, isCookie, createCookieSessionStorage, isSession과 같은 여러 API를 사용하여 쿠키 및 세션 관리를 지원합니다. 하지만 넥스트를 이용할 경우 이를 관리하기 위해 초보자 같은 서드파티 라이브러리 등을 이용해야 합니다.

## 에러, 인터럽트 등 처리
리믹스의 각 라우트에는 ErrorBoundary 라는 에러 함수가 있을 수 있습니다. 이에 따라 자식 컴포넌트가 에러를 렌더링하면 앱이 충돌하지 않습니다. 에러는 부모 컴포넌트가 예상대로 작동하는 동안에만 자식 컴포넌트에 대해 표시가 됩니다. 이는 중첩 라우트(nested routes)로 인해 각 파일이 다른 파일과 독립적이기 때문입니다.
넥스트에서 특정 라우트의 서버 에러가 생길 시 500 에러 발생으로 전체 UI가 작동하지 않게 됩니다.

다음은 리믹스 ErrorBoundary 함수의 예입니다.
```jsx
export function ErrorBoundary({ error }) {
  return (
    <div>
      <p>{error}</p>
    </div>
  );
};
```
라우트 모듈에 ErrorBoundary 함수가 없으면 다음 ErrorBoundary를 찾기 위해 상위로 버블됩니다.

이는 에러가 상황에 따라 달라질 수 있음을 의미합니다.
리믹스는 클라이언트에서 에러만 찾을 수 있는 리액트와 달리 클라이언트, 서버 모두에서 에러를 잡아낼 수 있습니다. 또한 한 번에 여러 POST 요청을 하려고 할 때 경쟁 조건(race condition)이 발생할 수 있습니다. 기본적으로 리믹스가 이를 처리하므로 오래된 데이터에 대한 걱정을 할 필요가 없습니다.

> 다음으로 가벼운 농담을 랜덤으로 보여주는 웹을 만들며 리믹스를 연습해 보겠습니다

Remix 리액트 프레임워크

# TS-4 썬더볼트 독 도착!
아기다리 고기다리던 썬더볼트4 독인 칼디짓의 TS-4 가 왔다... ㅜㅜ
이 얼마나 기다렸던가...
솔직히 TS-3 Plus도 잘 사용했었지만 약간씩의 불만이 있었는데 이번 TS-4는 나에게 딱 완벽하다 ㅋㅋ
![](https://image.dnkdream.com/220709_193207_405345e0d45fd7413420da20d)

## 구성품 살펴보기
![](https://image.dnkdream.com/220709_193240_405345e0d45fd7413420da20e)
구성품은 이전 작과 비슷하다, 아니 거의 똑같다고 해야 하나...?
눈에 띄는 변경점은 데이터 케이블이 썬더볼트3에서 썬더볼트4로 바뀌었다는 거?
계속해서 이전 작인 TS-3 Plus와 비교해보자

# 구성품 비교 TS3 Plus vs TS4
## 썬더볼트 케이블
![](https://image.dnkdream.com/220709_193354_405345e0d45fd7413420da20f)
사진에서 보이는 것과 같이 이번엔 썬더볼트4로 바뀌었다. 근데 케이블도 그렇고 본체도 그렇고 인쇄된 문자가 흐릿해졌다. 일부러 저렇게 한 건가....??

## 크기 및 포트 비교
![](https://image.dnkdream.com/220709_193536_405345e0d45fd7413420da210)
![](https://image.dnkdream.com/220709_193558_405345e0d45fd7413420da211)
![](https://image.dnkdream.com/220709_193630_405345e0d45fd7413420da212)
![](https://image.dnkdream.com/220709_193640_405345e0d45fd7413420da213)
보이는 것과 같이 좌측이 TS-4, 우측이 TS-3 Plus 이다.
내부 성능 비교는 나중에 작성해야지... 지금은 급하게 차 안에서 작성해봤다.. ㅋㅋ

TS-4 썬더볼트 독

장인은 도구를 탓하지 않는다... 는 말은 반은 맞지만 반은 틀린 말인 것 같다.. 적어도 내게는 ㅋㅋ
물론 도구를 탓할 이유는 없지만 도구를 잘 고르면 편의성 향상, 개발 시간 단축 등 여러모로 도움이 되는 건 사실이니까
내가 현재 집에서 사용 중인 데스크 셋업을 소개하고자 한다. 그다지 좋은 세팅이라고는 생각하진 않지만 적어도 나에겐 최선의 조건이다.

# 적절한 모니터
>현재 집에서 사용 중인 모니터는 어느 정도 게임도 겸하기 때문에 **LG Gear 27GN880 QHD 게이밍 모니터**로 선택했다.

![](https://image.dnkdream.com/220703_142148_405345e0d45fd7413420da206)

이 모니터는 4K 는 아니지만 *QHD, 27인치*이며 *144hz* 를 지원한다. *DCI-P3 98%의 색영역*을 갖고 있고 *nVidia G-Sync*를 지원한다(하지만 난 사용할 일이 없지 ㅋ)
*응답속도도 1ms* 로 딜레이 없는 작업을 보여준다. 개인적으로 매우 만족한다. 더불어 모니터 아래도 자리를 차지하지 않아 참 좋다!

# 썬더볼트 독 with Caldigit TS-3 Plus
현재 **맥북프로 M1 Pro 14인치**를 사용 중인데 맥 세이프 충전단자를 처음에는 잘 사용했는데 책상 구조를 보면 알겠지만 좌측 케이블, 우측 케이블 하나씩 나와 있으면 뭔가 기분이 멜랑꼴링 할 듯 하여 어차피 갖고 있는 썬더볼트 독 **칼디짓의 TS-3 Plus**를 연결했다.
이로써 썬더볼트 케이블 하나로 모든 연결이 가능하다. <span style="color:rgb(230, 0, 0)">(← 이게 정말 매우 편리하다)</span>
![](https://image.dnkdream.com/220703_143016_405345e0d45fd7413420da208)

*패쓰쓰루로 87와트 충전*도 지원하여 그냥 정말 저 케이블 하나면 된다. 현재 TS-4 (썬더볼트4)를 주문해 놓아 배송중인데 도착하면 TS-3 Plus는 사무실에 갖다 놓고 집에서는 TS-4를 쓸 예정이다.
참고로 *TS-4 는 98와트 패쓰쓰루*를 지원한다. 딱 내 맥북의 필요전력이다! <span style="color:rgb(230, 0, 0)">빨리 사용해 보고 싶다!</span>

![](https://image.dnkdream.com/220703_142924_405345e0d45fd7413420da207)

# 아이폰, 애플워치, 에어팟
![](https://image.dnkdream.com/220703_143128_405345e0d45fd7413420da209)
사진에서 보이듯이 아이폰, 애플워치, 에어팟 프로를 사용중인데 **벨킨의 3 in 1 충전기**를 사용 중이다. 이거 정말 편하다.
편하기도 편하지만 책상 위가 정리정돈 되는 느낌이라 너무 잘 사용 중이다.

## 듀얼센스(?)
![](https://image.dnkdream.com/220703_143229_405345e0d45fd7413420da20a)
데스크 셋업은 아니지만 가끔은 게임도 하면서 스트레스도 날려야 한다고 생각한다. 그래서 어떤 패드를 살까 고민하다 **듀얼센스**로 골랐다.
이것 저것 연결해 보니 <span style="color:rgb(230, 0, 0)">맥북에서 듀얼센스는 생각보다 연결이 정말 잘 되고 사용하는데 편하다!</span>
맥에서 게임한다는게 좀 웃기긴 하지만 생각보다 에뮬게임이 정말 잘 돌아간다 ㅋㅋㅋ
# 기타 키보드, 트랙패드
사진을 따로 찍진 않았지만 코딩할 때나 웹서핑, 파이널 컷 등을 사용할 때는 솔직히 마우스보다 저 미친 성능의 **매직 트랙패드**가 너무 좋다.
넓직해서 사용하기도 편하고 표면의 질감이나 클릭감, 움직임이 너무 우수해 즐겨 사용한다.

또한 키보드는 맥과 윈도우를 왔다갔다 할 수 있고 유선과 블루투스 연결을 병행할 수 있는 제품들 중 지금까지 사용해 본 경험에 의하면 **키크론 사의 키보드**가 나랑 정말 잘 맞아서 사용 중이다.
집에서는 소음과 관계가 없으니 청축을 사용, 회사에서는 적축을 사용하며 스위치 하나로 맥과 윈도우의 전환, 유선과 블루투스의 전환이 이루어져 너무너무 편하게 사용 중이다.
![](https://image.dnkdream.com/220703_143942_405345e0d45fd7413420da20b)

이렇게 내 데스크 셋업을 소개해 봤다. 데스크 셋업의 정석이란 건 없고 내가 사용하기 편하고 효율적이면 그게 최고지만 작업을 얼마나 빠르고 쾌적하게 불편함 없이 할 수 있게 구조를 잡느냐가 관건인 것 같다.
> 빨리 TS-4 가 왔으면....

개발 데스크 셋업

# 장마....
비가 어마무시하게 내린다.
그저께부터 오기 시작하더니 그치질 않네.. ㅜㅜ
새벽에 부모님 일을 돕다보니 비를 그대로 다 맞아야 하는데 시원해서 좋긴 하지만 빨래가 너무 밀린다...

창 밖에 비가 오는 걸 보면서 코딩을 하다보니 갬성(?)이 자극되어서 이런 저런 글을 찾아보다가 김다슬 작가님의 김다슬 에세이의 글귀를 몇 가지 보게 되었다.
별 말 아닌 것 같은 글귀가 너무 와닿는 글들이 많았다.
그 중에서 가장 갬성을 자극하는 글을 한 번 적어본다.

> 김다슬 작가님 "김다슬 에세이" 중...

# 평생동안 곁에 남을 진짜 친구는

## 1. 그냥 연락한다.
아무런 용건이 없이 통화해도 어색함이 없다.
필요할 때만 찾는 사람과는 근본적으로 다르다.

## 2. 전화 한 통에 기분이 풀린다.
어이없고 짜증나는 일도 친구와 통화 한 번이면 짜증, 불안, 화가 가라앉고 답답했던 속이 한결 나아진다.

## 3. 시시한 일상을 공유한다.
이런 사소한 것 까지 얘기하나 싶을 정도로 시시한 일을 함께 공유하는 것이 즐겁다.

## 4. 쓸데없는 얘기로 웃는다.
남이 보기엔 웃기지도 않고 이해할 수 없는 얘기도 둘 만의 코드가 잘 맞아서 빵빵 터지며 웃게 된다.

## 5. 나를 위해 준다.
모든 행동에 날 위하는 마음이 묻어 있다. 쓴 소리도 내 생각해서 따끔하게 하고, 힘들 때는 그저 들어주고, 슬프고 우울할 땐 곁에서 어떻게든 위로해준다.

인간관계는 대부분 필요와 이해로 얽혀 있다.
계산적인 관계들 사이에서 아이처럼 목적없이 순수한 관계인 친구가 있다면 삶의 보물같은 사람이다.
그 친구와의 우정을 평생 지킨다면 그것만으로 참 근사한 인생이 된다.
> 지금 떠오른 그 친구 말이다.

# 기분을 관리하면 인생이 관리된다
이 글귀가 들어있는 [책의 이름](http://www.yes24.com/Product/Goods/108624716)
이다.

비 오는 날 괜한 갬성(?) 폭발로 보게 된 글귀가 너무 가슴을 울린다.

![](https://image.dnkdream.com/220630_174710_405345e0d45fd7413420da204)

비가 많이 옵니다

이번에 제작한 이 블로그도 그렇고 예전부터 운영해오던 행사전표시스템도 마찬가지이지만 전부 페이징 전환이 없는 무한스크롤링(**Infinite Scroll**)을 사용하고 있다.
블로그 감성 때문에 페이징을 직접 클릭해 움직이는 것보단 아무래도 별 생각없이 쭈욱쭉 스크롤을 내리면서 글을 읽을 수 있는 점이 무한 스크롤의 큰 장점인데 예전에 구현할 때는 *Redux*, *Apollo* 와 *window의 스크롤 이벤트*를 활용해서 만들었 었고 이는 성능 하락의 원인이 되었었다. 이유는?

> 스크롤을 할 때마다 계속 *의미없는 체킹*을 하게 되니까...

그렇다면 이번엔 어떻게 구현을 할 것인가
바로 **react-query**의 **useInfiniteQuery**와 자바스크립트의 **Intersection Observer**를 통해서 구현을 해보고자 한다.
그럼 빠르게 구현해보자.

# 백엔드 설정 (koa.js)
백엔드는 항상 내가 애용하는 koa.js 로 작성했으며 다른 구조는 무시하고 api 호출만 기록하고자 한다.

*api.ts*
```jsx
import Router from 'koa-router';
import { dataSource } from '../server';
import Post from '../entities/Post';

const api = new Router();

async function listPostsAPI(ctx: Context) {
  type QueryType = {
    cursor?: string;
  };

  const { cursor }: QueryType = ctx.query;

  try {
    const postsRepo = await ﻿dataSource.getRepository(Post);
    const query = postsRepo.createQueryBuilder('posts')
      .limit(30)
      .orderBy('posts.created_at', 'DESC')
      .addOrderBy('posts.id', 'DESC');
    if (cursor) {
      const post = await postsRepo.findOneBy({ id: cursor });
      if (!post) {
        ctx.status = 404;
        ctx.body = '해당 포스트가 존재하지 않습니다.';
        ﻿return;
      };
      query.andWhere('posts.created_at < :date', {
        date: post.created_at,
      });
      query.orWhere('posts.created_at = :date AND posts.id < :id', {
        date: post.created_at,
        id: post.id
      });
    };
    const posts = await query.getMany();
    ctx.body = posts;
  } catch(err: any) {
    ctx.throw(500, err);
  }
};
```
*cursor* 를 **api query**로 받아서 그 이후의 포스트 목록을 30개를 반환하는 API이다.
그럼 이어서 프론트엔드를 작성해 보자.

# 프론트엔드 (Nextjs)
Next js, typescript를 사용할 거고 아래와 같이 설치한다.
```js
$ npx create-next-app infinite-scroll-posts --typescript
```
이어서 react-query 설치
```js
$ npm i react-query
```

그럼 이제 react-query를 Nextjs에서 사용하기 위한 설정을 하자.

*pages/_app.tsx*
```jsx
import type { AppProps } from 'next/app';
import { useState } from 'react';
import { QueryClient, QueryClientProvider, Hydrate } from 'react-query';
import { ReactQueryDevtools } from 'react-query/devtools';

function App({ Component, pageProps }: AppProps) {
  const [queryClient] = useState(() => new QueryClient());

  return (
    <QueryClientProvider client={queryClient}>
      <Hydrate state={pageProps.dehydratedState}>
        <Component {...pageProps} />
      </Hydrate>
      <ReactQueryDevtools initialIsOpen={false} />
    </QueryClientProvider>
  );
}

export default App;
```

이제 리액트 쿼리 기본 설정이 끝났으니 무한 스크롤을 위한 훅을 하나 만들자.

*hooks/useObserver.ts*
```jsx
import { useEffect, useState } from 'react';

interface Props {
  onIntersect: IntersectionObserverCallback;
  root?: null;
  rootMargin?: string;
  threshold?: number;
}

function useObserver({
  onIntersect,
  root,
  rootMargin = '0px',
  threshold = 0,
}: Props) {
  const [target, setTarget] = useState<HTMLElement | null | undefined>(null);

  useEffect(() => {
    if (!target) return;
    
    const observer: IntersectionObserver = new IntersectionObserver(
      onIntersect,
      { root, rootMargin, threshold }
    );
    observer.observe(target);
    return () => observer.unobserve(target);
  }, [onIntersect, root, rootMargin, target, threshold]);

  return { setTarget };
}

export default useObserver;
```

## Intersection Observer? 그게 뭐야?
![](https://image.dnkdream.com/220627_104839_405345e0d45fd7413420da202)
**MDN**에 나와있는 [Intersection Observer](https://developer.mozilla.org/ko/docs/Web/API/Intersection_Observer_API)의 설명이다.
따라서 편하게 생각하자면 다음과 같다.
대상으로 하는 녀석(*target*)을 **기기의 뷰포트**나 **특정 요소**가 <span style="color:rgb(230, 0, 0)">교차할 때 콜백함수를 실행</span>해 준다 정도로 이해하자
이 녀석을 이제 적용해 보자.

*pages/index.tsx*
```jsx
import type { NextPage } from 'next';
import { useMemo } from 'react';
import { useRouter } from 'next/router';
import { listPostsAPI } from '../api/posts';
import useObserver from '../hooks/useObserver';

const IndexPage: NextPage = () => {
  const router = useRouter();
  /*
	pageParam으로 백엔드 cursor 값으로 넣어주고
	다음 페이지의 cursor는 들어온 포스트 리스트의 마지막 -1 아이디로 지정하여 api 호출﻿
  */
  const { data, fetchNextPage } = useInfiniteQuery(
    'posts',
    ({ pageParam }) => listPostsAPI({ cursor: pageParam }),
    {
      getNextPageParam: (data) =>
        data && data.length === 30 ? data[data.length - 1].id : undefined,
      enabled: true,
    }
  );

  /*
	포스트의 내용을 계속 이어 붙여줘야 하기 때문에 concat 함수를 사용
	data의 불필요한 연산을 방지하기 위해 useMemo로 저장
  */
  const posts = useMemo(() => {
    if (!data) {
      return [];
    }
    return ([] as PostType[]).concat(...data.pages);
  }, [data]);

  const onReadPost = (id: string) => {
    router.push(`/post/${id}`);
  };

  const onIntersect: IntersectionObserverCallback = ([entry]) => {
    entry.isIntersecting && fetchNextPage();
  };

  const { setTarget } = useObserver({ onIntersect });

  return (
    <div>
      <h2>포스트 목록</h2>
      {posts &&
        posts.length > 0 &&
        posts.map((post) => (
          <div key={post.id} onClick={() => onReadPost(post.id)}>
            {post.title}
          </div>
        ))}
      <div ref={setTarget} />
    </div>
  );
};

export default IndexPage;
```

# 라우터 이동 위치 기억
보통 블로그를 생각해보면 <span style="color:rgb(230, 0, 0)">라우터 또는 next/link</span>를 이용하여 포스트 제목을 클릭하고 포스트의 세부 내용을 본 다음 다시 뒤로 즉, *router.back()* 을 하게 마련이다.
이 경우 <span style="color:rgb(230, 0, 0)">현재까지 스크롤이 되어 있던 위치가 사라지게 되므로</span> 다시 처음부터 스크롤이 시작될 거다.
이건 너무 사용자 경험에 있어서 불편함을 주기 때문에 **위치를 기록해 주는 방법**을 마련하자.
```js
$ npm install use-local-storage
```
로컬 스토리지를 간편하게 사용하게 해주는 라이브러리이다.
그럼 아래와 같이 코드가 변경된다.

*pages/index.tsx*
```jsx
...
import useLocalstorage from 'use-local-storage';

const IndexPage: NextPage = () => {
  const [scrollY, setScrollY] = useLocalstorage('posts_list', 0);

  // 생략...
  const onReadPost = (id: string) => {
    setScrollY(window.scrollY);
    router.push(/post/<span class="hljs-subst">${id}</span>);
  };

  useEffect(() => {
    if (scrollY !== 0) window.scrollTo(0, Number(scrollY));
  }, []);

  // 생략...
  return (
    <div>
      <h2>포스트 목록</h2>
      {posts && posts.length > 0 && (
        posts.map(post => (<div key={post.id}>{post.title}</div>)
      ))}
      <div ref={setTarget} />
    </div>
...
```

*onReadPost* 라는 함수로 포스트 내용 보기 페이지로 이동할 때 **setScroll** 로 현재의 스크롤을 저장해주고 이후 라우터를 뒤로 돌려봐도 위치가 **posts_list** 로컬스토리지 값에 기록되어 있으므로 자동으로 그 위치로 돌아가게 된다.

React-query Infinite Scroll

# 나는 개발자가 아니다
어린 시절 게임 개발을 하고 싶어 헌책방에서 C언어 책들을 사서 읽곤 했었는데, 당시 부모님께서 컴퓨터를 구매해 주지 않으셔서 공부를 제 때 못해 장래 희망이었던 프로그래머를 접게 되었다.
이후 정처없이 살다가 군 입대 후 부사관으로 지원하여 14년의 군생활을 마치고 전역하여 현재 다니는 직장(회사)에 오게 되었다.

## 적성?? 흥미??
적성과 흥미는 엄연히 다른 것이지만 현역 시절 군수 업무를 맡아 했어서 그런지 현재 이 회사에서 하는 업무(군수 관련 업무)는 정말 편하고 익숙하여 좋기는 하지만 너무너무.... 재미가 없다!!!!
좋아하는 분야에서 직업을 갖는다는 건 꿈만 같은 일이겠지만 사실 그런 분들을 볼 때마다 참 부럽기도 하고 난 왜 저리 열정적이지 못할까 많이 자책을 한다. 물론 지금 이순간도...
지금 이런 블로그를 스스로 개발해서 내가 좋아하던 프로그래밍 공부를 다시금 할 수 있는 것만 해도 참 행복한 일이지만 업무, 개인적인 일, 가족 관계, 친구 관계를 유지하며 중간중간 해 나간다는 것이 생각만큼 쉽지 않지만 사실 누군들 안 그런가??

# 징징(핑계) vs 정당한 불만

사실 나는 성실하다(ㅋㅋㅋㅋ....)
내 입으로 말해 뭐하긴 하지만 일에 집중할 때에는 정말 앞 뒤 안 재고 일만 할 정도로 빠져서 한다.
이게 엄청난 장점이자 단점이 되는데, 남들 다 갖는 취미 생활 하나 제대로 가지지 못하고 사람들과의 교류(동아리 같은)도 자주 하지 못하는... (알콜 매니아인데!!)

> 난 참 재미없는 인생을 살고 있다.

# 기회인가? 아니면 단순 취미인가
그렇게 무기력하게 지내오던 중 갑자기 나의 흥미를 잡아 끄는 일이 생겼다. 바로 웹 코딩이었다.
뜬금 웹 코딩을 하게 되었던 계기는 전역 후 8개월 간 휴식을 했었는데 그 중 했던 와우 라는 게임이었다.
![](https://image.dnkdream.com/220615_141735_ba531520754442c329d386a0c)

이 와우라는 게임에서 한 길드에 들어가게 되었는데, 너무나 가족같은 분위기, 친밀감에 자주 정모도 하고 번개도 하며 나이가 웬만큼 먹었는데 게임 때문에 누구를 만나 친해진다는 게 신기하기도 하여 너무 재밌게 생활했었다.
그러던 중 우리 길드를 홍보해 보고 싶은 생각이 들어 열심히 구글링하여 길드 홈페이지를 만들고, 다시 그 홈페이지를 직접 운영해보고 싶어 라즈베리파이로 웹 서버를 구축하여 이것저것 삽질(?) 을 해본 것이 개발의 시작이었다.

# 개발 언어의 선택(선택장애 OTL)
웹 코딩을 하려고 달려들어보니 사용할 수 있는 언어, 프레임워크가 너무 무궁무진하더라.
친한 동생(사실 군 간부 시절 데리고 있던 병사ㅋ)이 백앤드 개발자인데

> 형 리액트 함 해봐용

이라는 말에 자바스크립트도 공부하지 않은 상태로 뛰어들었었다.
결과는 ㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎ ㅜㅜ
한글로 된 자료도 별로 없던 시절, 구글링을 열심히 하고 Velopert(김민준)님, Nomad coder님 등의 자료들을 죽어라 공부해가며 이것 저것 만들어본 결과 지금은 간단한 쇼핑몰 정도는 구축할 정도가 되었다. 하하핫!

# 행사전표시스템(KoaJS, NextJS)
현재 내가 다니고 있는 회사는 연회(파티), 웨딩, 컨벤션 등을 주로 하는 곳으로 각 홀 담당자들이 대금 결제를 위한 빌지(영수증)를 손으로 적어서 인포메이션에 내려가 결제를 진행하는 것을 보았다.

> 아니 요즘같은 IT 시대에 이 무슨... ㅡ,.ㅡ;

그러던 중 우리 부장님이 "웹 만들 줄 아시는 것 같던데, 전표 폰으로 작성할 수 있게 해주고 인포에서 출력할 수 있게 해주면 좋지 않을까요? ^^" 라고 하여 뜬금 개발하기 시작한 행사전표시스템
지금은 꽤나 버전이 올라가 5.1버전으로 운영중이고, 처음엔 Express 서버에 ejs 템플릿으로 만들었다가, Koa 서버에 React 로 리팩토링, 또다시 graphql로 리팩토링, 이후 현재는 @reduxjs/toolkit 이 나와 운영중에 있다.
다시 버전업을 계획하고 있으며 다음 버전은 react-query를 사용할 예정이다. (현재 이 블로그가 react-query ㅋㅋ)

# React-Native
리액트를 보다보니 욕심이 생겨 앱 제작도 해보고 싶었다. 하지만 요즘 대세라는 Flutter 는 여태껏 내가 공부해온 언어와 스타일이 너무 달라서 달려들지를 못했고, 같은 페이스 북에서 제작한 React-Native를 이용하여 앱을 두어번 만들어봤고, 실제 출시도 2번 했다. ㅋㅋㅋ
창피해서 어디 보여줄 수준은 안되지만 이것 또한 좋은 경험이 되리라!
![](https://image.dnkdream.com/220615_142850_ba531520754442c329d386a0d)

# 결론(?)
결론은 없다.
하하하하하하하핫...
개발자도 아니고 독학(구글링)으로 공부를 하다보니 막힐 때마다 참 답답하고 영어도 잘 못하니 매번 머리를 쥐어짜가며 고민하고 이런 방법 저런 방법 해보는데 이러다 성공하면 너무너무 기분이 좋다!!!! >ㅁ<
이 맛에 하는 건가 ㅋㅋ

아 일하기 싫다!!

# 급조된 여행
나는 회사 특성 상 토요일, 일요일 업무를 하고 월요일이 고정 휴일인데, 일요일 일을 하던 중 갑자기 펜션이 가고 싶어졌다 ㅋㅋㅋ

무슨 바람이 분 건지는 모르겠지만 평소 친한 직원들에게 같이 가자고 꼬시고 저녁에 급 출발을 했다.
시간도 늦은 시간이었고 예정되어 있지 않던 여행이라 서울에서 갈 만한 곳은 사실 강화도 밖에 없다고 생각해서 찾아보고 결정을 했다.

**여기어때**를 이용해서 예약을 했고 [석모도](https://namu.wiki/w/%EC%84%9D%EB%AA%A8%EB%8F%84)가 눈앞에 보이는 살짝 고지대의 펜션이었다.

![](https://image.dnkdream.com/220615_063654_ba531520754442c329d386a01)

# 이 죽일 놈의 날씨
난 니콘 P1000 콤팩트 망원 카메라를 가지고 있어서 평소 달 촬영 등 이것 저것 마구 찍어댄다(기술은 전혀 없어서 항상 흔들린다 ㅜㅜ)
하.지.만.... 여행 날 날씨는 썸네일 사진에서 보이듯이 해무가 잔뜩 끼고 구름도 가득하여 별도... 달도... 바닷가 조차도 전혀 제대로 찍히질 않아서 너무 안타까웠다...

![](https://image.dnkdream.com/220615_063935_ba531520754442c329d386a02)

날씨가 좋을 때는 달을 대충 찍어도 이 정도 사진을 뽑아주는 카메라인데...
해무가 잔뜩 끼니 도착하자마자 찍은 사진이 이렇다...
![](https://image.dnkdream.com/220615_064058_ba531520754442c329d386a03)

아오... 눈으로는 정말 아름다웠는데...
![](https://image.dnkdream.com/220615_064200_ba531520754442c329d386a04)
![](https://image.dnkdream.com/220615_064214_ba531520754442c329d386a05)

저 멀리 보이는 배도 당겨서 찍어보고
![](https://image.dnkdream.com/220615_064229_ba531520754442c329d386a06)
전선 위 새 한 마리가 찍어달라고 신호를 보내기에 찍어 주었다. ㅋㅋㅋㅋ

# 눈 앞에 보이는 석모도
아침이 되어 그나마 구름은 어느 정도 걷혔으나 해무는 여전히 끼어 있어 아쉬웠지만 줌을 당겨보았다.
![](https://image.dnkdream.com/220615_064243_ba531520754442c329d386a07)
드문드문 민가가 보인다. 섬 크기가 앞에서 보는 것과 달리 지도로 보니 꽤 크던데 정면에서 보니 작은 섬처럼 보인다.
![](https://image.dnkdream.com/220615_064259_ba531520754442c329d386a08)

# 준비된 여행을 하자
다음 부터는 좀 더 채비를 갖추고 여행을 떠나야겠다.
촬영도 제대로 하지 못하고 즐길 수 있는 시간이 거의 없는 상태로 떠나니 별 것 해보지도 못하고 피로만 가득 쌓여서 돌아오게 됐다.

끝으로 강화도 끝자락에서 바라본 석모도 영상이다.
수전증으로 인해 많이 흔들리지만 ㅋㅋ

<iframe class="ql-video" frameborder="0" allowfullscreen="true" src="https://www.youtube.com/embed/GEMG_JtdI4k?showinfo=0"></iframe>

> 그래도 너무 멋졌다!!

강화도 펜션 급 여행

개발자는 아니지만 친한 동생이 백엔드 서버 개발자인데 뜬금 프로젝트 하나 해보자고 해서 진행을 하게 되었는데 Next.JS에 네이버 맵을 띄워야 하는 상황이 오게 되어 이리저리 삽질(?) 하다가 확인된 내용들을 정리하고자 합니다..

벨로그와 구글링을 통해 Next.js에 네이버 맵을 얹으려고 정보를 찾아보면 거의 대부분이 이전 버전의 naver map npm 모듈 을 사용한 글이거나 원인은 잘 모르겠으나 그대로 따라해도 작동을 하지 않아 이것 저것 찾아보며 결국 띄우긴 하여 기록을 합니다.

```js
$ npx create-next-app next-naver-map --typescript
```


# Naver Map API 등록
프로젝트 생성 후 네이버 클라우드 플랫폼에 가입 후 네이버 맵 API 사용을 신청합니다.
네이버 클라우드 플랫폼에 접속하여 로그인 후 우측 상단의 콘솔 메뉴를 클릭합니다.
메뉴 중 Services ➡️ AI∙NAVER API

![Image01](https://image.dnkdream.com/220613_224508_65feb512cdf867cae0ada4100)
![Image02](https://image.dnkdream.com/220613_224520_65feb512cdf867cae0ada4101)
![Image03](https://image.dnkdream.com/220613_224525_65feb512cdf867cae0ada4102)

**Application** 등록 메뉴를 눌러 새 앱을 생성합니다.

이후 아래와 같이 설정 후 **+추가** 를 해준 후 등록합니다.

![Image04](https://image.dnkdream.com/220613_224544_65feb512cdf867cae0ada4103)

그럼 이와 같이 앱이 등록되는데 저기서 인증정보를 눌러 Client ID키 값을 복사해 둡니다.
![Image05](https://image.dnkdream.com/220613_224555_65feb512cdf867cae0ada4104)

# Next.js에 네이버 맵 등록
Next.js 프로젝트 경로에 .env.local 파일을 생성하고 아래와 같이 저장합니다.
```js
NEXT_PUBLIC_MAP_KEY=조금 전 Client ID 키
```
Next.js에서 .env.local 설정을 읽어올 때는 NEXT_PUBLIC_을 반드시 앞에 붙여주어야 합니다.
CRA로 프로젝트를 만들었으면 */public/index.html* 내부에 네이버 스크립트를 작성하겠지만 Next.js 는 *_app.tsx* 내부에 next/script 모듈을 사용하여 작성해 줍니다.
```jsx
import type { AppProps } from 'next/app';
import Head from 'next/head';
import Script from 'next/script';

function App({ Component, pageProps ): AppProps) {
  return (
    <Head>
      <meta charSet="utf-8" />
      <title>Next Naver Map</title>
    </Head>
    <Script
      strategy="beforeInteractive"
      src={`https://openapi.map.naver.com/openapi/v3/maps.js?ncpClientId=${process.env.NEXT_PUBLIC_MAP_KEY}`}
    />
    <Component {...pageProps} />
  );
};

export default App;
```

그리고 저는 타입스크립트를 사용하였기에 *@types/navermaps* 모듈을 설치합니다.
styled-components 로 스타일을 할 거라 아래와 같이 설치합니다.

```js
$ npm i styled-components
$ npm i -D @types/styled-components babel-plugin-styled-components @types/navermaps
```

*_document.tsx*
```jsx
import type { DocumentContext, DocumentInitialProps } from 'next/document';
import Document, { Html, Head, Main, NextScript } from 'next/document';
import { Fragment } from 'react';
import { ServerStyleSheet } from 'styled-components';

class MyDocument extends Document {
  static async getInitialProps(ctx: DocumentContext): Promise<DocumentInitialProps> {
    const sheet = new ServerStyleSheet();
	const originalRenderPage = ctx.renderPage;

	try {
		ctx.renderPage = () =>
			originalRenderPage({
				enhanceApp: (App) => (props) =>
					sheet.collectStyles(<App {...props} />),
			});
		const initialProps = await Document.getInitialProps(ctx);

		return {
			...initialProps,
			styles: [
				<Fragment key={new Date().toString()}>
					{initialProps.styles}
					{sheet.getStyleElement()}
				</Fragment>,
			],
		};
	} finally {
		sheet.seal();
	}
	
	render() {
		return (
			<Html>
				<Head />
				<body>
					<Main />
					<NextScript />
				</body>
			</Html>
		);
	}
}

export default MyDocument;
```

*.babelrc*
```js
{
  "presets": ["next/babel"],
  "plugins": [
    [
      "styled-components", {
        "ssr": true,
        "displayName": true,
        "preprocess": false
      }
    ]
  ]
}
```

그럼 아래 코드와 같이 네이버 맵을 불러올 수 있습니다.
div 태그에 꼭 id 값을 map 으로 하고 너비와 높이를 지정해 주면 됩니다.

*pages/index.tsx*
```jsx
import type { NextPage } from 'next';

const IndexPage: NextPage = () => {
  return (
    <div id="map"></div>
   );
};

export default IndexPage;
```

위와 같이 작성하고 나면 텅~빈 화면이 나올 겁니다.
맵의 크기 및 위치를 지정해 주어야 하죠.

# 지도 위치 초기화
Navigator의 Geolocation API를 이용하여 현재 위치를 확인하며 위치 정보 동의를 못 구할 시 임의 좌표를 입력합니다.
그리고 myLocation이 'string'이 아니라면 즉, 좌표값이 들어있다면 그 위치를 센터로 네이버 맵을 생성합니다.

*useMap.ts*
```jsx
import { useEffect, useRef, useState } from 'react';

function useMap() {
  const mapRef = useRef<HTMLElement | null | any>(null);
  const [myLocation, setMyLocation] = useState<
    { latitude: number; longitude: number } | string
  >('');

  useEffect(() => {
    // geolocation 이용 현재 위치 확인, 위치 미동의 시 기본 위치로 지정
    if (navigator.geolocation) {
      navigator.geolocation.getCurrentPosition((position) => {
        setMyLocation({
          latitude: position.coords.latitude,
          longitude: position.coords.longitude,
        });
      });
    } else {
      window.alert('현재 위치를 알 수 없어 기본 위치로 지정합니다.');
      setMyLocation({ latitude: 37.4862618, longitude: 127.1222903 });
    }
  }, []);

  useEffect(() => {
    if (typeof myLocation !== 'string') {
      // 현재 위치 추적
      let currentPosition = [myLocation.latitude, myLocation.longitude];
      // Naver Map 생성
      mapRef.current = new naver.maps.Map('map', {
        center: new naver.maps.LatLng(currentPosition[0], currentPosition[1]),
        zoomControl: true,
      });
    }
  }, [myLocation]);

  return {
    myLocation,
  };
}

export default useMap;
```

*pages/index.tsx*
```jsx
import type { NextPage } from 'next';
import styled from 'styled-components';
import useMap from '../hooks/useMap';

const IndexPage: NextPage = () => {
  useMap();

  return <MapBox id="map"></MapBox>;
};

// Styles
const MapBox = styled.div`
  width: 800px;
  height: 800px;
`;

export default IndexPage;

```

이렇게 작성하면 쨔란!
![Image06](https://image.dnkdream.com/220613_230002_65feb512cdf867cae0ada4105)
이렇게 지도가 나옵니다.
나중에 시간이 가용하면 마커 작성 및 위치 추적 등 부가 기능도 기록해야겠네요.