PHP Conference China 2020

htmlentities

(PHP 4, PHP 5, PHP 7)

htmlentitiesConvertit tous les caractères éligibles en entités HTML

Description

htmlentities ( string $string [, int $flags = ENT_COMPAT | ENT_HTML401 [, string $encoding = ini_get("default_charset") [, bool $double_encode = TRUE ]]] ) : string

htmlentities() est identique à la fonction htmlspecialchars(), sauf que tous les caractères qui ont des équivalents en entités HTML sont effectivement traduits.

Si vous voulez réaliser l'opération inverse, vous devez utiliser la fonction html_entity_decode().

Liste de paramètres

string

La chaîne d'entrée.

flags

Un masque d'un ou plusieurs drapeaux suivants, qui déterminent la façon dont les guillemets seront gérés, dont les séquences de code invalide seront gérées ainsi que le type du document utilisé. Par défaut, ce sera ENT_COMPAT | ENT_HTML401.

Constantes disponibles pour flags
Constante Description
ENT_COMPAT Convertit les guillemets doubles, et ignore les guillemets simples.
ENT_QUOTES Convertit les guillemets doubles et les guillemets simples.
ENT_NOQUOTES Ignore les guillemets doubles et les guillemets simples.
ENT_IGNORE Ignore les séquences de caractères invalides plutôt que de retourner une chaine vide. L'utilisation de ce drapeau est fortement déconseillée pour des » raisons de sécurité.
ENT_SUBSTITUTE Remplace les séquences de code invalide avec un caractère de remplacement Unicode U+FFFD (UTF-8) ou &#FFFD; (sinon) au lieu de retourner une chaîne vide.
ENT_DISALLOWED Remplace les points du code invalides du document fourni avec un caractère de remplacement Unicode U+FFFD (UTF-8) ou &#FFFD; (sinon) au lieu de le laisser tel quel. Ceci peut être utile pour, par exemple, s'assurer du bon formatage de documents XML contenant du contenu externe.
ENT_HTML401 Gère le code comme étant du HTML 4.01.
ENT_XML1 Gère le code comme étant du XML 1.
ENT_XHTML Gère le code comme étant du XHTML.
ENT_HTML5 Gère le code comme étant du HTML 5.

encoding

Un argument optionnel définissant l'encodage utilisé lors de la convertion des caractères.

Si omis, la valeur par défaut du paramètre encoding varie suivant la version PHP utilisée. En PHP 5.6.0 et suivants, l'option de configuration default_charset sera utilisée comme valeur par défaut. En PHP 5.4 et 5.5, UTF-8 sera la valeur par défaut. Pour les versions plus anciennes, PHP utilisera ISO-8859-1.

Malgré le fait que cet argument soit techniquement optionnel, vous êtes vivement encouragé à spécifier la valeur correcte pour votre code si vous utilisez PHP 5.5 ou antérieures, ou si votre option de configuration default_charset a été définie de façon incorrecte pour l'entrée fournie.

Les jeux de caractères suivants sont supportés :

Jeux de caractères supportés
Jeux de caractères Alias Description
ISO-8859-1 ISO8859-1 Europe occidentale, Latin-1.
ISO-8859-5 ISO8859-5 Jeu de caractère cyrillique rarement utilisé (Latin/Cyrillic).
ISO-8859-15 ISO8859-15 Europe occidentale, Latin-9. Dispose du signe Euro, des caractères spéciaux français et finlandais, qui manquent au Latin-1 (ISO-8859-1).
UTF-8   Unicode 8 bits multioctets, compatible avec l'ASCII
cp866 ibm866, 866 Jeu de caractères Cyrillique spécifique à DOS.
cp1251 Windows-1251, win-1251, 1251 Jeu de caractères Cyrillic spécifique à Windows.
cp1252 Windows-1252, 1252 Jeu de caractères spécifique de Windows pour l'Europe occidentale.
KOI8-R koi8-ru, koi8r Russe.
BIG5 950 Chinois traditionnel, principalement utilisé à Taïwan.
GB2312 936 Chinois simplifié, officiel.
BIG5-HKSCS   Big5 avec les extensions de Hong Kong, chinois traditionnel.
Shift_JIS SJIS, SJIS-win, cp932, 932 Japonais
EUC-JP EUCJP, eucJP-win Japonais
MacRoman   Jeu de caractères utilisé par Mac OS.
''   Une chaîne vide active la détection de l'encodage depuis un script (multi-octet Zend), default_charset et la locale courante (voir nl_langinfo() et setlocale()), dans cet ordre. Non recommandé.

