๐ŸŽ‰ berenickt ๋ธ”๋กœ๊ทธ์— ์˜จ ๊ฑธ ํ™˜์˜ํ•ฉ๋‹ˆ๋‹ค. ๐ŸŽ‰
Front
NextJs
Optimizing
Lazy Loading

Lazy Loading

Lazy loading in Next.js helps improve the initial loading performance of an application by decreasing the amount of JavaScript needed to render a route.

It allows you to defer loading of Client Components and imported libraries, and only include them in the client bundle when theyโ€™re needed. For example, you might want to defer loading a modal until a user clicks to open it.

There are two ways you can implement lazy loading in Next.js:

  1. Using Dynamic Imports with next/dynamic
  2. Using React.lazy() with Suspense

By default, Server Components are automatically code split, and you can use streaming to progressively send pieces of UI from the server to the client. Lazy loading applies to Client Components.

next/dynamic

next/dynamic is a composite of React.lazy() and Suspense. It behaves the same way in the app and pages directories to allow for incremental migration.

Examples

Importing Client Components

app/page.js
1
'use client'

2


3
import { useState } from 'react'

4
import dynamic from 'next/dynamic'

5


6
// Client Components:

7
const ComponentA = dynamic(() => import('../components/A'))

8
const ComponentB = dynamic(() => import('../components/B'))

9
const ComponentC = dynamic(() => import('../components/C'), { ssr: false })

10


11
export default function ClientComponentExample() {

12
  const [showMore, setShowMore] = useState(false)

13


14
  return (

15
    <div>

16
      {/* Load immediately, but in a separate client bundle */}

17
      <ComponentA />

18


19
      {/* Load on demand, only when/if the condition is met */}

20
      {showMore && <ComponentB />}

21
      <button onClick={() => setShowMore(!showMore)}>Toggle</button>

22


23
      {/* Load only on the client side */}

24
      <ComponentC />

25
    </div>

26
  )

27
}

Skipping SSR

When using React.lazy() and Suspense, Client Components will be pre-rendered (SSR) by default.

If you want to disable pre-rendering for a Client Component, you can use the ssr option set to false:

1
const ComponentC = dynamic(() => import('../components/C'), { ssr: false })

Importing Server Components

If you dynamically import a Server Component, only the Client Components that are children of the Server Component will be lazy-loaded - not the Server Component itself.

app/page.js
1
import dynamic from 'next/dynamic'

2


3
// Server Component:

4
const ServerComponent = dynamic(() => import('../components/ServerComponent'))

5


6
export default function ServerComponentExample() {

7
  return (

8
    <div>

9
      <ServerComponent />

10
    </div>

11
  )

12
}

Loading External Libraries

External libraries can be loaded on demand using the import() function. This example uses the external library fuse.js for fuzzy search. The module is only loaded on the client after the user types in the search input.

app/page.js
1
'use client'

2


3
import { useState } from 'react'

4


5
const names = ['Tim', 'Joe', 'Bel', 'Lee']

6


7
export default function Page() {

8
  const [results, setResults] = useState()

9


10
  return (

11
    <div>

12
      <input

13
        type="text"

14
        placeholder="Search"

15
        onChange={async e => {

16
          const { value } = e.currentTarget

17
          // Dynamically load fuse.js

18
          const Fuse = (await import('fuse.js')).default

19
          const fuse = new Fuse(names)

20


21
          setResults(fuse.search(value))

22
        }}

23
      />

24
      <pre>Results: {JSON.stringify(results, null, 2)}</pre>

25
    </div>

26
  )

27
}

Adding a custom loading component

app/page.js
1
import dynamic from 'next/dynamic'

2


3
const WithCustomLoading = dynamic(

4
  () => import('../components/WithCustomLoading'), //

5
  {

6
    loading: () => <p>Loading...</p>,

7
  },

8
)

9


10
export default function Page() {

11
  return (

12
    <div>

13
      {/* The loading component will be rendered while  <WithCustomLoading/> is loading */}

14
      <WithCustomLoading />

15
    </div>

16
  )

17
}

Importing Named Exports

To dynamically import a named export, you can return it from the Promise returned by import() function:

components/hello.js
1
'use client'

2


3
export function Hello() {

4
  return <p>Hello!</p>

5
}
app/page.js
1
import dynamic from 'next/dynamic'

2


3
const ClientComponent = dynamic(

4
  () => import('../components/hello').then(mod => mod.Hello), //

5
)
Static AssetsAnalytics