Slik løser du feilen «Module not found: Can’t resolve 'fs'» i Webpack

Sist verifisert: 11. september 2026. Feilen «Module not found: Error: Can’t resolve 'fs'» betyr vanligvis at Webpack bygger kode for en nettleser, men at kildekoden din – eller en av dens avhengigheter – importerer Node.js’ filsystemmodul. Node dokumenterer node:fs som API-et for å samhandle med filsystemet, mens Webpacks gjeldende dokumentasjon sier at Webpack 5 ikke lenger automatisk polyfiller Node.js’ kjerne-moduler for nettleserbygger.

Det viktige er å velge løsningen som samsvarer med hva koden faktisk prøver å gjøre. Det finnes ingen enkeltinnstilling som er riktig for alle prosjekter. Hvis applikasjonen din virkelig trenger å lese filer fra serverens disk, flytt dette arbeidet til Node/serverkode. Hvis en avhengighet importerer fs kun for en valgfri Node-kun-funksjon som nettleserpakken din aldri bruker, kan resolve.fallback: { fs: false } være passende. Hvis pakken har en nettleserkompatibel bygging, bruk den i stedet. Og hvis pakken er ment å kjøre i Node, mål mot Node i stedet for å late som om det er en nettleserpakke.

Rask beslutningstabell

SituasjonBeste første løsningHovedfordelHovedkompromiss
Din egen nettleserkode importerer fsFjern den fra nettleserstien eller flytt operasjonen til en server/APISamsvare med den faktiske kjøretidsmiljøetKrever en arkitektonisk grense mellom klient og server
En avhengighet importerer fs, men funksjonen brukes aldri i nettleserenVurder resolve.fallback: { fs: false }Liten, enkel byggefixVil feile logisk hvis pakken senere utfører filsystemavhengig kode
En avhengighet tilbyr nettleser- og Node-byggBruk eller oppgrader til den nettleserkompatible inngangenBevarer tiltenkt nettleseratferdKan kreve endringer i pakke/versjon
Utdatabygg kjører i Node, ikke i en nettleserBruk target: "node"Holder Node-innbygde moduler tilgjengelige ved kjøretidUtdatabygg er ikke lenger en nettleserpakke
Du prøver å «polyfille fs» i nettleserenVurder kravet på nyttUnngår et villedende kompatibilitetslagDu kan trenge en annen nettleserbasert lagrings/fil-arbeidsflyt

Webpacks offisielle dokumentasjon for resolve.fallback angir at Webpack 5 ikke lenger polyfiller Node-kjerne-moduler automatisk. Dens utgivelsesnotater for Webpack 5 forklarer årsaken: automatiske polyfills kunne legge til store, unødvendige kompatibilitetskoder i frontend-pakker, så Webpack flyttet ansvaret til applikasjonen eller pakkeforfatteren.

Steg 1: Finn ut hvem som importerer fs

Start med den første nyttige linjen i Webpacks feilutdata. Den peker vanligvis til filen hvor oppløsningen feilet, for eksempel:

ERROR in ./src/utils/fileHelper.js 1:0-20
Module not found: Error: Can't resolve 'fs'
AI-generert terminalillustrasjon som viser at Webpack ikke klarer å løse Node fs-modulen i et nettleserbygg
AI-generert illustrasjon av et Webpack-bygg som feiler på en fs-import. Det er ikke utdata fra et ekte prosjekt; filnavn og linjenumre er illustrative.

Hvis den feilende filen er din, søk i den etter begge former:

const fs = require('fs')

// eller
import fs from 'node:fs'

// eller
import { readFile } from 'node:fs/promises'

Nodes offisielle dokumentasjon for filsystemet bekrefter at node:fs og node:fs/promises er Node-API-er for filsystemoperasjoner. En vanlig nettleserpakke får ikke tilgang til serverens disk bare fordi Webpack kan analysere importen.

Hvis den feilende filen er under node_modules, ikke rediger den pakken på stedet umiddelbart. Identifiser først hvilken toppnivåavhengighet som brakte den inn i nettleserpakken din. Det nyttige spørsmålet er ikke bare «Hvilken pakke importerer fs?», men «Hvorfor er den Node-orienterte kodebanen tilgjengelig fra klientinngangen min?»