Note: Les autres jeux de caractères ne sont pas reconnus. L'encodage par défaut sera utilisé à la place et une alerte sera émise.

double_encode

Lorsque double_encode est désactivé, PHP n'encodera pas les entités html existantes. Par défaut, tout est converti.

Valeurs de retour

Retourne la chaîne encodée.

Si l'entrée string contient une séquence de code invalide dans l'encodage encoding fourni, une chaîne vide sera retournée, à moins que le drapeau ENT_IGNORE ou le drapeau ENT_SUBSTITUTE ne soit défini.

Historique

Version Description
5.6.0 La valeur par défaut pour le paramètre encoding a été modifiée pour être la valeur de l'option de configuration default_charset.
5.4.0 La valeur par défaut du paramètre encoding est maintenant UTF-8.
5.4.0 Les constantes ENT_SUBSTITUTE, ENT_DISALLOWED, ENT_HTML401, ENT_XML1, ENT_XHTML et ENT_HTML5 ont été ajoutées.
5.3.0 La constante ENT_IGNORE a été ajoutée.
5.2.3 Ajout du paramètre double_encode.

Exemples

Exemple #1 Exemple avec htmlentities()

<?php
$str 
'Un \'apostrophe\' en <strong>gras</strong>';

// Affiche : Un 'apostrophe' en &lt;strong&gt;gras&lt;/strong&gt;
echo htmlentities($str);

// Affiche : Un &#039;apostrophe&#039; en &lt;strong&gt;gras&lt;/strong&gt;
echo htmlentities($strENT_QUOTES);
?>

Exemple #2 Utilisation de ENT_IGNORE

<?php
$str 
"\x8F!!!";

// Affiche une chaine vide
echo htmlentities($strENT_QUOTES"UTF-8");

// Affiche "!!!"
echo htmlentities($strENT_QUOTES ENT_IGNORE"UTF-8");
?>

Voir aussi

add a note add a note

User Contributed Notes 21 notes

up
136
Sijmen Ruwhof
10 years ago
An important note below about using this function to secure your application against Cross Site Scripting (XSS) vulnerabilities.

When printing user input in an attribute of an HTML tag, the default configuration of htmlEntities() doesn't protect you against XSS, when using single quotes to define the border of the tag's attribute-value. XSS is then possible by injecting a single quote:

<?php
$_GET
['a'] = "#000' onload='alert(document.cookie)";
?>

XSS possible (insecure):

<?php
$href
= htmlEntities($_GET['a']);
print
"<body bgcolor='$href'>"; # results in: <body bgcolor='#000' onload='alert(document.cookie)'>
?>

Use the 'ENT_QUOTES' quote style option, to ensure no XSS is possible and your application is secure:

<?php
$href
= htmlEntities($_GET['a'], ENT_QUOTES);
print
"<body bgcolor='$href'>"; # results in: <body bgcolor='#000&#039; onload=&#039;alert(document.cookie)'>
?>

The 'ENT_QUOTES' option doesn't protect you against javascript evaluation in certain tag's attributes, like the 'href' attribute of the 'a' tag. When clicked on the link below, the given JavaScript will get executed:

