ToolDeck

HTML to JSX

Převeďte HTML na JSX pro React — class→className, style řetězce→objekty

Zkusit příklad

HTML vstup

JSX výstup

Běží lokálně · Bezpečné pro vkládání tajných údajů
JSX výstup se zobrazí zde…

Co je převod HTML na JSX?

Převod HTML na JSX je proces transformace standardního HTML kódu do syntaxe JSX, kterou mohou vykreslovat React komponenty. JSX vypadá podobně jako HTML, ale řídí se konvencemi a pravidly JavaScriptu. Atributy jako class se stávají className, for se stává htmlFor a řetězce inline stylů jsou nahrazeny objekty JavaScriptu. Tyto změny jsou povinné, protože JSX se kompiluje na volání React.createElement(), kde názvy atributů musí odpovídat názvům vlastností DOM API, nikoli názvům HTML atributů.

Mapování mezi HTML atributy a JSX props je definováno dokumentací DOM elementů Reactu. React používá camelCase pro vícesvá atributy (tabindex se stává tabIndex, maxlength se stává maxLength), protože identifikátory JavaScriptu nemohou obsahovat pomlčky. Samouzavírací značky jako <img>, <br> a <input> musí v JSX obsahovat koncové lomítko (<img />), protože JSX se řídí pravidly XML, kde každá značka musí být explicitně uzavřena.

htmlToJsxContent.whatBody3

Proč použít převodník HTML na JSX?

Ruční přejmenování atributů a přepisování řetězců stylů napříč desítkami HTML elementů je pomalé a náchylné k chybám. Převodník zvládne všechny transformace najednou — vložte HTML z libovolného zdroje a získejte platný JSX během několika sekund.

Okamžitý převod
Vložte libovolný HTML fragment a okamžitě získejte JSX výstup. Převodník zpracuje class, for, style, obslužné rutiny událostí, booleovské atributy a samouzavírací značky v jediném průchodu.
🔒
Zpracování zaměřené na soukromí
Veškerý převod běží lokálně ve vašem prohlížeči. Vaše HTML nikdy neopustí stránku, takže můžete bezpečně převádět kód obsahující interní kód, API endpointy nebo citlivý obsah.
📋
Bez účtu a bez nastavení
Otevřete stránku a začněte převádět. Není potřeba žádné přihlášení, žádné npm balíčky k instalaci ani žádný build krok ke konfiguraci. Funguje na libovolném zařízení s moderním prohlížečem.
🔧
Úplné pokrytí atributů
Převádí všechna standardní mapování HTML na JSX atributů včetně className, htmlFor, tabIndex, readOnly, autoComplete a více než 20 dalších. Zpracovává také přejmenování obslužných rutin události z onclick na onClick.

Případy použití HTML na JSX

Frontend vývojář: migrace šablon
Při přesouvání existující HTML stránky nebo komponenty do React projektu vložte kód do převodníku místo ručního hledání atributů class a for napříč stovkami řádků.
Backend vývojář: vkládání HTML e-mailů
E-mailové šablony se píší v čistém HTML. Při jejich vykreslování uvnitř React administračního dashboardu nebo komponenty pro náhled převeďte HTML na platný JSX, aby nedocházelo k chybám syntaxe className a style.
DevOps: převod widgetů dashboardu
Monitorovací dashboardy často používají HTML fragmenty pro vlastní widgety. Převeďte je na JSX při integraci do platformy interních nástrojů postavené na Reactu, jako je Retool nebo vlastní administrační panel.
QA inženýr: reprodukce hlášení chyb
Pokud hlášení chyby obsahuje surový HTML výstup, převeďte ho na JSX a rychle ho vykreslete uvnitř React testovacího nástroje nebo Storybook story pro vizuální kontrolu a ladění.
Designér: prototypování z HTML návrhů
Návrhářské nástroje jako Figma exportují HTML/CSS. Převeďte exportovaný kód na JSX a vložte ho přímo do React prototypu bez ručního čištění atributů.
Student: učení syntaxe Reactu
Porovnávejte HTML vstup s JSX výstupem vedle sebe a pochopte, které atributy se mění a proč. Sledování transformace usnadní zapamatování konvencí pojmenování v Reactu lépe než samotné čtení dokumentace.

Referenční tabulka mapování HTML na JSX atributy

