ToolDeck

HTML to JSX

Konvertera HTML till JSX för React — class→className, style-strängar→objekt

Prova ett exempel

HTML-inmatning

JSX-utmatning

Körs lokalt · Säkert att klistra in hemligheter
JSX-utmatning visas här…

Vad är HTML till JSX-konvertering?

HTML till JSX-konvertering är processen att omvandla vanlig HTML-uppmärkning till JSX-syntax som React-komponenter kan rendera. JSX liknar HTML men följer JavaScript-namnkonventioner och -regler. Attribut som class blir className, for blir htmlFor, och inline-stil-strängar ersätts med JavaScript-objekt. Dessa ändringar krävs eftersom JSX kompileras till React.createElement()-anrop, där attributnamn måste matcha DOM API:ets egenskapsnamn snarare än HTML-attributnamn.

Mappningen mellan HTML-attribut och JSX-props definieras av Reacts dokumentation för DOM-element. React använder camelCase för sammansatta attribut (tabindex blir tabIndex, maxlength blir maxLength) eftersom JavaScript-identifierare inte kan innehålla bindestreck. Självstängande taggar som <img>, <br> och <input> måste inkludera ett avslutande snedstreck i JSX (<img />) eftersom JSX följer XML-regler där varje tagg måste stängas explicit.

htmlToJsxContent.whatBody3

Varför använda ett HTML till JSX-verktyg?

Att manuellt byta namn på attribut och skriva om stil-strängar i dussintals HTML-element är långsamt och felbenäget. Ett verktyg hanterar alla omvandlingar på en gång och låter dig klistra in HTML från valfri källa och få giltig JSX på sekunder.

Omedelbar konvertering
Klistra in valfritt HTML-utdrag och få JSX-utdata direkt. Verktyget hanterar class, for, style, händelsehanterare, booleska attribut och självstängande taggar i ett enda pass.
🔒
Integritetsfokuserad bearbetning
All konvertering körs lokalt i din webbläsare. Din HTML lämnar aldrig sidan, så du kan säkert konvertera uppmärkning som innehåller intern kod, API-slutpunkter eller känsligt innehåll.
📋
Inget konto eller installation
Öppna sidan och börja konvertera. Ingen inloggning krävs, inga npm-paket att installera, inget byggsteg att konfigurera. Fungerar på alla enheter med en modern webbläsare.
🔧
Komplett attributtäckning
Konverterar alla vanliga HTML till JSX-attributmappningar inklusive className, htmlFor, tabIndex, readOnly, autoComplete och 20+ andra. Hanterar även namnbyte av händelsehanterare som onclick till onClick.

Användningsområden för HTML till JSX

Frontend-utvecklare: migrera mallar
När du flyttar en befintlig HTML-sida eller komponent till ett React-projekt, klistra in uppmärkningen i verktyget i stället för att manuellt jaga class- och for-attribut över hundratals rader.
Backend-utvecklare: bädda in HTML-e-post
E-postmallar skrivs i vanlig HTML. När de renderas inuti en React-adminpanel eller förhandsgranskningskomponent, konverterar du HTML till giltig JSX för att undvika syntaxfel med className och style.
DevOps: konvertera instrumentpanelwidgetar
Övervakningspaneler använder ofta HTML-utdrag för anpassade widgetar. Konvertera dem till JSX när du integrerar dem i en React-baserad internt verktygsplattform som Retool eller en anpassad adminpanel.
QA-ingenjör: återskapa felrapporter
När en felrapport innehåller rå HTML-utdata, konverterar du den till JSX för att snabbt rendera den inuti ett React-testramverk eller en Storybook-berättelse för visuell inspektion och felsökning.
Designer: prototyper från HTML-mockups
Designverktyg som Figma exporterar HTML/CSS. Konvertera den exporterade uppmärkningen till JSX för att lägga den direkt i en React-prototyp utan manuell attributrensning.
Student: lär dig React-syntax
Jämför HTML-indata med JSX-utdata sida vid sida för att förstå vilka attribut som ändras och varför. Att se omvandlingen gör det lättare att memorera Reacts namnkonventioner än att läsa dokumentation.

