suche nach in der

htmlentities> <hex2bin
Last updated: Fri, 18 May 2012

view this page in

html_entity_decode

(PHP 4 >= 4.3.0, PHP 5)

html_entity_decode — Konvertiert alle benannten HTML-Zeichen in ihre entsprechenden Ursprungszeichen

Beschreibung

string html_entity_decode ( string $string [, int $flags = ENT_COMPAT | ENT_HTML401 [, string $encoding = 'UTF-8' ]] )

html_entity_decode() ist das Gegenstück zu htmlentities(), welches alle HTML-Entities innerhalb von string in ihre entsprechenden Ursprungszeichen zurückwandelt.

Parameter-Liste

string

Die Eingabezeichenkette.

flags

Eine Bitmaske von einem oder mehreren der folgenden Flags, die die Behandlung von Anführungszeichen, sowie den zu nutzenden Dokumententyp festlegen. Der Standardwert ist ENT_COMPAT | ENT_HTML401.

Verfügbare flags-Konstanten
Konstantenname Beschreibung
ENT_COMPAT Konvertiert doppelte Anführungszeichen und lässt einfache Anführungszeichen unberührt.
ENT_QUOTES Konvertiert sowohl doppelte als auch einfache Anführungszeichen.
ENT_NOQUOTES Lässt sowohl doppelte als auch einfache Anführungszeichen unberührt.
ENT_HTML401 Behandle Code als HTML 4.01.
ENT_XML1 Behandle Code als XML 1.
ENT_XHTML Behandle Code als XHTML.
ENT_HTML5 Behandle Code als HTML 5.

encoding

Zu verwendende Zeichenkodierung. Standardwert ist ISO-8859-1 in PHP Versionen vor 5.4.0 und UTF-8 in PHP 5.4.0 und neuer.

Die folgenden Zeichensätze werden mit PHP 4.3.0 und höher unterstützt:

Unterstützte Zeichensätze
Zeichensatz Alias Beschreibung
ISO-8859-1 ISO8859-1 Westeuropäisch, Latin-1
ISO-8859-15 ISO8859-15 Westeuropäisch, Latin-9. Enthält das Euro-Zeichen sowie französische und finnische Buchstaben, die in Latin-1(ISO-8859-1) fehlen.
UTF-8   ASCII-kompatibles Multi-Byte 8-Bit Unicode.
cp866 ibm866, 866 DOS-spezifischer Kyrillischer Zeichensatz. Dieser Zeichensatz wird ab PHP Version 4.3.2 unterstützt.
cp1251 Windows-1251, win-1251, 1251 Windows-spezifischer Kyrillischer Zeichensatz. Dieser Zeichensatz wird ab PHP Version 4.3.2 unterstützt.
cp1252 Windows-1252, 1252 Windows spezifischer Zeichensatz für westeuropäische Sprachen.
KOI8-R koi8-ru, koi8r Russisch. Dieser Zeichensatz wird ab PHP Version 4.3.2 unterstützt.
BIG5 950 Traditionelles Chinesisch, hauptsächlich in Taiwan verwendet.
GB2312 936 Vereinfachtes Chinesisch, nationaler Standard-Zeichensatz.
BIG5-HKSCS   Big5 mit Hongkong-spezifischen Erweiterungen; traditionelles Chinesisch.
Shift_JIS SJIS, 932 Japanisch
EUC-JP EUCJP Japanisch

Hinweis: Weitere Zeichensätze sind nicht implementiert, an ihrer Stelle wird ISO-8859-1 verwendet.

Rückgabewerte

Gibt die dekodierte Zeichenkette zurück.

Changelog

Version Beschreibung
5.4.0 Die Standardkodierung wurde von ISO-8859-1 auf UTF-8 geändert.
5.4.0 Die Optionen ENT_HTML401, ENT_XML1, ENT_XHTML und ENT_HTML5 wurden hinzugefügt.
5.0.0 Die Unterstützung für Multibyte-Kodierungen wurde hinzugefügt.

Beispiele

Beispiel #1 Dekodieren benannter HTML-Zeichen

