CRLF vs. LF på Windows: Konvertera, konfigurera och undvik projektproblem

Senaste uppdateringen: 04/09/2025
Författare: Isaac
  • LF (Unix) och CRLF (Windows) är olika radslut; standardisera dem för att undvika skillnader och fel.
  • Git löser problemet med core.autocrlf och .gitattributes; det använder * text=auto och point-regler.
  • Konfigurera editorn (VS Code/Visual Studio) och, om nödvändigt, omnormalisera med git add --renormalize .
  • Behåll LF i arkivet och låt Windows använda CRLF i arbetskopian när det är lämpligt.

Konvertera mellan radbrytningsformat i Windows

Om du arbetar i Windows och växlar projekt med folk på Linux eller macOS, kommer du förr eller senare att stöta på den eviga CRLF vs LF -striden . Ibland känns det som svart magi: du redigerar en fil, ändrar ingenting "synligt", och Git markerar hälften av filen som modifierad. Oroa dig inte, det är inte häxkonst; det är radsluten som arbetar emot dig.

För att bespara dig huvudvärk är det bra att förstå vad som händer under och hur du justerar Git, dina editorer och dina verktyg så att varje fil anländer "ren" i repositoriet, utan fantomändringar eller konstiga fel i CI/CD eller skript. I den här guiden kommer jag att förklara, i detalj och rakt på sak, hur man konverterar, konfigurerar och normaliserar CRLF och LF i Windows utan att slösa tid.

Vad är LF och CRLF och varför är de viktiga?

Radslut är kontrolltecken som avgränsar varje rad i en textfil: LF (\n, ASCII 10) och CRLF (\r\n, ASCII 13+10) . Unix-liknande system (Linux, macOS) använder LF , medan Windows använder CRLF på grund av sitt arv från skrivare och skrivmaskiner: först vagnretur (CR), sedan radmatning (LF).

Valet är inte enbart estetiskt: att byta från ett format till ett annat kan orsaka artificiella skillnader , skript som misslyckas med "kommandot hittades inte", pipelines som kraschar när man kör filer som sparats med CRLF på Linux, eller editorer som visar allt på en enda rad. Ja, att öppna en .sh-fil med CRLF i Bash kan bli en obehaglig överraskning.

För att runda av känner Unicode igen fler separatorer (NEL U+0085, LS U+2028, PS U+2029, VT U+000B, FF U+000C), men i den dagliga utvecklingen står den verkliga kampen mellan CRLF och LF . Ändå är det bra att veta att de existerar när man stöter på stordatortext eller ovanliga filer som en äldre editor inte tolkar väl.

En annan användbar teknisk detalj: en radbrytning kan behandlas som en avgränsare (mellan rader) eller som en avslutning (markerar slutet). Denna subtilitet förklarar varför man ibland ser en sista rad utan radbrytning eller extra tomma rader när man blandar verktyg. Om du behöver lära dig hur man hittar och ersätter styckebrytningar , var medveten om att vissa tolkarverktyg förväntar sig det ena eller det andra.

Skillnader mellan CRLF och LF beroende på operativsystem

Skillnader mellan olika system och typiska problem

På Windows är CRLF standarden ; på Linux och macOS är det LF . Denna skillnad märks omedelbart på ett blandat system: någon redigerar en fil med sitt system, sparar den och diff-filen fylls med ändringar som egentligen bara är radslut . I praktiken komplicerar detta revisioner och förorenar historiken.

Det finns också biverkningar: ett skript med CRLF som körs i en Unix-miljö kan misslyckas med kryptiska fel, eller i CI kan en uppgift gå sönder eftersom ett shell misstolkar returvärdena. Omvänt kan det hända att en fil som endast öppnas med LF i äldre editorer i Windows plattas ut till en enda rad.

Var försiktig med verktyg för kontinuerlig integration som Jenkins eller GitHub Actions: om bygget körs på Linux men du laddar upp filer med inkonsekventa radslut kan du förstöra pipelinen även om "allt fungerar på min maskin". Många har förlorat timmar på grund av detta.