Tabulka níže uvádí HTML atributy, které se při převodu na JSX mění. Atributy zde neuvedené (id, src, href, alt, placeholder atd.) zůstávají beze změny, protože jejich HTML názvy již odpovídají názvům příslušných vlastností DOM API.

HTML atributJSX propPoznámky
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

Převod inline stylů: HTML vs JSX

Inline styly jsou nejnáchylnější části převodu HTML na JSX, protože se mění jak formát hodnoty, tak názvy vlastností:

HTML atribut style
Řetězec CSS deklarací oddělených středníky. Názvy vlastností používají kebab-case (background-color, font-size, border-radius). Hodnoty jsou vždy řetězce, včetně numerických hodnot s jednotkami.
<div style="background-color: #fff;
  font-size: 14px;
  margin-top: 10px;">
JSX prop style
Objekt JavaScriptu s názvy vlastností v camelCase (backgroundColor, fontSize, borderRadius). Řetězcové hodnoty jsou v uvozovkách. Numerické hodnoty bez jednotek (lineHeight, opacity, zIndex, flexGrow) mohou být čísla.
<div style={{
  backgroundColor: '#fff',
  fontSize: '14px',
  marginTop: 10
}}>

Ukázky kódu

Tyto příklady ukazují, jak programově převádět HTML na JSX v různých jazycích a prostředích. Každý pokrývá přejmenování atributů, převod stylů a zpracování samouzavíracích značek.

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

Často kladené otázky

Jaký je rozdíl mezi HTML a JSX?
JSX je rozšíření syntaxe JavaScriptu používané Reactem. Vypadá jako HTML, ale kompiluje se na volání React.createElement(). Hlavní rozdíly jsou: class se stává className, for se stává htmlFor, inline styly používají objekty JavaScriptu místo CSS řetězců a všechny značky musí být explicitně uzavřeny (včetně void elementů jako <img />). JSX také umožňuje vkládání JavaScriptových výrazů do složených závorek.
Proč React používá className místo class?
Slovo 'class' je rezervované klíčové slovo v JavaScriptu. Protože se JSX kompiluje na volání JavaScriptových funkcí, použití 'class' jako názvu prop by způsobilo chybu syntaxe. React zvolil 'className', protože odpovídá názvu vlastnosti DOM API (element.className), který JavaScript již používá ke čtení a nastavování CSS tříd na DOM elementech.
Musím HTML na JSX převádět ručně?
Ne. Můžete použít online převodník jako tento nástroj nebo to automatizovat pomocí knihoven jako htmltojsx (npm) nebo html-react-parser. Pro rozsáhlé migrace mohou nástroje jako codemod nebo jscodeshift transformovat celé kódové základny. Ruční převod je praktický pouze pro malé fragmenty o několika řádcích.
Jak jsou v JSX zpracovány inline styly?
htmlToJsxContent.a4
Mohu v JSX používat HTML komentáře?
Ne. HTML komentáře (<!-- komentář -->) nejsou v JSX platné. Místo toho použijte blokové komentáře JavaScriptu uzavřené do složených závorek: {/* komentář */}. Tento převodník transformaci provede automaticky. Komentáře JSX musí být uvnitř nadřazeného elementu, nikoli na nejvyšší úrovni návratové hodnoty komponenty.
Které HTML atributy zůstávají v JSX stejné?
Většina HTML atributů si v JSX zachovává původní názvy. Běžné příklady zahrnují id, src, href, alt, type, name, value, placeholder, disabled, hidden a všechny atributy data-* a aria-*. Změnit je potřeba pouze atributy, jejichž HTML název se liší od názvu vlastnosti DOM API: class na className, for na htmlFor a vícesvá atributy přecházející z malých písmen na camelCase.
Je dangerouslySetInnerHTML totéž jako převod HTML na JSX?
Ne. dangerouslySetInnerHTML obchází vykreslování Reactu a vkládá surové HTML přímo do DOM, což přináší riziko XSS zranitelností. Převod HTML na JSX produkuje skutečné React elementy, které procházejí virtuálním DOM Reactu a jsou ve výchozím nastavení bezpečné. Převod HTML na JSX používejte pro statický kód, který kontrolujete. dangerouslySetInnerHTML používejte pouze tehdy, když musíte vykreslit důvěryhodné HTML z externího zdroje, který nelze převést na JSX.