Referens: HTML till JSX-attributmappning

Tabellen nedan listar HTML-attribut som ändras vid konvertering till JSX. Attribut som inte listas här (id, src, href, alt, placeholder osv.) förblir oförändrade eftersom deras HTML-namn redan matchar motsvarande DOM API-egenskapsnamn.

HTML-attributJSX-propAnteckningar
classclassNameReserved word in JavaScript
forhtmlForReserved word in JavaScript
tabindextabIndexcamelCase convention
readonlyreadOnlycamelCase convention
maxlengthmaxLengthcamelCase convention
minlengthminLengthcamelCase convention
cellpaddingcellPaddingcamelCase convention
cellspacingcellSpacingcamelCase convention
rowspanrowSpancamelCase convention
colspancolSpancamelCase convention
enctypeencTypecamelCase convention
autocompleteautoCompletecamelCase convention
autofocusautoFocuscamelCase convention
autoplayautoPlaycamelCase convention
contenteditablecontentEditablecamelCase convention
crossorigincrossOrigincamelCase convention
novalidatenoValidatecamelCase convention
allowfullscreenallowFullScreencamelCase convention
spellcheckspellCheckcamelCase convention
http-equivhttpEquivHyphen removed, camelCase
onclickonClickEvent handler camelCase
onchangeonChangeEvent handler camelCase
onsubmitonSubmitEvent handler camelCase

Konvertering av inline-stilar: HTML vs JSX

Inline-stilar är den mest felbenägna delen av HTML till JSX-konvertering eftersom både värdeformatet och egenskapsnamnen ändras:

HTML style-attribut
En sträng av CSS-deklarationer separerade med semikolon. Egenskapsnamn använder kebab-case (background-color, font-size, border-radius). Värden är alltid strängar, inklusive numeriska värden med enheter.
<div style="background-color: #fff;
  font-size: 14px;
  margin-top: 10px;">
JSX style-prop
Ett JavaScript-objekt med camelCase-egenskapsnamn (backgroundColor, fontSize, borderRadius). Strängvärden är citerade. Enhetslösa numeriska värden (lineHeight, opacity, zIndex, flexGrow) kan vara enkla tal.
<div style={{
  backgroundColor: '#fff',
  fontSize: '14px',
  marginTop: 10
}}>

Kodexempel

Dessa exempel visar hur du konverterar HTML till JSX programmatiskt i olika språk och miljöer. Varje exempel täcker attributbyte, stilkonvertering och hantering av självstängande taggar.

JavaScript (DOM API)
// Simple attribute conversion using string replacement
function htmlToJsx(html) {
  return html
    .replace(/\bclass=/g, 'className=')
    .replace(/\bfor=/g, 'htmlFor=')
    .replace(/\btabindex=/g, 'tabIndex=')
    .replace(/<!--([\s\S]*?)-->/g, '{/*$1*/}')
}

htmlToJsx('<div class="box" tabindex="0"><!-- note --></div>')
// → '<div className="box" tabIndex="0">{/* note */}</div>'
JavaScript (html-react-parser)
import parse from 'html-react-parser'

// Parse HTML string into React elements (handles all JSX rules)
const element = parse('<div class="card"><img src="photo.jpg" alt="Photo"></div>')
// Returns: React.createElement('div', { className: 'card' },
//   React.createElement('img', { src: 'photo.jpg', alt: 'Photo' }))

// With custom element replacement
const options = {
  replace(domNode) {
    if (domNode.name === 'img') {
      return <OptimizedImage src={domNode.attribs.src} alt={domNode.attribs.alt} />
    }
  }
}
const custom = parse('<img src="photo.jpg" alt="Photo">', options)
Python (BeautifulSoup)
from bs4 import BeautifulSoup
import re

ATTR_MAP = {
    'class': 'className', 'for': 'htmlFor',
    'tabindex': 'tabIndex', 'readonly': 'readOnly',
    'maxlength': 'maxLength', 'autocomplete': 'autoComplete',
}