Bruk denne diagnosen når: feilen oppstår etter oppgradering av Webpack, tillegging av en avhengighet, import av et tidligere server-kun-verktøy i frontend-kode, eller flytting av delt kode til en klientpakke.

Praktisk sjekk: fjern midlertidig importen som fører til den feilende modulen og bygg på nytt. Hvis fs-feilen forsvinner, har du bekreftet avhengighetsbanen før du endrer Webpack-konfigurasjonen.

Steg 2: Hvis koden virkelig trenger filsystemtilgang, flytt den til Node/serverkode

Dette er den beste løsningen når koden trenger å lese konfigurasjonsfiler, maler, lokale dokumenter, private nøkler, genererte eiendeler, serverlogger eller noe annet fra maskinens filsystem.

For eksempel er dette passende i Node:

import { readFile } from 'node:fs/promises'

export async function loadTemplate() {
  return readFile('./templates/email.html', 'utf8')
}

Men den bør ikke trekkes inn i en nettleserinngang. Eksponer i stedet resultatet gjennom applikasjonens serverlag. En forenklet oppdeling kan være:

// server-side kode
import { readFile } from 'node:fs/promises'

app.get('/api/template', async (req, res) => {
  const text = await readFile('./templates/email.html', 'utf8')
  res.type('text/plain').send(text)
})
// nettleser-side kode
export async function loadTemplate() {
  const response = await fetch('/api/template')
  if (!response.ok) throw new Error('Failed to load template')
  return response.text()
}
AI-generert kodeeditorillustrasjon som viser at filsystemlogikk er flyttet fra nettleserkode til en server/API-grense
AI-generert illustrasjon av separasjon av Node-filsystemarbeid fra nettleserkode. Det er et konseptuelt arkitektureksempel, ikke et skjermbilde av et spesifikt rammeverk.

Kompromisset er arkitektonisk: du legger til et server-endepunkt eller en annen serverside grense, men du bevarer semantikken til fs. Nettleseren ber om data; serveren leser filsystemet.

Denne løsningen er passende når: filsystemoperasjonen er reell og nødvendig.

Denne løsningen er ikke nødvendig når: importen kun finnes inne i en valgfri Node-kodebane som nettleseren aldri utfører. I det tilfellet kan en nettleserspesifikk pakkeinngang eller en ignorert fallback være renere.

Steg 3: Bruk resolve.fallback: { fs: false } kun når filsystematferd er valgfritt

Webpacks offisielle migreringsguide fra Webpack 4 til 5 sier spesifikt at konfigurasjoner som bruker det gamle mønsteret node.fs: 'empty' bør gå over til:

module.exports = {
  // ...
  resolve: {
    fallback: {
      fs: false
    }
  }
}

Se den offisielle Webpack 5-migreringsguiden.

AI-generert webpack.config.js-illustrasjon som viser resolve fallback med fs satt til false
AI-generert illustrasjon av resolve.fallback: { fs: false }. Bruk dette kun når nettleseren ikke trenger avhengighetens filsystematferd.

Å sette en fallback til false forteller Webpack å ikke inkludere en implementering for den uløste modulen. Dette kan være nøyaktig riktig for en pakke som inneholder en beskyttet Node-kun-gren, som kode som bruker fs kun under serverrendering eller CLI-utførelse.

Det kan også skjule byggefeilen mens du sitter igjen med en designfeil ved kjøretid. Vurder denne avhengigheten:

const fs = require('fs')

export function loadUserConfig(path) {
  return fs.readFileSync(path, 'utf8')
}

Hvis nettleseren din faktisk kaller loadUserConfig(), erstatter fs med «ingenting» ikke et fungerende nettleserfilsystem. Bygget kan fortsette, men funksjonen kan fortsatt ikke utføre den tiltenkte Node-operasjonen.

Bruk fs: false når: du har verifisert at den filsystemspesifikke grenen ikke brukes i nettlesermålet.

Ikke bruk den når: nettleserfunksjonen din avhenger av readFileSync, kataloggjennomgang, serverstier eller annen reell Node-filsystematferd.

Hvorfor «bare installer en fs-polyfill» vanligvis er feil første svar

Webpacks gjeldende dokumentasjon for resolve.fallback gir eksempler på manuelle polyfills for flere Node-kjerne-moduler som path, buffer, stream og crypto. Merk at kompatibilitetslisten ikke gir en generell fs-erstatning som er ekvivalent med Node-filsystemet.