Den goda nyheten är att det finns en tydlig lösning: etablera en konvention och låt verktygen tillämpa den automatiskt . Det involverar Git och din editor. Och om skadan redan är skedd, omnormalisera repositoriet.

  Ta reda på hur man Tillverkningsanläggning Återställer iPhone eller iPad

För övrigt visar moderna editorer som VS Code brytningstypen i statusfältet och låter dig ändra den direkt; det är en livräddare när du upptäcker "korsrefererade" filer och snabbt vill ändra ordningen på dem , eller när du behöver undvika oväntade sidbrytningar och formatering när du klistrar in text i dokument.

Konfigurera Git för CRLF och LF

Git och radändelser: core.autocrlf och .gitattributes

Git kan automatiskt konvertera radslut för att hålla historiken ren och undvika överraskningar. Nyckeln är alternativet ` core.autocrlf` , som du bör förstå väl innan du ändrar det, och vara medveten om att konfigurationen kan vara global eller arkivspecifik (den lokala inställningen har företräde).

Granska din globala konfiguration med `--global` och kom ihåg att repositoryt kan ha ett annat värde som prioriteras. För att visa allt globalt, använd `git config --list --global` . Om du ser ovanligt beteende i repositoryt, kontrollera det lokala värdet och prioritera det efter dina behov.

Core.autocrlf-lägen i praktiken (Windows vs. Unix): `true` konverterar till CRLF vid utcheckning och tillbaka till LF vid commit; `input` konverterar bara till LF vid commit (idealiskt på Linux/macOS); `false` gör ingenting (och är ofta en kortsiktig lösning på långsiktiga problem på ett blandat system). På Windows är ` true` det mest förnuftiga alternativet om du vill undvika överraskningar.

Användbara kommandon för att justera och rensa upp ditt repository utan att göra det för komplicerat: om du vill att repository ska använda det globala värdet, ta bort den lokala nyckeln; om du föredrar att tvinga fram ett värde i det repository, konfigurera det utan `--global` . För att åtgärda blandade filer, omnormalisera och commit, och gruppera ändringarna i slutet av raden.

git config --list --global
# Ver el valor global efectivo

git config --unset core.autocrlf
# Quitar el valor local y heredar el global

git config core.autocrlf true
# Fijar el valor solo en el repo actual (Windows)

git add --renormalize .
# Recorrerá el repo y homogeneizará line endings según la config

git commit -m 'Homogeneizados los cambios de línea'
# Sube un solo commit de normalización

Men det finns något ännu bättre: en .gitattributes-fil i rotkatalogen som följer med koden. Med regeln *text=auto anger du att Git ska upptäcka textfiler och hantera radbrytningar korrekt (LF i repository; CRLF i Windows arbetskopia om tillämpligt). Och du kan finjustera den genom tillägget, t.ex. tvinga Visual Studio .sln-filer att alltid vara CRLF.

* text=auto
# Homogeneiza automáticamente (LF en el repo)

*.sln text eol=crlf
# Asegura CRLF en soluciones de Visual Studio

När du lägger till `.gitattributes` till ett befintligt repository, glöm inte att använda `git add --renormalize` och gruppera commiten. Detta förhindrar att varje bidragsgivare skapar sin egen "mega-commit-rensning". Det är en av de där uppgifterna man gör en gång och som sparar problem i åratal.

Konfigurera redigeraren: VS Code, EditorConfig och Visual Studio

Din editor spelar också en stor roll. I VS Code kan du ställa in radbrytningar från statusfältet eller med alternativet `files.eol` . Om ditt projekt använder radbrytningar, välj det bara, så är du klar; editorn sparar automatiskt utan att du behöver gå fil för fil. Den är snabb och undviker brusiga differenser.

Om alla i teamet använder en annan editor är det en livräddare att lägga till EditorConfig (.editorconfig) i rotkatalogen: det definierar konsekvent regler som radslut, kodning och mellanslag/tabbinställningar. De flesta moderna editorer respekterar det och det integreras sömlöst med Git och CI.

  Sättet att ändra Apple-ID utan ingång till e-posthantering

