Convertir HTML a cadena de JavaScript: guía y errores

PublicadoHerramientaConvertidor de HTML a Cadena JS

Contenido
  1. Por qué surge este problema en la práctica
  2. Cómo convertir a mano, sin herramienta
  3. Puntos que suelen confundir y errores habituales
  4. En resumen
  5. Preguntas frecuentes

Cuando pasas un bloque de código HTML a una variable de cadena de JavaScript, lo que debes hacer es conservar los saltos de línea como datos en lugar de como saltos reales, y escapar únicamente las comillas que coinciden con el símbolo que envuelve la cadena. Así podrás pegarla sin errores de sintaxis. Si haces este proceso a mano, basta con olvidar una línea o una comilla para que el error solo aparezca en tiempo de ejecución. Este artículo explica por qué los modos de comillas dobles y simples funcionan de forma distinta al modo de comillas invertidas (template literals), y qué debes comprobar antes de pegar el resultado en tu código.

Resumen ① Los modos de comillas dobles y simples cortan la cadena en cada línea y la vuelven a unir con "\n" y +. Esto se debe a que una cadena normal no puede contener saltos de línea reales dentro del código fuente. ② El modo de comillas invertidas deja los saltos de línea tal cual y solo escapa la comilla invertida (`) y ${. Esto se debe a que los template literals son, por definición, una sintaxis que admite varias líneas. ③ Si aparece un error de sintaxis después de la conversión, casi siempre es porque cambiaste a mano el símbolo que envuelve la cadena, o porque copiaste solo una parte de un resultado de varias líneas y se quedó fuera el punto y coma de la última.

Por qué surge este problema en la práctica

Es frecuente tener que meter un bloque de marcado HTML completo dentro de una sola variable de cadena de JavaScript: el script de un widget que se inserta en una página estática, el código de envío de correos, el content script de una extensión de navegador. Es la situación típica en la que un desarrollador traslada al archivo de código un fragmento de HTML creado por un diseñador o un maquetador.

Si copias el HTML tal cual y lo pegas entre comillas, las comillas de los atributos de las etiquetas, como class="box", chocan con las comillas que envuelven la cadena y la cortan en ese punto. Además, el HTML suele ocupar varias líneas, y una cadena normal de JavaScript no permite saltos de línea reales dentro del código fuente.

Por eso hay que tratar los saltos de línea y las comillas según sus propias reglas, y esas reglas dependen del tipo de comilla con la que envuelvas la cadena.

Cómo convertir a mano, sin herramienta

Si entiendes el principio, puedes hacerlo tú mismo. Primero decide con qué vas a envolver la cadena.

Trabajar en modo de comillas dobles o simples

Si eliges comillas dobles (") o comillas simples ('), sigue este orden:

  1. Divide el HTML en varias líneas, cortando en cada salto de línea.
  2. Dentro de cada línea, si el original tiene una barra invertida (), escápala primero como \.
  3. En esa misma línea, cada vez que aparezca el mismo carácter que el símbolo que envuelve la cadena (una " si elegiste comillas dobles, una ' si elegiste simples), añade una \ delante.
  4. Añade al final de la línea un "\n" que representa el salto, y envuelve todo entre comillas.
  5. Si no es la última línea, añade detrás el operador de concatenación + para enlazarla con la cadena de la línea siguiente; solo en la última línea pon en lugar de + un punto y coma ; que cierra la sentencia.

La razón de cortar las líneas y volver a unirlas con + es sencilla. Una cadena normal envuelta en "..." o '...' que contenga un salto de línea real en medio del código fuente se interpreta como una cadena sin cerrar en ese punto y da error.

Por eso el salto real se sustituye por el carácter "\n", y el salto de línea del código fuente se imita encadenando varias cadenas con el operador +.

Trabajar en modo de comillas invertidas

Si eliges comillas invertidas (`), es distinto. No hace falta cortar líneas: metes todo el HTML entre dos comillas invertidas, tal cual. Los template literals, introducidos en ES6, son precisamente una sintaxis pensada para admitir saltos de línea reales dentro del código fuente.