Denne forskjellen er viktig. JavaScript-verktøy kan ofte reproduseres i en nettleser. Vilkårlig tilgang til verts-/serverfilsystemet er en kjøretidskapabilitet, ikke bare en manglende hjelpefunksjon.

Hvis det du virkelig trenger er en nettleserarbeidsflyt, velg et nettlesernativt design for den spesifikke oppgaven – for eksempel, hent en eiendel fra en URL, la brukeren velge en fil, eller lagre applikasjonsdata ved hjelp av en passende nettleserlagringsmekanisme. Døm ikke suksess kun etter om Webpack slutter å vise feilen.

Alternativ 4: Foretrekk en nettleserkompatibel avhengighet eller pakkeeksport

Hvis feilen kommer fra en tredjepartspakke, inspiser om den pakken offisielt støtter nettlesere. Webpacks gjeldende guide for pakke exports forklarer at pakker kan gi betingede eksporter for miljøer som browser og node. Webpacks utgivelsesveiledning anbefaler også at pakkeforfattere gir frontend-kompatible alternativer når Node-kun-implementeringer er uegnede for nettlesere.

For eksempel kan en pakke konseptuelt eksponere:

{
  "exports": {
    ".": {
      "browser": "./dist/browser.js",
      "node": "./dist/node.js",
      "default": "./dist/browser.js"
    }
  }
}

Hvis en oppgradert pakkeversjon gir en riktig nettleserinngang mens den eldre versjonen din ikke gjør det, kan oppgradering være tryggere enn å konfigurere fs: false. Tilsvarende kan erstatning av en Node-orientert pakke med en som er eksplisitt designet for nettleserbruk redusere kompatibilitetshacks og pakkekompleksitet.

Velg denne ruten når: avhengigheten er ment å fungere i nettlesere, men den installerte versjonen velger eller eksponerer en Node-kun-implementering.

Kompromiss: oppgradering eller erstatning av en pakke kan introdusere API-endringer, så kjør de vanlige applikasjonstestene dine i stedet for å behandle en vellykket kompilering som tilstrekkelig.

Alternativ 5: Hvis utdata er en Node-pakke, sett målet til Node

Ikke alltid produserer Webpack nettleserkode i det hele tatt. Du kan pakke en CLI, bakgrunnsarbeider, byggeverktøy, SSR-server eller Node-tjeneste. I det tilfellet er det bakvendt å prøve å undertrykke fs: kjøretidsmiljøet gir faktisk den.

Webpacks offisielle dokumentasjon for Targets sier at:

module.exports = {
  target: 'node'
}

kompilerer for et Node.js-lignende miljø og lar innebygde moduler som fs og path bli levert av Node ved kjøretid.

Webpacks mer detaljerte referanse for target-konfigurasjon skiller også mellom web, node, Electron-mål, nettleserarbeidere og andre miljøer.

Bruk target: 'node' når: den resulterende JavaScript-koden vil utføre under Node.

Ikke bruk den for å «fikse» en vanlig nettleser-SPA: endring av målet gjør ikke at en nettleser plutselig gir Nodes filsystem-API-er. Det endrer hvilket miljø Webpack antar vil utføre pakken.

Avanserte Node-bygg: externals kan holde innebygde moduler ved kjøretid

For serverpakker gir Webpack også Node-orientert externals-atferd. Dens offisielle dokumentasjon for Externals angir at externalsPresets.node kan behandle Node-innbygde moduler som fs, path og vm som eksterne og laste dem med Nodes kjøretids require().

En typisk Node-orientert konfigurasjon kan derfor se ut som:

module.exports = {
  target: 'node',
  externalsPresets: {
    node: true
  }
}

Dette er en avansert serverpakke-bekymring, ikke en nettleser-workaround.

Steg 4: Bygg på nytt, og test deretter funksjonen som forårsaket importen

Etter å ha gjort den arkitektoniske eller konfigurasjonsmessige endringen, bygg på nytt:

npm run build
AI-generert terminalillustrasjon som viser et vellykket Webpack-produksjonsbygg etter at fs-importproblemet er løst
AI-generert illustrasjon av et vellykket Webpack-rebuild. Versjonsnumre, eiendelsstørrelser og byggetider er fiktive eksempler.