För de som använder Visual Studio finns det en dedikerad panel för att spara med specifik kodning och radbrytningar (Avancerade sparalternativ). Du kan komma åt den via Arkiv > Spara som > rullgardinsmenyn Spara > Spara med kodning , eller genom att placera Avancerade sparalternativ direkt i Arkiv-menyn för snabb åtkomst.

  1. öppnar Verktyg > Anpassa.
  2. Under fliken kommandonvälj Menyfältet och välj Arkiv.
  3. tryck Lägg till kommando, kategori Arkivoch lägger till Avancerade sparalternativ.
  4. Omplacera med Ladda upp/ladda ner och stäng den. Du har den redo.

Visual Studio kan också stöta på filer med olika separatorer (NEL, LS, PS). IDE:n försöker normalisera dem när den upptäcker inkonsekvenser och kommer att be dig om instruktioner. Att hålla dina .gitattributes och sparalternativ korrekt konfigurerade förhindrar att ditt projekt fylls med ovanliga skiftlägen.

Bortom CRLF och LF: NEL, LS, PS och kompani

Unicode betraktar vissa ytterligare kodpunkter som radslut: NEL (U+0085) , LS (U+2028) och PS (U+2029) , utöver VT (U+000B) och FF (U+000C) . Dessa är inte vanliga i app-/webbprojekt, men de förekommer i IBM-stordatorer (EBCDIC) och i vissa dokument som bearbetats med äldre eller nischade verktyg.

För kompatibilitet replikerar Unicode standard ASCII-kontrollerna med samma numeriska värden (CR och LF), och lägger till nya för förlustfria konverteringar mellan kodningar (t.ex. mappning av EBCDIC NL till Unicode NEL). Om du får en "konstig" fil kommer en modern editor vanligtvis att visa eller uppmana dig att normalisera den.

Karaktär beskrivning Unicode
CR LF Återbetalning + förskott U+000D + U+000A
LF Linjematning U+000A
NEL Nästa rad U + 0085
LS Linjeavgränsare U + 2028
PS Styckeavgränsare U + 2029

I äldre versioner av Windows Anteckningar visades inte ens LF korrekt; idag är stödet mycket bättre, men NEL är fortfarande problematiskt i vissa miljöer. Därför är det, för repositorier och CI/CD, den vinnande strategin att behålla allt i LF-format i repositoriet och lämna CRLF för arbetskopian till Git/editorer i Windows.

Programmeringsspråk och radbrytningar (\r, \n och traps)

I strängar tillåter många språk escape-sekvenser: \n = LF , \r = CR . Med dessa skriver du CRLF som \r\n vid behov, eller infogar en "ren" LF med \n. Men var medveten om att inte alla runtime-sekvenser beter sig på samma sätt.

Fall att tänka på: I Java , utöver \ry\n, har du %n (formatterare) och System.lineSeparator() för att hämta systemradbrytningen på ett portabelt sätt; i C# gör Environment.NewLine detsamma; i PHP finns PHP_EOL ; i Python , os.linesep . Om du vill skriva ut enligt plattformen, använd dessa konstanter istället för att förlita dig på CRLF.

Särskild försiktighet bör iakttas med C och C++ : i textläge kan sekvensen \n mappas till systemets radbrytning (CRLF i Windows), och om du skriver ut \r\n kan du generera CRCRLF . I binärt läge är det bokstavligt. Denna subtilitet överraskar många när de kompilerar i Windows och testar i Linux.

I JavaScript/TypeScript räcker \n vanligtvis för de flesta användningsområden, men om du bearbetar Windows-användarinmatning ser du \r\n och du måste normalisera när du bryter rader. Dessutom, när du genererar HTML, styrs den slutliga layouten av taggarna (p., br, p, h2…), inte \r\n-tecknen.

// C#
var s1 = "Primera\nSegunda";            // LF explícito
var s2 = "Primera" + Environment.NewLine + "Segunda"; // Salto del sistema

// Java
String a = "Uno\r\nDos";                 // CRLF explícito
String b = "Uno" + System.lineSeparator() + "Dos";    // Portátil