<?php
$_GET
['a'] = 'javascript:alert(document.cookie)';
$href = htmlEntities($_GET['a'], ENT_QUOTES);
print
"<a href='$href'>link</a>"; # results in: <a href='javascript:alert(document.cookie)'>link</a>
?>
up
28
q (dot) rendeiro (at) gmail (dot) com
13 years ago
I've seen lots of functions to convert all the entities, but I needed to do a fulltext search in a db field that had named entities instead of numeric entities (edited by tinymce), so I searched the tinymce source and found a string with the value->entity mapping. So, i wrote the following function to encode the user's query with named entities.

The string I used is different of the original, because i didn't want to convert ' or ". The string is too long, so I had to cut it. To get the original check TinyMCE source and search for nbsp or other entity ;)

<?php

$entities_unmatched
= explode(',', '160,nbsp,161,iexcl,162,cent, [...] ');
$even = 1;
foreach(
$entities_unmatched as $c) {
    if(
$even) {
       
$ord = $c;
    } else {
       
$entities_table[$ord] = $c;
    }
   
$even = 1 - $even;
}

function
encode_named_entities($str) {
    global
$entities_table;
   
   
$encoded_str = '';
    for(
$i = 0; $i < strlen($str); $i++) {
       
$ent = @$entities_table[ord($str{$i})];
        if(
$ent) {
           
$encoded_str .= "&$ent;";
        } else {
           
$encoded_str .= $str{$i};
        }
    }
    return
$encoded_str;
}

?>
up
10
hajo-p
6 years ago
The flag ENT_HTML5 also strips newline chars like \n with htmlentities while htmlspecialchars is not affected by that.

If you want to use nl2br on that string afterwards you might end up searching the problem like i did. This does not apply to other flags like e.g. ENT_XHTML which confused me.

Tested this with PHP 5.4 / 5.5 / 5.6-dev with same results, so it seems that this is an intended "feature".
up
12
realcj at g mail dt com
13 years ago
If you are building a loadvars page for Flash and have problems with special chars such as " & ", " ' " etc, you should escape them for flash:

Try trace(escape("&")); in flash' actionscript to see the escape code for &;

% = %25
& = %26
' = %27

<?php
function flashentities($string){
return
str_replace(array("&","'"),array("%26","%27"),$string);
}
?>

Those are the two that concerned me. YMMV.
up
14
phil at lavin dot me dot uk
10 years ago
The following will make a string completely safe for XML:

<?php
function philsXMLClean($strin) {
       
$strout = null;

        for (
$i = 0; $i < strlen($strin); $i++) {
               
$ord = ord($strin[$i]);

                if ((
$ord > 0 && $ord < 32) || ($ord >= 127)) {
                       
$strout .= "&amp;#{$ord};";
                }
                else {
                        switch (
$strin[$i]) {
                                case
'<':
                                       
$strout .= '&lt;';
                                        break;
                                case
'>':
                                       
$strout .= '&gt;';
                                        break;
                                case
'&':
                                       
$strout .= '&amp;';
                                        break;
                                case
'"':
                                       
$strout .= '&quot;';
                                        break;
                                default:
                                       
$strout .= $strin[$i];
                        }
                }
        }

        return
$strout;
}
?>
up
18
n at erui dot eu
8 years ago
html entities does not encode all unicode characters. It encodes what it can [all of latin1], and the others slip through. &#1033; is the nasty I use. I have searched for a function which encodes everything, but in the end I wrote this. This is as simple as I can get it. Consult an ansii table to custom include/omit chars you want/don't. I'm sure it's not that fast.

// Unicode-proof htmlentities.
// Returns 'normal' chars as chars and weirdos as numeric html entites.
function superentities( $str ){
    // get rid of existing entities else double-escape
    $str = html_entity_decode(stripslashes($str),ENT_QUOTES,'UTF-8');
    $ar = preg_split('/(?<!^)(?!$)/u', $str );  // return array of every multi-byte character
    foreach ($ar as $c){
        $o = ord($c);
        if ( (strlen($c) > 1) || /* multi-byte [unicode] */
            ($o <32 || $o > 126) || /* <- control / latin weirdos -> */
            ($o >33 && $o < 40) ||/* quotes + ambersand */
            ($o >59 && $o < 63) /* html */
        ) {
            // convert to numeric entity
            $c = mb_encode_numericentity($c,array (0x0, 0xffff, 0, 0xffff), 'UTF-8');
        }
        $str2 .= $c;
    }
    return $str2;
}
up
10
wd at NOSPAMwd dot it
8 years ago
Hi there,