<?php
$orig = "I'll \"walk\" the <b>dog</b> now";

$a = htmlentities($orig);

$b = html_entity_decode($a);

echo $a; // I'll &quot;walk&quot; the &lt;b&gt;dog&lt;/b&gt; now

echo $b; // I'll "walk" the <b>dog</b> now
?>

Anmerkungen

Hinweis:

Sie wundern sich vielleicht, warum trim(html_entity_decode('&nbsp;')); den String nicht zu einem leeren Sting reduziert. Der Grund dafür ist, dass '&nbsp;' in der Standard-Kodierung nicht dem Zeichen mit ASCII-Code 32 entspricht (dieses wird von trim() entfernt), sondern dem Zeichen mit ASCII-Code 160 (0xa0).

Siehe auch



add a note add a note User Contributed Notes
html_entity_decode
akniep at rayo dot info
13-Jul-2007 06:39
In answer to "laurynas dot butkus at gmail dot com" and "romans@void.lv" and their great code2utf-function I added the functionality for entries between [128, 160[ that are not ASCii, but equal for all major western encodings like ISO8859-X and UTF-8 that has been mentioned before.

Now, the following function should in fact convert any number (table-entry) into an UTF-8-character. Thus, the return-value  code2utf( <number> )  equals the character that is represented by the XML-entity  &#<number>;  (exceptions: #129, #141, #143, #144, #157).

To give an example, the function may be useful for creating a UTF-8-compatible html_entity_decode-function  or  determining the entry-position of UTF-8-characters in order to find the correct entity-replacement or similar.

    function code2utf($number)
    {
        if ($number < 0)
            return FALSE;
       
        if ($number < 128)
            return chr($number);
       
        // Removing / Replacing Windows Illegals Characters
        if ($number < 160)
        {
                if ($number==128) $number=8364;
            elseif ($number==129) $number=160; // (Rayo:) #129 using no relevant sign, thus, mapped to the saved-space #160
            elseif ($number==130) $number=8218;
            elseif ($number==131) $number=402;
            elseif ($number==132) $number=8222;
            elseif ($number==133) $number=8230;
            elseif ($number==134) $number=8224;
            elseif ($number==135) $number=8225;
            elseif ($number==136) $number=710;
            elseif ($number==137) $number=8240;
            elseif ($number==138) $number=352;
            elseif ($number==139) $number=8249;
            elseif ($number==140) $number=338;
            elseif ($number==141) $number=160; // (Rayo:) #129 using no relevant sign, thus, mapped to the saved-space #160
            elseif ($number==142) $number=381;
            elseif ($number==143) $number=160; // (Rayo:) #129 using no relevant sign, thus, mapped to the saved-space #160
            elseif ($number==144) $number=160; // (Rayo:) #129 using no relevant sign, thus, mapped to the saved-space #160
            elseif ($number==145) $number=8216;
            elseif ($number==146) $number=8217;
            elseif ($number==147) $number=8220;
            elseif ($number==148) $number=8221;
            elseif ($number==149) $number=8226;
            elseif ($number==150) $number=8211;
            elseif ($number==151) $number=8212;
            elseif ($number==152) $number=732;
            elseif ($number==153) $number=8482;
            elseif ($number==154) $number=353;
            elseif ($number==155) $number=8250;
            elseif ($number==156) $number=339;
            elseif ($number==157) $number=160; // (Rayo:) #129 using no relevant sign, thus, mapped to the saved-space #160
            elseif ($number==158) $number=382;
            elseif ($number==159) $number=376;
        } //if
       
        if ($number < 2048)
            return chr(($number >> 6) + 192) . chr(($number & 63) + 128);
        if ($number < 65536)
            return chr(($number >> 12) + 224) . chr((($number >> 6) & 63) + 128) . chr(($number & 63) + 128);
        if ($number < 2097152)
            return chr(($number >> 18) + 240) . chr((($number >> 12) & 63) + 128) . chr((($number >> 6) & 63) + 128) . chr(($number & 63) + 128);
       
       
        return FALSE;
    } //code2utf()
laurynas dot butkus at gmail dot com
15-May-2007 01:24
In PHP4 html_entity_decode() is not working well with UTF-8  spitting: "Warning: cannot yet handle MBCS in html_entity_decode()!".

This is working solution combining several workarounds:

<?php
function html_entity_decode_utf8($string)
{
    static $trans_tbl;
   
    // replace numeric entities
    $string = preg_replace('~&#x([0-9a-f]+);~ei', 'code2utf(hexdec("\\1"))', $string);
    $string = preg_replace('~&#([0-9]+);~e', 'code2utf(\\1)', $string);

    // replace literal entities
    if (!isset($trans_tbl))
    {
        $trans_tbl = array();
       
        foreach (get_html_translation_table(HTML_ENTITIES) as $val=>$key)
            $trans_tbl[$key] = utf8_encode($val);
    }
   
    return strtr($string, $trans_tbl);
}

// Returns the utf string corresponding to the unicode value (from php.net, courtesy - romans@void.lv)
function code2utf($num)
{
    if ($num < 128) return chr($num);
    if ($num < 2048) return chr(($num >> 6) + 192) . chr(($num & 63) + 128);
    if ($num < 65536) return chr(($num >> 12) + 224) . chr((($num >> 6) & 63) + 128) . chr(($num & 63) + 128);
    if ($num < 2097152) return chr(($num >> 18) + 240) . chr((($num >> 12) & 63) + 128) . chr((($num >> 6) & 63) + 128) . chr(($num & 63) + 128);
    return '';
}
?>
teecee[(a)]teecee[pont]hu
13-May-2007 05:29
Hi!

The main problem with the UTF-8 strings if You try to unhtmlentities them is that the get_html_translation_table() gives back a non-UTF8 conversion table. So the idea is to get the translation table and then translate the needed non-UTF8 strings to UTF8...

I have this code working, actually this code is the one sent by 'daviscabral', just with an extra foreach in it ( http://hu.php.net/manual/en/function.htmlentities.php#68479 )

And the code is:
<?
function unhtmlentitiesUtf8($string) {
    // replace numeric entities
    $string = preg_replace('~&#x([0-9a-f]+);~ei', 'chr(hexdec("\\1"))', $string);
    $string = preg_replace('~&#([0-9]+);~e', 'chr("\\1")', $string);
    // replace literal entities
    $trans_tbl = get_html_translation_table(HTML_ENTITIES);
    $trans_tbl = array_flip($trans_tbl);
    // changing translation table to UTF-8
    foreach( $trans_tbl as $key => $value ) {
        $trans_tbl[$key] = iconv( 'ISO-8859-1', 'UTF-8', $value );
    }
    return strtr($string, $trans_tbl);
}
?>

If You need this in production code, I suggest to get the $trans_tbl into a common-includable file I think it should be faster. ( Maybe the easiest way to do this is to write after the translation: die(var_export($trans_tbl, true)); and copy&paste the source of the displaying text. And don't forget to check if the browser uses UTF8 codepage! ;)
elektronaut gmx.net
10-Jan-2007 02:11
I made my own fix to allow numerical entities in utf8 in php4...

<?
    function utf8_replaceEntity($result){
        $value = (int)$result[1];
        $string = '';
       
        $len = round(pow($value,1/8));
       
        for($i=$len;$i>0;$i--){
            $part = ($value & (255>>2)) | pow(2,7);
            if ( $i == 1 ) $part |= 255<<(8-$len);
           
            $string = chr($part) . $string;
           
            $value >>= 6;
        }
       
        return $string;
    }
   
    function utf8_html_entity_decode($string){
        return preg_replace_callback(
            '/&#([0-9]+);/u',
            'utf8_replaceEntity',
            $string
        );
    }
   
    $string = '&#8217;&#8216; &#8211; &#8220; &#8221;'
        .'&#61607; &#263; &#324; &#345;'
    ;
    $string = utf8_html_entity_decode($string,null,'UTF-8');
   
    header('Content-Type: text/html; charset=UTF-8');
    echo '<li>'.$string;
?>
inco
28-Dec-2006 09:26
@ romekt:

iconv could not be implemented, so alternatively use utf8_decode and utf8_encode to solve the utf-8 / iso-8859-1 problem
jojo
04-Nov-2006 05:27
The decipherment does the character encoded by the escape function of JavaScript.
When the multi byte is used on the page, it is effective.

javascript escape('aaああaa') ..... 'aa%u3042%u3042aa'
php  jsEscape_decode('aa%u3042%u3042aa')..'aaああaa'

<?
function jsEscape_decode($jsEscaped,$outCharCode='SJIS'){
    $arrMojis = explode("%u",$jsEscaped);
    for ($i = 1;$i < count($arrMojis);$i++){
        $c = substr($arrMojis[$i],0,4);
        $cc = mb_convert_encoding(pack('H*',$c),$outCharCode,'UTF-16');
        $arrMojis[$i] = substr_replace($arrMojis[$i],$cc,0,4);
    }
    return implode('',$arrMojis);
}
?>
romekt at CUTTHISgmail dot com
01-Sep-2006 11:15
here's a simple workaround for the UTF-8 support problem

$var=iconv("UTF-8","ISO-8859-1",$var);
$var=html_entity_decode($var, ENT_QUOTES, 'ISO-8859-1');
$var=iconv("ISO-8859-1","UTF-8",$var);
derernst at gmx dot ch
01-Aug-2006 12:09
Combining the suggestions by buraks78 at gmail dot com, gaui at gaui dot is, daniel at brightbyte dot de, and the version in PEAR_PHP_Compat, I come to the following, which should work in an UTF-8 environment, with PHP < or > 4.3:

<?php
function decode_entities($text, $quote_style = ENT_COMPAT) {
    if (function_exists('html_entity_decode')) {
        $text = html_entity_decode($text, $quote_style, 'ISO-8859-1'); // NOTE: UTF-8 does not work!
    }
    else {
        $trans_tbl = get_html_translation_table(HTML_ENTITIES, $quote_style);
        $trans_tbl = array_flip($trans_tbl);
        $text = strtr($text, $trans_tbl);
    }
    $text = preg_replace('~&#x([0-9a-f]+);~ei', 'chr(hexdec("\\1"))', $text);
    $text = preg_replace('~&#([0-9]+);~e', 'chr("\\1")', $text);
    return $text;
}
?>

Note that I omitted the line
$trans_table['&#39;'] = "'";
as it would override the quote_style setting and thus lead to unexpected results for quote_styles ENT_NOQUOTES and ENT_COMPAT.
grvg (at) free (dot) fr
29-Jul-2006 06:44
Here is the ultimate functions to convert HTML entities to UTF-8 :
The main function is htmlentities2utf8
Others are helper functions

function chr_utf8($code)
    {
        if ($code < 0) return false;
        elseif ($code < 128) return chr($code);
        elseif ($code < 160) // Remove Windows Illegals Cars
        {
            if ($code==128) $code=8364;
            elseif ($code==129) $code=160; // not affected
            elseif ($code==130) $code=8218;
            elseif ($code==131) $code=402;
            elseif ($code==132) $code=8222;
            elseif ($code==133) $code=8230;
            elseif ($code==134) $code=8224;
            elseif ($code==135) $code=8225;
            elseif ($code==136) $code=710;
            elseif ($code==137) $code=8240;
            elseif ($code==138) $code=352;
            elseif ($code==139) $code=8249;
            elseif ($code==140) $code=338;
            elseif ($code==141) $code=160; // not affected
            elseif ($code==142) $code=381;
            elseif ($code==143) $code=160; // not affected
            elseif ($code==144) $code=160; // not affected
            elseif ($code==145) $code=8216;
            elseif ($code==146) $code=8217;
            elseif ($code==147) $code=8220;
            elseif ($code==148) $code=8221;
            elseif ($code==149) $code=8226;
            elseif ($code==150) $code=8211;
            elseif ($code==151) $code=8212;
            elseif ($code==152) $code=732;
            elseif ($code==153) $code=8482;
            elseif ($code==154) $code=353;
            elseif ($code==155) $code=8250;
            elseif ($code==156) $code=339;
            elseif ($code==157) $code=160; // not affected
            elseif ($code==158) $code=382;
            elseif ($code==159) $code=376;
        }
        if ($code < 2048) return chr(192 | ($code >> 6)) . chr(128 | ($code & 63));
        elseif ($code < 65536) return chr(224 | ($code >> 12)) . chr(128 | (($code >> 6) & 63)) . chr(128 | ($code & 63));
        else return chr(240 | ($code >> 18)) . chr(128 | (($code >> 12) & 63)) . chr(128 | (($code >> 6) & 63)) . chr(128 | ($code & 63));
    }

    // Callback for preg_replace_callback('~&(#(x?))?([^;]+);~', 'html_entity_replace', $str);
    function html_entity_replace($matches)
    {
        if ($matches[2])
        {
            return chr_utf8(hexdec($matches[3]));
        } elseif ($matches[1])
        {
            return chr_utf8($matches[3]);
        }
        switch ($matches[3])
        {
            case "nbsp": return chr_utf8(160);
            case "iexcl": return chr_utf8(161);
            case "cent": return chr_utf8(162);
            case "pound": return chr_utf8(163);
            case "curren": return chr_utf8(164);
            case "yen": return chr_utf8(165);
            //... etc with all named HTML entities
        }
        return false;
    }
   
    function htmlentities2utf8 ($string) // because of the html_entity_decode() bug with UTF-8
    {
        $string = preg_replace_callback('~&(#(x?))?([^;]+);~', 'html_entity_replace', $string);
        return $string;
    }
hurricane at cyberworldz dot org
23-Dec-2005 05:33
I shortened the function repace_num_entity a bit to make more understandable and clean. Maybe now someone sees the problem it possibly has... (as mentioned below)

<?php
function replace_num_entity($ord) {
    $ord = $ord[1];
    if (preg_match('/^x([0-9a-f]+)$/i', $ord, $match)) $ord = hexdec($match[1]);
        else $ord = intval($ord);
    $no_bytes = 0;
    $byte = array();
    if ($ord < 128) return chr($ord);
    if ($ord < 2048) $no_bytes = 2;
        else if ($ord < 65536) $no_bytes = 3;
        else if ($ord < 1114112) $no_bytes = 4;
        else return;
    switch($no_bytes) {
        case 2: $prefix = array(31, 192); break;
        case 3: $prefix = array(15, 224); break;
        case 4: $prefix = array(7, 240);
    }
    for ($i=0; $i < $no_bytes; ++$i)
        $byte[$no_bytes-$i-1] = (($ord & (63 * pow(2,6*$i))) / pow(2,6*$i)) & 63 | 128;
    $byte[0] = ($byte[0] & $prefix[0]) | $prefix[1];
    $ret = '';
    for ($i=0; $i < $no_bytes; ++$i) $ret .= chr($byte[$i]);
    return $ret;
}
?>
loufoque
08-Oct-2005 10:15
If you want to decode NCRs to utf-8 use this function instead of chr().

function utf8_chr($code)
{
    if($code<128) return chr($code);
    else if($code<2048) return chr(($code>>6)+192).chr(($code&63)+128);
    else if($code<65536) return chr(($code>>12)+224).chr((($code>>6)&63)+128).chr(($code&63)+128);
    else if($code<2097152) return chr($code>>18+240).chr((($code>>12)&63)+128)
                                  .chr(($code>>6)&63+128).chr($code&63+128));
}
emilianomartinezluque at yahoo dot com
26-Sep-2005 02:22
I've been using the great replace_num_entity function posted below. But there seems to be some problems with the 128 to 160 characters range. Ie, try:

<?php header("Content-type: text/html; charset=utf-8"); ?>
<html><body>
<?php
for($x=128; $x<161; $x++) {
      echo('&#' . $x . '; -- ' . preg_replace_callback('/&#([0-9a-fx]+);/mi', 'replace_num_entity', '&#' . $x . ';') . '</br>');
}
?>
</body></html>

I really dont know the reason for this (since according to UTF-8 specs the function should have worked) but I did a modified version of the function to address this. Hope it helps.

function replace_num_entity($ord)
   {
       $ord = $ord[1];
       if (preg_match('/^x([0-9a-f]+)$/i', $ord, $match))
       {
           $ord = hexdec($match[1]);
       }
       else
       {
           $ord = intval($ord);
       }
     
       $no_bytes = 0;
       $byte = array();

        if($ord == 128) {
            return chr(226).chr(130).chr(172);
        } elseif($ord == 129) {
            return chr(239).chr(191).chr(189);
        } elseif($ord == 130) {
            return chr(226).chr(128).chr(154);
        } elseif($ord == 131) {
            return chr(198).chr(146);
        } elseif($ord == 132) {
            return chr(226).chr(128).chr(158);
        } elseif($ord == 133) {
            return chr(226).chr(128).chr(166);
        } elseif($ord == 134) {
            return chr(226).chr(128).chr(160);
        } elseif($ord == 135) {
            return chr(226).chr(128).chr(161);
        } elseif($ord == 136) {
            return chr(203).chr(134);
        } elseif($ord == 137) {
            return chr(226).chr(128).chr(176);
        } elseif($ord == 138) {
            return chr(197).chr(160);
        } elseif($ord == 139) {
            return chr(226).chr(128).chr(185);
        } elseif($ord == 140) {
            return chr(197).chr(146);
        } elseif($ord == 141) {
            return chr(239).chr(191).chr(189);
        } elseif($ord == 142) {
            return chr(197).chr(189);
        } elseif($ord == 143) {
            return chr(239).chr(191).chr(189);
        } elseif($ord == 144) {
            return chr(239).chr(191).chr(189);
        } elseif($ord == 145) {
            return chr(226).chr(128).chr(152);
        } elseif($ord == 146) {
            return chr(226).chr(128).chr(153);
        } elseif($ord == 147) {
            return chr(226).chr(128).chr(156);
        } elseif($ord == 148) {
            return chr(226).chr(128).chr(157);
        } elseif($ord == 149) {
            return chr(226).chr(128).chr(162);
        } elseif($ord == 150) {
            return chr(226).chr(128).chr(147);
        } elseif($ord == 151) {
            return chr(226).chr(128).chr(148);
        } elseif($ord == 152) {
            return chr(203).chr(156);
        } elseif($ord == 153) {
            return chr(226).chr(132).chr(162);
        } elseif($ord == 154) {
            return chr(197).chr(161);
        } elseif($ord == 155) {
            return chr(226).chr(128).chr(186);
        } elseif($ord == 156) {
            return chr(197).chr(147);
        } elseif($ord == 157) {
            return chr(239).chr(191).chr(189);
        } elseif($ord == 158) {
            return chr(197).chr(190);
        } elseif($ord == 159) {
            return chr(197).chr(184);
        } elseif($ord == 160) {
            return chr(194).chr(160);
        }

       if ($ord < 128)
       {
           return chr($ord);
       }
       elseif ($ord < 2048)
       {
           $no_bytes = 2;
       }
       elseif ($ord < 65536)
       {
           $no_bytes = 3;
       }
       elseif ($ord < 1114112)
       {
           $no_bytes = 4;
       }
       else
       {
           return;
       }

       switch($no_bytes)
       {
           case 2:
           {
               $prefix = array(31, 192);
               break;
           }
           case 3:
           {
               $prefix = array(15, 224);
               break;
           }
           case 4:
           {
               $prefix = array(7, 240);
           }
       }

       for ($i = 0; $i < $no_bytes; $i++)
       {
           $byte[$no_bytes - $i - 1] = (($ord & (63 * pow(2, 6 * $i))) / pow(2, 6 * $i)) & 63 | 128;
       }

       $byte[0] = ($byte[0] & $prefix[0]) | $prefix[1];

       $ret = '';
       for ($i = 0; $i < $no_bytes; $i++)
       {
           $ret .= chr($byte[$i]);
       }

       return $ret;
   }
florianborn (at) yahoo (dot) de
20-Jul-2005 12:43
Note that

<?php

 echo urlencode(html_entity_decode("&nbsp;"));

?>

will output "%A0" instead of "+".
gaui at gaui dot is
05-Jul-2005 02:15
if( !function_exists( 'html_entity_decode' ) )
{
    function html_entity_decode( $given_html, $quote_style = ENT_QUOTES ) {
        $trans_table = array_flip(get_html_translation_table( HTML_SPECIALCHARS, $quote_style ));
        $trans_table['&#39;'] = "'";
        return ( strtr( $given_html, $trans_table ) );
       }
}
marius (at) hot (dot) ee
08-Apr-2005 03:40
To convert html entities into unicode characters, use the following:

        $trans_tbl = get_html_translation_table(HTML_ENTITIES);
        foreach($trans_tbl as $k => $v)
        {
            $ttr[$v] = utf8_encode($k);
        }
   
        $text = strtr($text, $ttr);
php dot net at c dash ovidiu dot tk
18-Mar-2005 09:37
Quick & dirty code that translates numeric entities to UTF-8.

<?php

    function replace_num_entity($ord)
    {
        $ord = $ord[1];
        if (preg_match('/^x([0-9a-f]+)$/i', $ord, $match))
        {
            $ord = hexdec($match[1]);
        }
        else
        {
            $ord = intval($ord);
        }
       
        $no_bytes = 0;
        $byte = array();

        if ($ord < 128)
        {
            return chr($ord);
        }
        elseif ($ord < 2048)
        {
            $no_bytes = 2;
        }
        elseif ($ord < 65536)
        {
            $no_bytes = 3;
        }
        elseif ($ord < 1114112)
        {
            $no_bytes = 4;
        }
        else
        {
            return;
        }

        switch($no_bytes)
        {
            case 2:
            {
                $prefix = array(31, 192);
                break;
            }
            case 3:
            {
                $prefix = array(15, 224);
                break;
            }
            case 4:
            {
                $prefix = array(7, 240);
            }
        }

        for ($i = 0; $i < $no_bytes; $i++)
        {
            $byte[$no_bytes - $i - 1] = (($ord & (63 * pow(2, 6 * $i))) / pow(2, 6 * $i)) & 63 | 128;
        }

        $byte[0] = ($byte[0] & $prefix[0]) | $prefix[1];

        $ret = '';
        for ($i = 0; $i < $no_bytes; $i++)
        {
            $ret .= chr($byte[$i]);
        }

        return $ret;
    }

    $test = 'This is a &#269;&#x5d0; test&#39;';

    echo $test . "<br />\n";
    echo preg_replace_callback('/&#([0-9a-fx]+);/mi', 'replace_num_entity', $test);

?>
Silvan
29-Jan-2005 04:33
Passing NULL or FALSE as a string will generate a '500 Internal Server Error' (or break the script when inside a function).

So always test your string first before passing it to html_entity_decode().
daniel at brightbyte dot de
14-Nov-2004 03:12
This function seems to have to have two limitations (at least in PHP 4.3.8):

a) it does not work with multibyte character codings, such as UTF-8
b) it does not decode numeric entity references

a) can be solved by using iconv to convert to ISO-8859-1, then decoding the entities, than convert to UTF-8 again. But that's quite ugly and detroys all characters not present in Latin-1.

b) can be solved rather nicely using the following code:

<?php
function decode_entities($text) {
    $text= html_entity_decode($text,ENT_QUOTES,"ISO-8859-1"); #NOTE: UTF-8 does not work!
    $text= preg_replace('/&#(\d+);/me',"chr(\\1)",$text); #decimal notation
    $text= preg_replace('/&#x([a-f0-9]+);/mei',"chr(0x\\1)",$text);  #hex notation
    return $text;
}
?>

HTH
aidan at php dot net
14-Sep-2004 09:57
This functionality is now implemented in the PEAR package PHP_Compat.

More information about using this function without upgrading your version of PHP can be found on the below link:

http://pear.php.net/package/PHP_Compat
add a note add a note

htmlentities> <hex2bin
Last updated: Fri, 18 May 2012