Encodeur et décodeur HTML pour le texte et les entités

Références de caractères HTML5

Les guillemets peuvent rester littéraux dans du texte HTML ordinaire ; échappez le guillemet correspondant lorsque vous insérez du texte dans un attribut délimité par des guillemets.

La liste des références de caractères nommées du WHATWG (en anglais)  définit les noms pris en charge par le HTML moderne.

Références de caractères HTML4

La traduction française de la référence des entités HTML 4.01  décrit l’ancien ensemble de noms. Le texte normatif du W3C (en anglais)  reste la référence. HTML4 ne définit pas ' ; utilisez ' pour une apostrophe si cette compatibilité est nécessaire. Les noms communs fonctionnent aussi en HTML5.

Références de caractères XML

XML ne définit que cinq noms d’entités prédéfinis . Cette traduction française est non normative ; le texte anglais du W3C  fait foi. Ils fonctionnent sans DTD ni déclaration personnalisée. Les références sont sensibles à la casse et nécessitent un point-virgule.

Les noms comme   et © ne sont pas prédéfinis en XML. Utilisez   pour une espace insécable ou © pour ©, ou déclarez les noms dans une DTD. Les références numériques doivent toujours désigner des caractères autorisés par XML.

Choisissez Texte avec guillemets pour échapper ces cinq caractères. Cet outil ne valide pas le XML et ne supprime pas les caractères interdits. Le mode Décoder applique les règles HTML5 ; il n’analyse pas du XML.

JavaScript et TypeScript

La bibliothèque entities (en anglais)  fonctionne dans Node.js et dans les applications pour navigateur. Installez-la avec npm install entities. Cet exemple utilise escapeText, comme l’option par défaut Texte HTML (recommandé) de cet outil. Utilisez escapeUTF8 pour Texte avec guillemets ou encodeNonAsciiHTML pour Entités étendues.

import { escapeText, decodeHTML } from "entities";

const text = "<p>Tea & coffee</p>";
const encoded = escapeText(text);
const decoded = decodeHTML(encoded);

console.log(encoded); // &lt;p&gt;Tea &amp; coffee&lt;/p&gt;
console.log(decoded); // <p>Tea & coffee</p>

Pour placer du texte brut sur une page web, l’affecter à textContent  évite de l’interpréter comme du balisage. encodeURIComponent effectue un encodage d’URL, qui est une opération différente.

Python

Le module html  intégré à Python propose les deux opérations. Sa documentation française comporte encore des passages en anglais. html.escape échappe les guillemets par défaut tout en conservant le texte Unicode ordinaire ; html.unescape reconnaît les références nommées et numériques HTML5.

import html

text = "<p>Tea & coffee</p>"
encoded = html.escape(text, quote=True)
decoded = html.unescape(encoded)

print(encoded)  # &lt;p&gt;Tea &amp; coffee&lt;/p&gt;
print(decoded)  # <p>Tea & coffee</p>

PHP

Utilisez htmlspecialchars  pour les caractères spéciaux et html_entity_decode  pour décoder les références. Les options explicites sélectionnent HTML5, échappent les deux types de guillemets et remplacent les séquences UTF-8 invalides pendant l’encodage. Les lettres Unicode ordinaires restent inchangées.

<?php
$text = '<p>Tea & coffee</p>';
$flags = ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML5;
$encoded = htmlspecialchars($text, $flags, 'UTF-8');
$decoded = html_entity_decode($encoded, $flags, 'UTF-8');

// Run in the CLI to inspect both strings as text.
echo $encoded, PHP_EOL; // &lt;p&gt;Tea &amp; coffee&lt;/p&gt;
echo $decoded, PHP_EOL; // <p>Tea & coffee</p>

C# et .NET

System.Net.WebUtility  fournit la conversion HTML sans paquet supplémentaire. HtmlEncode et HtmlDecode sont pratiques pour les chaînes ; ne supposez pas que chaque décodeur reconnaît toutes les références nommées HTML5.

using System;
using System.Net;

string text = "<p>Tea & coffee</p>";
string encoded = WebUtility.HtmlEncode(text);
string decoded = WebUtility.HtmlDecode(encoded);

Console.WriteLine(encoded); // &lt;p&gt;Tea &amp; coffee&lt;/p&gt;
Console.WriteLine(decoded); // <p>Tea & coffee</p>