En ren kompilering beviser bare at moduloppløsningen lyktes. Det beviser ikke at den berørte funksjonen oppfører seg korrekt. Test i henhold til løsningen du valgte:

  • Hvis du flyttet filtilgang til serveren, kall nettleserfunksjonen og verifiser at server-endepunktet returnerer de forventede dataene.
  • Hvis du satte fs: false, utøv avhengigheten i nettleseren og bekreft at den aldri går inn i den filsystemavhengige grenen.
  • Hvis du byttet til en nettleserbygging av en pakke, kjør pakkens virkelige brukerrettede arbeidsflyt.
  • Hvis du endret målet til Node, utfør den bygde utdataen under Node-versjonen du støtter.

Vanlige løsninger sammenlignet

LøsningNettlesersikker?Bevarer reell Node-filsystemtilgang?Når du bør foretrekke den
Flytt fs-arbeid til server/APIJaJa, på serverenApplikasjonen din trenger virkelig serverfilsystemdata
resolve.fallback.fs = falseKun hvis fs-grenen ikke brukesNeiValgfri Node-kun-avhengighetsbane
Nettleserspesifikk pakke/eksportJa, hvis pakkene støtter detNei; gir nettleserspesifikk atferd i stedetEn avhengighet er ment å støtte begge kjøretidsmiljøer
target: 'node'NeiJaPakken kjører faktisk i Node
Generisk «fs-polyfill»Avhenger av biblioteket og semantikkenIkke ekvivalent med vilkårlig Node-filsystemtilgangKun etter verifisering av den nøyaktige nettleseratferden du trenger

Spesielt tilfelle: delt kode importert av både nettleser- og serverpakker

En hyppig kilde til denne feilen er et verktøymodul som inneholder både rene funksjoner og Node-kun-hjelpere:

// shared-utils.js
import fs from 'node:fs'

export function formatDate(date) {
  return new Intl.DateTimeFormat('en-US').format(date)
}

export function readConfig(path) {
  return fs.readFileSync(path, 'utf8')
}

Selv om nettleseren din kun importerer formatDate, kan den toppnivå fs-importen tvinge Webpack til å løse fs. Et renere design er å splitte modulene:

// shared/formatDate.js
export function formatDate(date) {
  return new Intl.DateTimeFormat('en-US').format(date)
}

// server/readConfig.js
import fs from 'node:fs'

export function readConfig(path) {
  return fs.readFileSync(path, 'utf8')
}

Dette gjør kjøretidsgrensen synlig i modulgrafet i stedet for å stole på tree-shaking eller en fallback for å fjerne en inkompatibel import.

Spesielt tilfelle: feilen dukket opp etter oppgradering fra Webpack 4

Dette er et av de klassiske Webpack 5-migreringssymptomene. Webpack 4 leverte automatisk kompatibilitetsshim for mange Node-kjerne-moduler. Webpack 5 sluttet med vilje å gjøre det. Hvis koden din «fungerte før oppgraderingen», spør om den virkelig trengte Node-funksjonen i nettleseren, eller om den gamle bundleren stille injiserte kompatibilitetskode.

Den offisielle Webpack-migreringsguiden anbefaler å lese veiledningen for ødeleggende endringer i byggefeilen og erstatte gammel node.*-kompatibilitetskonfigurasjon med den nyere resolver-tilnærmingen der det er passende.

Ikke anta at gjenskaping av hver eneste Webpack 4-polyfill er den beste migreringen. Webpacks egne utgivelsesnotater anbefaler frontend-kompatible moduler der det er mulig.

Endelig selvkontroll

Før du lukker saken, verifiser disse punktene:

  1. Finn den nøyaktige kildefilen eller avhengigheten som importerer fs.
  2. Bekreft om den berørte pakken kjører i en nettleser eller i Node.
  3. Hvis det er en nettleserpakke, verifiser om funksjonen faktisk trenger filsystematferd.
  4. Hvis den gjør det, flytt filsystemoperasjonen bak en servergrense.
  5. Hvis avhengighetens fs-bruk er valgfri og aldri utført i nettleseren, vurder resolve.fallback: { fs: false }.
  6. Hvis pakkene offisielt gir en nettleser-eksport, foretrekk den fremfor å undertrykke nødvendig atferd.
  7. Hvis pakken utfører i Node, bruk et Node-mål i stedet for et nettlesermål.
  8. Bygg på nytt og bekreft at moduloppløsingsfeilen er borte.
  9. Kjør den faktiske funksjonen som tidligere trakk inn fs; ikke stopp ved «kompilert vellykket».