En este caso solo hay dos cosas que escapar. Si el original contiene una comilla invertida (), cámbiala por \, y si contiene ${, el símbolo de las expresiones que insertan variables, cámbialo por ${.

Si dejas ${ tal cual, JavaScript intentará interpretar lo que viene después como código, lo que lleva a un comportamiento no deseado o a un error. En cambio, las comillas normales (", ') en el modo de comillas invertidas son simples caracteres sin ningún significado especial, así que no hay que escaparlas.

Cuando procesas a mano un HTML con muchas líneas siguiendo estas reglas, es fácil que se te escape una barra invertida o una comilla en alguna línea. Las reglas son exactamente las de arriba, así que solo tienes que reducir el trabajo repetitivo. Compruébalo con nuestra herramienta.

Convertidor de HTML a Cadena JS

Convierte bloques de HTML en declaraciones de cadena de JavaScript con tres modos: comillas dobles, comillas simples y backticks. No necesitas instalar nada ni registrarte.

Puntos que suelen confundir y errores habituales

ModoTratamiento de los saltos de líneaQué se escapa
Comillas dobles "Se corta por líneas y se unen con "\n" +Comillas dobles ("), barra invertida ()
Comillas simples 'Se corta por líneas y se unen con "\n" +Comillas simples ('), barra invertida ()
Comillas invertidas `Se mantienen tal cual (no se cortan líneas)Comilla invertida (`), ${

El error más común es cambiar a mano solo el símbolo que envuelve la cadena después de obtener el resultado. Por ejemplo, tomas un resultado convertido en modo de comillas invertidas y luego sustituyes tú mismo las comillas invertidas por comillas dobles, y ahí surgen los problemas.

Como el modo de comillas invertidas no escapó las " ni las ', las comillas que había dentro de los atributos HTML siguen ahí y cortan la cadena por la mitad. Si necesitas un resultado con comillas dobles, vuelve a seleccionar el modo de comillas dobles en la herramienta y convierte de nuevo.

El segundo error es no volver a pulsar el botón de conversión después de modificar la entrada. Esta herramienta no recalcula automáticamente cuando cambia el contenido del campo de entrada: el resultado solo se actualiza al pulsar el botón "Convertir a cadena JS". Si editas el HTML y copias el resultado anterior, el código y lo que ves en pantalla dejan de coincidir.

El tercero es copiar solo una parte de un resultado dividido en varias líneas. En el resultado de los modos de comillas dobles y simples, casi todas las líneas terminan en + y solo la última acaba en punto y coma. Si copias sin el final del resultado, te queda una sentencia incompleta que termina en + y no continúa; y si pegas otro código justo después del resultado, añades tokens extraños detrás de una sentencia que ya terminaba en punto y coma, y se produce un error.

En resumen

  • Las cadenas normales (", ') no admiten saltos de línea reales dentro del código fuente, así que los modos de comillas dobles y simples dividen por líneas y unen con "\n" +.
  • Los template literals con comillas invertidas admiten varias líneas, así que no hace falta cortar y solo se escapan la comilla invertida y ${.
  • El modo de comillas invertidas no escapa las comillas normales, por lo que no debes limitarte a cambiar a mano el símbolo que envuelve la cadena después de la conversión.
  • Antes de pegar el resultado, comprueba que la última línea termina en punto y coma y que todas las anteriores se enlazan con +.
  • Si modificaste la entrada, vuelve a pulsar el botón de conversión para obtener el resultado actualizado.
Convertidor de HTML a Cadena JS

Convierte bloques de HTML en declaraciones de cadena de JavaScript con tres modos: comillas dobles, comillas simples y backticks. No necesitas instalar nada ni registrarte.

Preguntas frecuentes

¿Por qué el modo de comillas invertidas no escapa las comillas?

Porque dentro de una cadena con comillas invertidas, " y ' no son delimitadores, sino caracteres normales. El único símbolo que JavaScript reconoce como final de la cadena es la misma comilla invertida con la que empezó, así que lo único que hay que escapar es la propia comilla invertida y ${, el símbolo de inserción de expresiones.

Pegé el resultado y me da un error de sintaxis. ¿Por qué?

Casi siempre es una de dos cosas: modificaste el HTML y copiaste el resultado anterior sin volver a pulsar el botón de conversión, o copiaste solo una parte de un resultado dividido en varias líneas y falta el punto y coma de la última, o se pegó otro código detrás de forma incorrecta. Lo más rápido es volver a copiar el panel de resultados completo, de principio a fin, y comprobarlo.

¿Qué pasa si el HTML original tiene barras invertidas?

En los modos de comillas dobles y simples, las barras invertidas de cada línea también se escapan, así que se escriben como \ (dos barras). Cuando trabajes con texto que contiene barras invertidas, como rutas o patrones de expresiones regulares, ten en cuenta que es normal que en el resultado aparezcan dos barras en lugar de una.

¿Puedo convertir después un resultado del modo de comillas invertidas a una cadena con comillas dobles?

No es recomendable. Como el modo de comillas invertidas no escapa las " ni las ', si cambias a mano solo el símbolo que envuelve la cadena, las comillas de los atributos HTML siguen ahí y cierran la cadena antes de tiempo. Si necesitas un resultado con comillas dobles, lo seguro es volver a seleccionar el modo de comillas dobles en la herramienta y convertir de nuevo.

Este artículo está adaptado de nuestro original en coreano. Leer el original en coreano

Artículos relacionados

  1. Eliminar espacios en HTML: por qué solo se borran entre etiquetasQué borra realmente la minificación de HTML: espacios entre etiquetas, saltos de línea y comentarios, y por qué script, style, pre y textarea se conservan intactos.
  2. Generador de htpasswd: crea el archivo sin instalar nadaCrea la línea usuario:hash de .htpasswd para la autenticación básica de Apache y Nginx en el navegador, con la estructura {SHA} y {SHA256} explicada.
  3. Diferencia entre 401 y 403: cómo distinguirlos de un vistazoAprende a separar los códigos HTTP por su primera cifra y a diferenciar 401 y 403, 400 y 404, 502, 503 y 504 según la situación real en que aparecen.
  4. Cómo convertir una imagen a Base64 y leer el resultadoPor qué el resultado crece un 33 %, en qué se diferencian Data URL y Plain Base64 y qué errores hacen que la imagen no se muestre al pegarla.
  5. Convertir estilos inline en clases CSS: cómo funcionaAsí extrae la herramienta el atributo style, lo convierte en clases numeradas y genera una hoja CSS externa, sin borrar el class que ya tenías.
  6. Reglas de abreviatura IPv6: cómo leer :: y la forma expandidaAprende las reglas para abreviar IPv6: omitir los ceros iniciales de cada bloque, comprimir con :: una sola vez y expandir la dirección a sus 8 bloques.

Herramientas relacionadas