Go

Le paquet standard html (en anglais)  de Go échappe les cinq caractères spéciaux et décode un ensemble plus large de références. Pour un véritable modèle HTML, préférez html/template (en anglais) , qui applique l’échappement selon le contexte.

package main

import (
    "fmt"
    "html"
)

func main() {
    text := "<p>Tea & coffee</p>"
    encoded := html.EscapeString(text)
    decoded := html.UnescapeString(encoded)

    fmt.Println(encoded) // &lt;p&gt;Tea &amp; coffee&lt;/p&gt;
    fmt.Println(decoded) // <p>Tea & coffee</p>
}

Rust

Ajoutez le crate html-escape (en anglais)  avec cargo add html-escape. Sa fonction encode_text échappe &, < et > pour du texte HTML ordinaire. Elle laisse les guillemets inchangés ; pour une valeur d’attribut entre guillemets, utilisez l’encodeur d’attribut approprié du crate. decode_html_entities décode les références nommées et numériques terminées, avec un comportement plus strict qu’un navigateur pour les entrées mal formées.

use html_escape::{decode_html_entities, encode_text};

fn main() {
    let text = "<p>Tea & coffee</p>";
    let encoded = encode_text(text);
    let decoded = decode_html_entities(encoded.as_ref());

    println!("{}", encoded); // &lt;p&gt;Tea &amp; coffee&lt;/p&gt;
    println!("{}", decoded); // <p>Tea & coffee</p>
}

Java

Ajoutez Apache Commons Text (org.apache.commons:commons-text) à votre projet Maven ou Gradle. Sa classe StringEscapeUtils (en anglais)  fournit escapeHtml4 et unescapeHtml4. Ces méthodes utilisent les noms HTML4, pas l’ensemble complet HTML5 ; escapeHtml4 n’échappe pas les apostrophes.

import org.apache.commons.text.StringEscapeUtils;

public class HtmlEntitiesExample {
    public static void main(String[] args) {
        String text = "<p>Tea & coffee</p>";
        String encoded = StringEscapeUtils.escapeHtml4(text);
        String decoded = StringEscapeUtils.unescapeHtml4(encoded);

        System.out.println(encoded); // &lt;p&gt;Tea &amp; coffee&lt;/p&gt;
        System.out.println(decoded); // <p>Tea & coffee</p>
    }
}

Swift

Ajoutez SwiftSoup avec Swift Package Manager (en anglais)  et incluez son produit dans votre cible. Utilisez Entities.escape  pour le texte HTML et Parser.unescapeEntities  pour décoder les références sans supprimer les balises ni afficher du HTML. L’argument false sélectionne le contexte texte plutôt que le contexte attribut pour le décodage. L’échappement du texte laisse les guillemets inchangés : ce n’est donc pas un encodeur de valeurs d’attribut entre guillemets.

import SwiftSoup

let text = "<p>Tea & coffee</p>"
let encoded = Entities.escape(text)

do {
    let decoded = try Parser.unescapeEntities(encoded, false)
    print(encoded) // &lt;p&gt;Tea &amp; coffee&lt;/p&gt;
    print(decoded) // <p>Tea & coffee</p>
} catch {
    print("Could not decode HTML entities: \(error)")
}

Delphi / Object Pascal

La classe TNetEncoding.HTML (en anglais)  de Delphi, dans System.NetEncoding, fournit Encode et Decode. Elle échappe &, <, > et les guillemets doubles. Son décodeur documenté reconnaît les références numériques et les noms amp, lt, gt et quot ; il ne faut pas attendre une prise en charge complète des entités nommées HTML5 ni l’échappement des apostrophes. Cet exemple utilise la bibliothèque d’exécution de Delphi, qui n’est pas partagée par tous les compilateurs Object Pascal.

program HtmlEntitiesExample;

{$APPTYPE CONSOLE}

uses
  System.NetEncoding;

var
  Text, Encoded, Decoded: string;
begin
  Text := '<p>Tea & coffee</p>';
  Encoded := TNetEncoding.HTML.Encode(Text);
  Decoded := TNetEncoding.HTML.Decode(Encoded);

  Writeln(Encoded); // &lt;p&gt;Tea &amp; coffee&lt;/p&gt;
  Writeln(Decoded); // <p>Tea & coffee</p>
end.