Den varige løsningen er å tilpasse koden til kjøretidsmiljøet. fs tilhører Nodes filsystemmiljø. Webpack 5 gjør denne grensen mer synlig ved å ikke lenger injisere Node-kjerne-polyfills automatisk. Når du først har bestemt om filsystemarbeidet hører hjemme på serveren, er valgfritt i nettleseren, eller er en del av en Node-rettet pakke, blir den riktige konfigurasjonen mye lettere å velge.

Legg igjen en kommentar

Slik fikser du «ENOSPC: Systemgrense for filovervåkere nådd» i Linux

Slik fikser du «ENOSPC: Systemgrense for filovervåkere nådd» i Linux

Rett opp feil i Linux ENOSPC-filovervåking ved å sjekke inotify-grenser, finne prosesser som er tunge i overvåking, heve grenser på en sikker måte og gjøre endringer permanente.

How to Fix "Tailwind CSS Styles Not Updating" in a Vite React App

How to Fix "Tailwind CSS Styles Not Updating" in a Vite React App

Fix Tailwind CSS styles not updating in Vite React by checking Tailwind v4 setup, CSS imports, source detection, dynamic classes, HMR, and stale caches.

Slik fikser du ModuleNotFoundError: Ingen modul kalt 'pip' i Python 3

Slik fikser du ModuleNotFoundError: Ingen modul kalt 'pip' i Python 3

Fiks Python 3s ModuleNotFoundError for pip på Windows, macOS og Linux med ensurepip, OS-pakker, virtuelle miljøer og tolkekontroller.

Slik fikser du «Ingen tillatelse (offentlig nøkkel)» i GitHub SSH

Slik fikser du «Ingen tillatelse (offentlig nøkkel)» i GitHub SSH

Fiks GitHub SSH-tillatelse nektet (offentlig nøkkel) ved å sjekke verten, aktiv SSH-nøkkel, GitHub-konto, SSO-autorisasjon, ekstern URL og port 22-tilgang.

How to Fix “Git Push Rejected: Non-Fast-Forward” Without Losing Changes

How to Fix “Git Push Rejected: Non-Fast-Forward” Without Losing Changes

Fix a Git non-fast-forward push safely. Protect local work, fetch remote commits, choose merge or rebase, resolve conflicts, and push without losing changes.

Slik fikser du "Nginx 502 Bad Gateway" når du bruker proxy til Node.js

Slik fikser du "Nginx 502 Bad Gateway" når du bruker proxy til Node.js

Rett Nginx 502 Bad Gateway-feil med en Node.js-oppstrøm ved å sjekke appporten, NGINX-logger, proxy_pass-adresse, containernettverk, tidsavbrudd og omlasting.

Slik fikser du «Typen 'null' kan ikke tilordnes til type» i TypeScript

Slik fikser du «Typen 'null' kan ikke tilordnes til type» i TypeScript

Rett TypeScripts feilmelding «Typen 'null' kan ikke tilordnes til type» med unionstyper, innsnevring, standardverdier og sikre påstander under strictNullChecks.

Slik fikser du feilen «Prisma Client has not been generated yet»

Slik fikser du feilen «Prisma Client has not been generated yet»

Fiks feilen med at Prisma Client ikke er generert ved å sjekke generatoren, skjemaet, utdatastien, importene, versjonene, monorepo-oppsettet og byggetrinnene ved distribusjon.

Slik fikser du «ERR_MODULE_NOT_FOUND» i Node.js ESM-importer

Slik fikser du «ERR_MODULE_NOT_FOUND» i Node.js ESM-importer

Fiks Node.js ERR_MODULE_NOT_FOUND i ESM ved å sjekke importstier, filtyper, pakkeinstallasjon, eksport, ESM-modus og rene installasjoner.

Slik løser du SSL-sertifikatproblemet: Unable to Get Local Issuer Certificate i Git

Slik løser du SSL-sertifikatproblemet: Unable to Get Local Issuer Certificate i Git

Løs Git-feilmeldingen 'unable to get local issuer certificate' ved å identifisere tillitsbakgrunnen, installere riktig CA-kjede og beholde SSL-verifisering aktivert.