def html_to_jsx(html: str) -> str:
    """Convert HTML attribute names to JSX equivalents."""
    for html_attr, jsx_attr in ATTR_MAP.items():
        html = re.sub(rf'\b{html_attr}=', f'{jsx_attr}=', html)
    # Convert HTML comments to JSX comments
    html = re.sub(r'<!--(.*?)-->', r'{/*\1*/}', html)
    return html

print(html_to_jsx('<label for="email" class="field">Email</label>'))
# → '<label htmlFor="email" className="field">Email</label>'
Go
package main

import (
    "fmt"
    "strings"
)

var attrMap = map[string]string{
    "class=":    "className=",
    "for=":      "htmlFor=",
    "tabindex=": "tabIndex=",
    "readonly":  "readOnly",
}

func htmlToJSX(html string) string {
    result := html
    for old, new := range attrMap {
        result = strings.ReplaceAll(result, old, new)
    }
    // Convert comments
    result = strings.ReplaceAll(result, "<!--", "{/*")
    result = strings.ReplaceAll(result, "-->", "*/}")
    return result
}

func main() {
    html := `<div class="wrapper"><input readonly tabindex="1"></div>`
    fmt.Println(htmlToJSX(html))
    // → <div className="wrapper"><input readOnly tabIndex="1"></div>
}

Vanliga frågor

Vad är skillnaden mellan HTML och JSX?
JSX är en syntaxtillägg för JavaScript som används av React. Det liknar HTML men kompileras till React.createElement()-anrop. De viktigaste skillnaderna är: class blir className, for blir htmlFor, inline-stilar använder JavaScript-objekt i stället för CSS-strängar, och alla taggar måste stängas explicit (inklusive void-element som <img />). JSX tillåter även inbäddning av JavaScript-uttryck inom klammerparenteser.
Varför använder React className i stället för class?
Ordet 'class' är ett reserverat nyckelord i JavaScript. Eftersom JSX kompileras till JavaScript-funktionsanrop skulle 'class' som prop-namn orsaka ett syntaxfel. React valde 'className' eftersom det matchar DOM API-egenskapsnamnet (element.className) som JavaScript redan använder för att läsa och ange CSS-klasser på DOM-element.
Behöver jag konvertera HTML till JSX manuellt?
Nej. Du kan använda ett onlineverktyg som det här, eller automatisera det med bibliotek som htmltojsx (npm) eller html-react-parser. För storskaliga migreringar kan verktyg som codemod eller jscodeshift omvandla hela kodbaser. Manuell konvertering är bara praktisk för korta utdrag på några rader.
Hur hanteras inline-stilar i JSX?
I JSX tar style-attributet emot ett JavaScript-objekt, inte en CSS-sträng. Egenskapsnamn använder camelCase (backgroundColor i stället för background-color). Värden är strängar som standard, men vissa numeriska egenskaper som lineHeight, opacity och zIndex accepterar enkla tal utan enheter. De dubbla klammerparenteserna i style={{ color: 'red' }} är inte speciell syntax: de yttre klammerparenteserna är ett JSX-uttryck och de inre är ett JavaScript-objektliteral.
Kan jag använda HTML-kommentarer i JSX?
htmlToJsxContent.a5
Vilka HTML-attribut förblir oförändrade i JSX?
De flesta HTML-attribut behåller sina ursprungliga namn i JSX. Vanliga exempel inkluderar id, src, href, alt, type, name, value, placeholder, disabled, hidden samt alla data-*- och aria-*-attribut. Endast attribut vars HTML-namn skiljer sig från DOM API-egenskapsnamnet behöver ändras: class till className, for till htmlFor, och sammansatta attribut som byter från gemener till camelCase.
Är dangerouslySetInnerHTML detsamma som att konvertera HTML till JSX?
Nej. dangerouslySetInnerHTML kringgår Reacts rendering och injicerar rå HTML direkt i DOM, vilket medför risk för XSS-sårbarheter. Att konvertera HTML till JSX producerar faktiska React-element som passerar genom Reacts virtuella DOM och är säkra som standard. Använd HTML till JSX-konvertering för statisk uppmärkning du kontrollerar. Använd dangerouslySetInnerHTML bara när du måste rendera betrodd HTML från en extern källa som inte kan konverteras till JSX.