ToolDeck

HTML to JSX

Converteer HTML naar JSX voor React — class→className, stijlstrings→objecten

Probeer een voorbeeld

HTML-invoer

JSX-uitvoer

Draait lokaal · Veilig om secrets te plakken
JSX-uitvoer verschijnt hier…

Wat is HTML naar JSX-conversie?

HTML naar JSX-conversie is het proces waarbij standaard HTML-markup wordt omgezet naar JSX-syntaxis die React-componenten kunnen renderen. JSX lijkt op HTML maar volgt JavaScript-naamgevingsconventies en -regels. Attributen zoals class worden className, for wordt htmlFor, en inline stijlstrings worden vervangen door JavaScript-objecten. Deze wijzigingen zijn vereist omdat JSX compileert naar React.createElement()-aanroepen, waarbij attribuutnamen overeen moeten komen met de DOM API-eigenschapsnamen in plaats van HTML-attribuutnamen.

De koppeling tussen HTML-attributen en JSX-props is vastgelegd in de DOM-elementendocumentatie van React. React gebruikt camelCase voor samengestelde attributen (tabindex wordt tabIndex, maxlength wordt maxLength) omdat JavaScript-identifiers geen koppeltekens mogen bevatten. Zelfsluitende tags zoals <img>, <br> en <input> moeten een afsluitende slash bevatten in JSX (<img />) omdat JSX XML-regels volgt waarbij elke tag expliciet gesloten moet zijn.

htmlToJsxContent.whatBody3

Waarom een HTML naar JSX Converter gebruiken?

Handmatig attributen hernoemen en stijlstrings herschrijven over tientallen HTML-elementen is traag en foutgevoelig. Een converter verwerkt alle transformaties tegelijk: plak HTML uit welke bron dan ook en ontvang geldige JSX in seconden.

Directe conversie
Plak een willekeurig HTML-fragment en ontvang direct JSX-uitvoer. De converter verwerkt class, for, style, event handlers, booleaanse attributen en zelfsluitende tags in één doorgang.
🔒
Privacy-eerste verwerking
Alle conversie wordt lokaal in uw browser uitgevoerd. Uw HTML verlaat de pagina nooit, zodat u veilig markup kunt converteren die interne code, API-eindpunten of gevoelige inhoud bevat.
📋
Geen account of installatie
Open de pagina en begin met converteren. Geen login vereist, geen npm-pakketten te installeren, geen bouwstap te configureren. Werkt op elk apparaat met een moderne browser.
🔧
Volledige attribuutdekking
Converteert alle standaard HTML-naar-JSX-attribuutkoppelingen, inclusief className, htmlFor, tabIndex, readOnly, autoComplete en meer dan 20 andere. Verwerkt ook het hernoemen van onclick naar onClick voor event handlers.

Toepassingen van HTML naar JSX

Front-endontwikkelaar: sjablonen migreren
Wanneer u een bestaande HTML-pagina of -component naar een React-project overzet, plak de markup in de converter in plaats van handmatig te zoeken naar class- en for-attributen over honderden regels.
Back-endontwikkelaar: HTML-e-mails insluiten
E-mailsjablonen zijn geschreven in gewone HTML. Wanneer u ze weergeeft in een React-beheerdashboard of voorbeeldcomponent, zet de HTML om naar geldige JSX om className- en stijlsyntaxfouten te voorkomen.
DevOps: dashboard-widgets converteren
Monitoringdashboards gebruiken vaak HTML-fragmenten voor aangepaste widgets. Converteer deze naar JSX wanneer u ze integreert in een op React gebaseerd intern toolsplatform zoals Retool of een aangepast beheerpaneel.
QA-engineer: bugrapporten reproduceren
Wanneer een bugrapport ruwe HTML-uitvoer bevat, zet deze om naar JSX om het snel te renderen in een React-testomgeving of Storybook-story voor visuele inspectie en debuggen.
Designer: prototypes maken vanuit HTML-mockups
Ontwerptools zoals Figma exporteren HTML/CSS. Zet de geëxporteerde markup om naar JSX om deze direct in een React-prototype te plaatsen zonder handmatige attribuutopschoning.
Student: React-syntaxis leren
Vergelijk HTML-invoer met JSX-uitvoer naast elkaar om te begrijpen welke attributen veranderen en waarom. Het zien van de transformatie maakt React-naamgevingsconventies makkelijker te onthouden dan alleen documentatie lezen.

HTML naar JSX Attribuutkoppeling Naslagwerk