after several and several tests, I figured out that dot:

- htmlentities() function remove characters like "à","è",etc when you specify a flag and a charset

- htmlentities() function DOES NOT remove characters like those above when you DO NOT specify anything

So, let's assume that..

<?php

$str
= "Hèèèllooo";

$res_1 = htmlentities($str, ENT_QUOTES, "UTF-8");
$res_2 = htmlentities($str);

echo
var_dump($res_1); // Result: string '' (length=0)
echo var_dump($res_2); // string 'H&egrave;&egrave;&egrave;llooo' (length=30)

?>

I used this for a textarea content for comments. Anyway, note that using the "$res_2" form the function will leave unconverted single/double quotes. At this point you should use str_replace() function to perform the characters but be careful because..

<?php

$str
= "'Hèèèllooo'";

$res_2 = str_replace("'","&#039;",$str);
$res_2 = htmlentities($str);
echo
var_dump($res_2); // string '&amp;#039;H&egrave;&egrave;&egrave;llooo&amp;#039;'

$res_3 = htmlentities($str);
$res_3 = str_replace("'","&#039;",$res_3);
echo
var_dump($res_3); // string '&#039;H&egrave;&egrave;&egrave;llooo&#039;' --> Nice
?>

Hope it will helps you.

Regards,
W.D.
up
11
ustimenko dot alexander at gmail dot com
8 years ago
For those Spanish (and not only) folks, that want their national letters back after htmlentities :)

<?php
protected function _decodeAccented($encodedValue, $options = array()) {
   
$options += array(
       
'quote'     => ENT_NOQUOTES,
       
'encoding'  => 'UTF-8',
    );
    return
preg_replace_callback(
       
'/&\w(acute|uml|tilde);/',
       
create_function(
           
'$m',
           
'return html_entity_decode($m[0], ' . $options['quote'] . ', "' .
           
$options['encoding'] . '");'
       
),
       
$encodedValue
   
);
}
?>
up
1
2962051004 at qq dot com
1 year ago
<?php

/**
* 将中文转为Html实体
* Convert Chinese in HTML to entity
* Author QiangGe
* Mail 2962051004@qq.com
*
*/

$str = <<<EOT
你好 world
EOT;

function
ChineseToEntity($str) {
return
preg_replace_callback(
       
'/[\x{4e00}-\x{9fa5}]/u', // utf-8
        // '/[\x7f-\xff]+/', // if gb2312
       
function ($matches) {
           
$json = json_encode(array($matches[0]));
           
preg_match('/\[\"(.*)\"\]/', $json, $arr);
           
/*
             * 通过json_encode函数将中文转为unicode
             * 然后用正则取出unicode
             * Turn the Chinese into Unicode through the json_encode function, then extract Unicode from regular.
             * I think this idea is seamless.
            */
           
return '&#x'. str_replace('\\u', '', $arr[1]). ';';
        },
$str
  
);
}

echo
ChineseToEntity($str);
// &#x4f60;&#x597d; world
up
7
Waygood
9 years ago
When putting values inside comment tags <!-- --> you should replace -- with &#45;&#45; too, as this would end your tag and show the rest of the comment.
up
5
robin at robinwinslow dot co dot uk
9 years ago
htmlentities seems to have changed at some point between version 5.1.6 and 5.3.3, such that it now returns an empty string for anything containing a pound sign:

$ php -v
PHP 5.1.6 (cli) (built: May 22 2008 09:08:44)
$ php -r "echo htmlentities('£hello', null, 'utf-8');"
&pound;hello
$

$ php -v
PHP 5.3.3 (cli) (built: Aug 19 2010 12:07:49)
$ php -r "echo htmlentities('£hello', null, 'utf-8');"
$