// Python
s = 'Linea1' + os.linesep + 'Linea2'

// JavaScript
const t = 'L1\nL2'; // Normaliza entrada si viene con \r\n

Om du genererar nätverkstrafik, kom ihåg att protokoll som HTTP, SMTP, FTP och IRC är strikta: headers och många kontrolllinjer måste använda CRLF . Inga "påhitt": anpassa din utdata till RFC, annars kommer du att stöta på servrar som avvisar dina förfrågningar.

  Hur man undviker och hanterar IP-avstängningar i Minecraft

Hur man på ett tillförlitligt sätt upptäcker och konverterar radavslutningar

Det finns ingen enskild "BOM" som anger vilken typ av radbrytning det är i en fil: du måste titta på bytena . I praktiken räknar verktyg CR (0x0D) och LF (0x0A) och analyserar deras mönster: om de visas parvis är det vanligtvis CRLF; om bara 0x0A visas är det LF; om det finns en inkonsekvent blandning har du en röra som behöver åtgärdas.

Vissa redigerare upptäcker och varnar dig; VS Code visar det i statusfältet; Visual Studio kan erbjuda normalisering. I Git är det säkraste tillvägagångssättet att definiera `.gitattributes` och, om nödvändigt, omnormalisera för att anpassa hela trädet till policyn. Ditt arkiv (och dina revisioner) kommer att tacka dig.

Vad händer om du arbetar med "exotiska format"? Redigerare som Notepad++ och VS Code hanterar CRLF och LF bra och identifierar vanligtvis LS/PS . För NEL och EBCDIC behöver du ibland utföra en förkonvertering av kodningen utöver radbrytningen.

Den vinnande strategin för de flesta projekt är enkel: spara till arkivet med LF , aktivera automatisk konvertering i Windows och blockera undantag med eol=crlf för filer som behöver det (t.ex. .sln). Allt annat är undvikbara problem.

Repos med blandade radbrytningar: hur man fixar röran

Det är väldigt vanligt: ​​delar av koden kommer från Linux (LF) och andra delar har modifierats i Windows (CRLF). Resultatet är ett träd med blandade rader, oläsliga skillnader och folk som undrar varför deras skript inte startar idag. Dags att få ordning på saker och ting.

Snabb och säker plan :

  1. tillägger .gitattributes med * text=auto och specifika regler om det behövs (t.ex. *.sln text eol=crlf).
  2. Springa git add –renormalize. att låta Git gå igenom repot och justera radbrytningar enligt reglerna.
  3. Gör en enda commit med ett tydligt budskap (t.ex. ”Homogeniserade linjeändringar”).
  4. Låt teamet veta och fråga dra innan man går vidare för att minimera konflikter.

Om du har känsliga skript (sh, py, etc.), se till att de sparas med LF och att själva texten inte är skadad. Du kan framtvinga detta med mönster i .gitattributes eller kontrollera det i din editor innan du genomför commit.

Om Visual Studio upptäcker inkonsekventa hopp föreslår den normalisering. Acceptera, granska skillnaden och genomför sedan den föregående omnormaliseringen för att säkerställa att allt fungerar korrekt.

Från och med det ögonblicket, med .gitattributes och core.autocrlf korrekt konfigurerade, var korrigeringarna "den här gången bearbetades det av CRLF" ett minne blott . Och om någon öppnar projektet i Linux eller macOS kommer allt att förbli detsamma eftersom filerna i arkivet sparas med LF.

Format som stöds av Microsoft Office och när det är bäst att använda vart och ett
Relaterad artikel:
Microsoft Office-format: Vad de är och när man ska använda var och en
Isaac

Isaac

Passionerad författare om bytesvärlden och tekniken i allmänhet. Jag älskar att dela med mig av min kunskap genom att skriva, och det är vad jag kommer att göra i den här bloggen, visa dig alla de mest intressanta sakerna om prylar, mjukvara, hårdvara, tekniska trender och mer. Mitt mål är att hjälpa dig att navigera i den digitala världen på ett enkelt och underhållande sätt.