De onderstaande tabel geeft een overzicht van de HTML-attributen die veranderen bij conversie naar JSX. Attributen die hier niet staan (id, src, href, alt, placeholder, etc.) blijven ongewijzigd omdat hun HTML-namen al overeenkomen met de bijbehorende DOM API-eigenschapsnamen.

HTML-attribuutJSX-propOpmerkingen
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

Inline stijlconversie: HTML versus JSX

Inline stijlen zijn het meest foutgevoelige deel van HTML naar JSX-conversie, omdat zowel het waardeformaat als de eigenschapsnamen veranderen:

HTML-stijlattribuut
Een string van CSS-declaraties gescheiden door puntkomma's. Eigenschapsnamen gebruiken kebab-case (background-color, font-size, border-radius). Waarden zijn altijd strings, inclusief numerieke waarden met eenheden.
<div style="background-color: #fff;
  font-size: 14px;
  margin-top: 10px;">
JSX-stijlprop
Een JavaScript-object met camelCase-eigenschapsnamen (backgroundColor, fontSize, borderRadius). Stringwaarden staan tussen aanhalingstekens. Eenheidsloze numerieke waarden (lineHeight, opacity, zIndex, flexGrow) kunnen gewone getallen zijn.
<div style={{
  backgroundColor: '#fff',
  fontSize: '14px',
  marginTop: 10
}}>

Codevoorbeelden

Deze voorbeelden laten zien hoe u HTML naar JSX programmatisch converteert in verschillende talen en omgevingen. Elk voorbeeld behandelt het hernoemen van attributen, stijlconversie en de verwerking van zelfsluitende tags.

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>
}

Veelgestelde vragen

Wat is het verschil tussen HTML en JSX?
JSX is een syntaxisextensie voor JavaScript die door React wordt gebruikt. Het lijkt op HTML maar compileert naar React.createElement()-aanroepen. De belangrijkste verschillen zijn: class wordt className, for wordt htmlFor, inline stijlen gebruiken JavaScript-objecten in plaats van CSS-strings, en alle tags moeten expliciet gesloten zijn (inclusief lege elementen zoals <img />). JSX staat ook het insluiten van JavaScript-expressies toe binnen accolades.
Waarom gebruikt React className in plaats van class?
Het woord 'class' is een gereserveerd sleutelwoord in JavaScript. Omdat JSX compileert naar JavaScript-functie-aanroepen, zou het gebruik van 'class' als propnaam een syntaxisfout veroorzaken. React koos voor 'className' omdat dit overeenkomt met de DOM API-eigenschapsnaam (element.className) die JavaScript al gebruikt om CSS-klassen op DOM-elementen te lezen en in te stellen.
Moet ik HTML handmatig naar JSX converteren?
Nee. U kunt een online converter zoals dit hulpmiddel gebruiken, of het automatiseren met bibliotheken zoals htmltojsx (npm) of html-react-parser. Voor grootschalige migraties kunnen tools zoals codemod of jscodeshift hele codebases transformeren. Handmatige conversie is alleen praktisch voor kleine fragmenten van een paar regels.
Hoe worden inline stijlen verwerkt in JSX?
htmlToJsxContent.a4
Kan ik HTML-opmerkingen gebruiken in JSX?
Nee. HTML-opmerkingen (<!-- opmerking -->) zijn niet geldig in JSX. Gebruik in plaats daarvan JavaScript-blokopmerkingen omhuld met accolades: {/* opmerking */}. Deze converter verwerkt de transformatie automatisch. JSX-opmerkingen moeten binnen een ouderelement staan, niet op het hoogste niveau van een component-return.
Welke HTML-attributen blijven hetzelfde in JSX?
De meeste HTML-attributen behouden hun oorspronkelijke naam in JSX. Veelvoorkomende voorbeelden zijn id, src, href, alt, type, name, value, placeholder, disabled, hidden en alle data-*- en aria-*-attributen. Alleen attributen waarvan de HTML-naam afwijkt van de DOM API-eigenschapsnaam moeten veranderen: class naar className, for naar htmlFor en samengestelde attributen die overschakelen van kleine letters naar camelCase.
Is dangerouslySetInnerHTML hetzelfde als HTML naar JSX converteren?
Nee. dangerouslySetInnerHTML omzeilt het renderen van React en injecteert ruwe HTML direct in de DOM, wat XSS-kwetsbaarheden met zich mee kan brengen. Het converteren van HTML naar JSX produceert echte React-elementen die door de virtuele DOM van React worden verwerkt en standaard veilig zijn. Gebruik HTML-naar-JSX-conversie voor statische markup die u beheert. Gebruik dangerouslySetInnerHTML alleen wanneer u vertrouwde HTML van een externe bron moet renderen die niet naar JSX geconverteerd kan worden.