(Returns an empty string the second time)

Just a heads up.
up
5
admin at wapforum dot rs
9 years ago
A useful little function to convert the symbols in the different inputs.
<?php
function ConvertSimbols($var, $ConvertQuotes = 0) {
if (
$ConvertQuotes > 0) {
$var = htmlentities($var, ENT_NOQUOTES, 'UTF-8');
$var = str_replace('\"', '', $var);
$var = str_replace("\'", '', $var);
} else {
$var = htmlentities($var, ENT_QUOTES, 'UTF-8');
}
return
$var;
}
?>

Usage with quotes for example message:

$message = ConvertSimbols($message);

Usage without quotes for example link:

$link = ConvertSimbols($link, 1);
up
3
Bassie (:
17 years ago
Note that you'll have use htmlentities() before any other function who'll edit text like nl2br().

If you use nl2br() first, the htmlentities() function will change < br > to &lt;br&gt;.
up
2
Jeff
2 years ago
There is a feature when writing to XML using an AJAX call to PHP that rarely is mentioned. I struggled for many hours using htmlentities() because what was getting written to my XML document was not as expected. I naturally assumed that I should be converting my strings before writing them to XML to adhere to XML rules on illegal characters. To my surprise, when converting with htmlentities() or htmlspecialchars() and then writing to an XML file, the resulting ampersands get converted afterwards! Consider the following example:

<?php
$str
= "<b>I am cool</b>" ;
$str = htmlentities($str) ;
?>

When you append $str to an XML element and save() the document, you would expect the XML document's source code to look something like this:

<ele>&lt;b&gt;I am cool&lt;/b&gt;</ele>

But that is not what happens. The resulting ampersands get converted by PHP automatically to &amp; and your source code ends up looking like this:

<ele>&amp;lt;b&amp;gt;I am cool&amp;lt;/b&amp;gt;</ele>

As you can see, this creates problems when trying to output the XML data back to HTML. It is important to remember that when writing to XML this way, special characters like ">" and "<"; PHP converts them automatically and there becomes no need to use htmlentities() in certain cases. I assume this feature is in place to aid with passing data through header queries, to avoid reserved characters conflicting with others in a header query (e.g. & or =). Now I understand this may not be the case with older versions of PHP and that this might be a feature of my version (PHP version 5.6.32). With older versions, I assume using htmlentities() or htmlspecialchars() is a must, as stated with previous notes here. Also I use the charset UTF-8 in my HTML and XML and am not sure if this also effects the results I get.

Anyway, I struggled for many hours with using htmlentities() to convert strings for XML writing and saving, when all I had to do was simply not use the function and let PHP convert my strings for me. I hope this helps because I would think I am not the only one who has struggled with this situation.
up
1
chris at ocproducts dot com
3 years ago
This function throws a warning on bad input even if ENT_SUBSTITUTE is set, so be prepared for this.
up
4
jake_mcmahon at hotmail dot com
16 years ago
This fuction is particularly useful against XSS (cross-site-scripting-). XSS makes use of holes in code, whether it be in Javascript or PHP. XSS often, if not always, uses HTML entities to do its evil deeds, so this function in co-operation with your scripts (particularly search or submitting scripts) is a very useful tool in combatting "H4X0rz".
up
3
h_guillaume at hotmail dot com
10 years ago
I use this function to encode all the xml entities and also all the &something; that are not defined in xml like &trade;
You can also decode what you encode with my decode function.
My function works a little like the htmlentities.
You can also add other string to the array if you want to exclude them from the encoding.

<?php
function xml_entity_decode($text, $charset = 'Windows-1252'){
   
// Double decode, so if the value was &amp;trade; it will become Trademark
   
$text = html_entity_decode($text, ENT_COMPAT, $charset);
   
$text = html_entity_decode($text, ENT_COMPAT, $charset);
    return
$text;
}

function
xml_entities($text, $charset = 'Windows-1252'){
    
// Debug and Test
    // $text = "test &amp; &trade; &amp;trade; abc &reg; &amp;reg; &#45;";
   
    // First we encode html characters that are also invalid in xml
   
$text = htmlentities($text, ENT_COMPAT, $charset, false);
   
   
// XML character entity array from Wiki
    // Note: &apos; is useless in UTF-8 or in UTF-16
   
$arr_xml_special_char = array("&quot;","&amp;","&apos;","&lt;","&gt;");
   
   
// Building the regex string to exclude all strings with xml special char
   
$arr_xml_special_char_regex = "(?";
    foreach(
$arr_xml_special_char as $key => $value){
       
$arr_xml_special_char_regex .= "(?!$value)";
    }
   
$arr_xml_special_char_regex .= ")";
   
   
// Scan the array for &something_not_xml; syntax
   
$pattern = "/$arr_xml_special_char_regex&([a-zA-Z0-9]+;)/";
   
   
// Replace the &something_not_xml; with &amp;something_not_xml;
   
$replacement = '&amp;${1}';
    return
preg_replace($pattern, $replacement, $text);
}
?>
up
2
steve at mcdragonsoftware dot com
8 years ago
I'm glad 5.4 has xml support, but many of us are working with older installations, some of us still have to use PHP4. If you're like me you've been frustrated with trying to use htmlentites/htmlspecial chars with xml output. I was hoping to find an option to force numeric encoding, lacking that, I have written my own xmlencode function, which I now offer:

usage:

$string xmlencode( $string )

it will use htmlspecialchars for the valid xml entities amp, quote, lt, gt, (apos) and return the numeric entity for all other non alpha-numeric characters.

-------------------------------------------

<?php
if( !function_exists( 'xmlentities' ) ) {
    function
xmlentities( $string ) {
       
$not_in_list = "A-Z0-9a-z\s_-";
        return
preg_replace_callback( "/[^{$not_in_list}]/" , 'get_xml_entity_at_index_0' , $string );
    }
    function
get_xml_entity_at_index_0( $CHAR ) {
        if( !
is_string( $CHAR[0] ) || ( strlen( $CHAR[0] ) > 1 ) ) {
            die(
"function: 'get_xml_entity_at_index_0' requires data type: 'char' (single character). '{$CHAR[0]}' does not match this type." );
        }
        switch(
$CHAR[0] ) {
            case
"'":    case '"':    case '&':    case '<':    case '>':
                return
htmlspecialchars( $CHAR[0], ENT_QUOTES );    break;
            default:
                return
numeric_entity_4_char($CHAR[0]);                break;
        }       
    }
    function
numeric_entity_4_char( $char ) {
        return
"&#".str_pad(ord($char), 3, '0', STR_PAD_LEFT).";";
    }   
}
?>
up
1
Tom Walter
11 years ago
Note that as of 5.2.5 it appears that if the input string contains a character that is not valid for the output encoding you've specified, then this function returns null.

You might expect it to just strip the invalid char, but it doesn't.

You can strip the chars yourself like so:

iconv('utf-8','utf-8',$str);

You can combine that with htmlentities also:

$str = htmlentities(iconv('UTF-8', 'UTF-8//IGNORE', $str, ENT_QUOTES, 'UTF-8');

Should give you a string with htmlentities encoded to utf-8, and any unsupported chars stripped.
up
0
za at byza dot it
12 years ago
Trouble when using files with different charset?

htmlentities and html_entity_decode can be used to translate between charset!

Sample function:

<?php
function utf2latin($text) {
  
$text=htmlentities($text,ENT_COMPAT,'UTF-8');
   return
html_entity_decode($text,ENT_COMPAT,'ISO-8859-1');
}
?>
up
-2
drallen at cs dot uwaterloo dot ca
9 years ago
A pointer to http://www.php.net/manual/en/function.mb-convert-encoding.php if your intention is to translate *all* characters in a charset to their corresponding HTML entities, not just named characters. Non-named characters will be replaced with HTML numeric encoding. eg:

$text = mb_convert_encoding($text, 'HTML-ENTITIES', "UTF-8");
To Top