Detecta la codificación y crea todo UTF-8

Estoy leyendo muchos textos de varios canales RSS y los inserto en mi base de datos.

Por supuesto, hay varias codificaciones de caracteres diferentes utilizadas en las fuentes, por ejemplo, UTF-8 e ISO 8859-1.

Desafortunadamente, a veces hay problemas con las codificaciones de los textos. Ejemplo:

1. El "ß" en "Fußball" debería verse así en mi base de datos: "Ÿ". Si es un "Ÿ", se muestra correctamente.

2. A veces, el "ß" en "Fußball" se ve así en mi base de datos: "ß". Entonces se muestra incorrectamente, por supuesto.

3. En otros casos, el "ß" se guarda como un "ß", es decir, sin ningún cambio. Entonces también se muestra incorrectamente.

¿Qué puedo hacer para evitar los casos 2 y 3?

¿Cómo puedo hacer que todo tenga la misma codificación, preferiblemente UTF-8? ¿Cuándo debo usar utf8_encode(), cuándo debo usar utf8_decode()(está claro cuál es el efecto pero cuándo debo usar las funciones?) Y cuándo no debo hacer nada con la entrada?

¿Cómo hago que todo tenga la misma codificación? Quizás con la función mb_detect_encoding()? ¿Puedo escribir una función para esto? Entonces mis problemas son:

1. ¿Cómo puedo saber qué codificación utiliza el texto?
2. ¿Cómo lo convierto a UTF-8, sea cual sea la codificación anterior?

¿Funcionaría una función como esta?

function correct_encoding($text) {
    $current_encoding = mb_detect_encoding($text, 'auto');
    $text = iconv($current_encoding, 'UTF-8', $text);
    return $text;
}

Lo he probado, pero no funciona. ¿Qué tiene de malo?

Si aplica utf8_encode()a una cadena ya UTF-8, devolverá una salida UTF-8 ilegible.

Hice una función que aborda todos estos problemas. Se llama Encoding::toUTF8().

No necesita saber cuál es la codificación de sus cadenas. Puede ser Latin1 ( ISO 8859-1) , Windows-1252 o UTF-8, o la cadena puede tener una combinación de ellos. Encoding::toUTF8()convertirá todo a UTF-8.

Lo hice porque un servicio me estaba dando una fuente de datos desordenados, mezclando UTF-8 y Latin1 en la misma cadena.

Uso:

require_once('Encoding.php');
use \ForceUTF8\Encoding;  // It's namespaced now.

$utf8_string = Encoding::toUTF8($utf8_or_latin1_or_mixed_string);

$latin1_string = Encoding::toLatin1($utf8_or_latin1_or_mixed_string);

Descargar:

https://github.com/neitanod/forceutf8

He incluido otra función, Encoding::fixUFT8()que arreglará cada cadena UTF-8 que se vea confusa.

Uso:

require_once('Encoding.php');
use \ForceUTF8\Encoding;  // It's namespaced now.

$utf8_string = Encoding::fixUTF8($garbled_utf8_string);

Ejemplos:

echo Encoding::fixUTF8("Fédération Camerounaise de Football");
echo Encoding::fixUTF8("Fédération Camerounaise de Football");
echo Encoding::fixUTF8("FÃÂédÃÂération Camerounaise de Football");
echo Encoding::fixUTF8("Fédération Camerounaise de Football");

dará salida:

Fédération Camerounaise de Football
Fédération Camerounaise de Football
Fédération Camerounaise de Football
Fédération Camerounaise de Football

He transformado la función ( forceUTF8) en una familia de funciones estáticas en una clase llamada Encoding. La nueva función es Encoding::toUTF8().

Primero debe detectar qué codificación se ha utilizado. Mientras analiza las fuentes RSS (probablemente a través de HTTP), debe leer la codificación del charsetparámetro del Content-Typecampo de encabezado HTTP . Si no está presente, lea la codificación del encodingatributo de la instrucción de procesamiento XML . Si eso también falta, use UTF-8 como se define en la especificación .

Editar    Aquí es lo que probablemente haría:

Me gustaría usar cURL para enviar a buscar la respuesta. Eso le permite establecer campos de encabezado específicos y buscar el encabezado de respuesta también. Después de buscar la respuesta, debe analizar la respuesta HTTP y dividirla en encabezado y cuerpo. El encabezado debe contener el Content-Typecampo de encabezado que contiene el tipo MIME y (con suerte) el charsetparámetro con la codificación / juego de caracteres también. De lo contrario, analizaremos la PI de XML para determinar la presencia del encodingatributo y obtendremos la codificación a partir de ahí. Si eso también falta, las especificaciones XML definen el uso de UTF-8 como codificación.

$url = 'http://www.lr-online.de/storage/rss/rss/sport.xml';

$accept = array(
    'type' => array('application/rss+xml', 'application/xml', 'application/rdf+xml', 'text/xml'),
    'charset' => array_diff(mb_list_encodings(), array('pass', 'auto', 'wchar', 'byte2be', 'byte2le', 'byte4be', 'byte4le', 'BASE64', 'UUENCODE', 'HTML-ENTITIES', 'Quoted-Printable', '7bit', '8bit'))
);
$header = array(
    'Accept: '.implode(', ', $accept['type']),
    'Accept-Charset: '.implode(', ', $accept['charset']),
);
$encoding = null;
$curl = curl_init($url);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_HEADER, true);
curl_setopt($curl, CURLOPT_HTTPHEADER, $header);
$response = curl_exec($curl);
if (!$response) {
    // error fetching the response
} else {
    $offset = strpos($response, "\r\n\r\n");
    $header = substr($response, 0, $offset);
    if (!$header || !preg_match('/^Content-Type:\s+([^;]+)(?:;\s*charset=(.*))?/im', $header, $match)) {
        // error parsing the response
    } else {
        if (!in_array(strtolower($match[1]), array_map('strtolower', $accept['type']))) {
            // type not accepted
        }
        $encoding = trim($match[2], '"\'');
    }
    if (!$encoding) {
        $body = substr($response, $offset + 4);
        if (preg_match('/^<\?xml\s+version=(?:"[^"]*"|\'[^\']*\')\s+encoding=("[^"]*"|\'[^\']*\')/s', $body, $match)) {
            $encoding = trim($match[1], '"\'');
        }
    }
    if (!$encoding) {
        $encoding = 'utf-8';
    } else {
        if (!in_array($encoding, array_map('strtolower', $accept['charset']))) {
            // encoding not accepted
        }
        if ($encoding != 'utf-8') {
            $body = mb_convert_encoding($body, 'utf-8', $encoding);
        }
    }
    $simpleXML = simplexml_load_string($body, null, LIBXML_NOERROR);
    if (!$simpleXML) {
        // parse error
    } else {
        echo $simpleXML->asXML();
    }
}

Detectar la codificación es difícil.

mb_detect_encodingfunciona adivinando, en función de una serie de candidatos que lo aprueba. En algunas codificaciones, ciertas secuencias de bytes no son válidas, por lo que puede distinguir entre varios candidatos. Desafortunadamente, hay muchas codificaciones, donde los mismos bytes son válidos (pero diferentes). En estos casos, no hay forma de determinar la codificación; Puede implementar su propia lógica para hacer conjeturas en estos casos. Por ejemplo, los datos que provienen de un sitio japonés podrían tener más probabilidades de tener una codificación japonesa.

Mientras solo trate con idiomas de Europa occidental, las tres codificaciones principales a considerar son utf-8, iso-8859-1y cp-1252. Dado que estos son valores predeterminados para muchas plataformas, también es más probable que se denuncien erróneamente. P.ej. Si las personas usan diferentes codificaciones, es probable que sean francos al respecto, ya que de lo contrario su software se rompería muy a menudo. Por lo tanto, una buena estrategia es confiar en el proveedor, a menos que la codificación se informe como uno de esos tres. Aún debe verificar que sea válido, usando mb_check_encoding(tenga en cuenta que válido no es lo mismo que ser , la misma entrada puede ser válida para muchas codificaciones). Si es uno de esos, puede usarmb_detect_encodingpara distinguir entre ellos Afortunadamente eso es bastante determinista; Solo necesita usar la secuencia de detección adecuada, que es UTF-8,ISO-8859-1,WINDOWS-1252.

Una vez que haya detectado la codificación, debe convertirla a su representación interna ( UTF-8es la única opción sensata). La función se utf8_encodetransforma ISO-8859-1en UTF-8, por lo que solo se puede usar para ese tipo de entrada en particular. Para otras codificaciones, use mb_convert_encoding.

Una forma realmente agradable de implementar una isUTF8función se puede encontrar en php.net :

function isUTF8($string) {
    return (utf8_encode(utf8_decode($string)) == $string);
}

Esta hoja de referencia enumera algunas advertencias comunes relacionadas con el manejo de UTF-8 en PHP: http://developer.loftdigital.com/blog/php-utf-8-cheatsheet

Esta función de detección de caracteres multibyte en una cadena también podría ser útil ( fuente ):

function detectUTF8($string)
{
    return preg_match('%(?:
        [\xC2-\xDF][\x80-\xBF]             # non-overlong 2-byte
        |\xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
        |[\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
        |\xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
        |\xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
        |[\xF1-\xF3][\x80-\xBF]{3}         # planes 4-15
        |\xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
        )+%xs', 
    $string);
}

Un poco de cabeza. Usted dijo que el "ß" debería mostrarse como "Ÿ" en su base de datos.

Esto probablemente se deba a que está utilizando una base de datos con codificación de caracteres Latin-1 o posiblemente su conexión PHP-MySQL está configurada incorrectamente, esto es, P cree que su MySQL está configurado para usar UTF-8, por lo que envía datos como UTF-8 , pero su MySQL cree que PHP está enviando datos codificados como ISO 8859-1, por lo que una vez más puede intentar codificar sus datos enviados como UTF-8, causando este tipo de problemas.

Echa un vistazo a mysql_set_charset . Te puede ayudar.

Su codificación parece codificada en UTF-8 dos veces ; es decir, desde alguna otra codificación, a UTF-8 y nuevamente a UTF-8. Como si tuviera ISO 8859-1, convertido de ISO 8859-1 a UTF-8, y tratado la nueva cadena como ISO 8859-1 para otra conversión a UTF-8.

Aquí hay un pseudocódigo de lo que hiciste:

$inputstring = getFromUser();
$utf8string = iconv($current_encoding, 'utf-8', $inputstring);
$flawedstring = iconv($current_encoding, 'utf-8', $utf8string);

Deberías intentarlo:

1. detecta la codificación usando mb_detect_encoding()o lo que quieras usar
2. si es UTF-8, conviértalo a ISO 8859-1 y repita el paso 1
3. finalmente, vuelva a convertirlo en UTF-8

Eso supone que en la conversión "intermedia" usó ISO 8859-1. Si usó Windows-1252, conviértalo a Windows-1252 (latin1). La codificación fuente original no es importante; la que usaste en la segunda conversión defectuosa es.

Esta es mi suposición sobre lo que sucedió; Hay muy poco más que podría haber hecho para obtener cuatro bytes en lugar de un byte ASCII extendido.

El idioma alemán también utiliza ISO 8859-2 y Windows-1250 (Latin-2).

Lo interesante de mb_detect_encodingy mb_convert_encodinges que el orden de las codificaciones que sugieres sí importa:

// $input is actually UTF-8

mb_detect_encoding($input, "UTF-8", "ISO-8859-9, UTF-8");
// ISO-8859-9 (WRONG!)

mb_detect_encoding($input, "UTF-8", "UTF-8, ISO-8859-9");
// UTF-8 (OK)

Por lo tanto, es posible que desee utilizar un orden específico al especificar las codificaciones esperadas. Aún así, tenga en cuenta que esto no es infalible.

Debe probar el conjunto de caracteres en la entrada ya que las respuestas pueden codificarse con diferentes codificaciones.

Obligo a que todo el contenido se envíe a UTF-8 mediante detección y traducción mediante la siguiente función:

function fixRequestCharset()
{
  $ref = array(&$_GET, &$_POST, &$_REQUEST);
  foreach ($ref as &$var)
  {
    foreach ($var as $key => $val)
    {
      $encoding = mb_detect_encoding($var[$key], mb_detect_order(), true);
      if (!$encoding)
        continue;
      if (strcasecmp($encoding, 'UTF-8') != 0)
      {
        $encoding = iconv($encoding, 'UTF-8', $var[$key]);
        if ($encoding === false)
          continue;
        $var[$key] = $encoding;
      }
    }
  }
}

Esa rutina convertirá todas las variables PHP que provienen del host remoto en UTF-8.

O ignore el valor si la codificación no se pudo detectar o convertir.

Puede personalizarlo según sus necesidades.

Solo invocalo antes de usar las variables.

Resolver la codificación de caracteres de los canales RSS parece ser complicado . Incluso las páginas web normales a menudo omiten o mienten acerca de su codificación.

Por lo tanto, podría intentar usar la forma correcta de detectar la codificación y luego recurrir a alguna forma de autodetección (adivinar).

Sé que esta es una pregunta anterior, pero creo que una respuesta útil nunca está de más. Estaba teniendo problemas con mi codificación entre una aplicación de escritorio, SQLite y las variables GET / POST. Algunos estarían en UTF-8, otros estarían en ASCII, y básicamente todo se arruinaría cuando se involucraran caracteres extranjeros.

Aquí está mi solución. Elimina su OBTENER / POSTAR / SOLICITAR (omití las cookies, pero podría agregarlas si lo desea) en cada carga de la página antes del procesamiento. Funciona bien en un encabezado. PHP lanzará advertencias si no puede detectar la codificación de origen automáticamente, por lo que estas advertencias se suprimen con @ 's.

//Convert everything in our vars to UTF-8 for playing nice with the database...
//Use some auto detection here to help us not double-encode...
//Suppress possible warnings with @'s for when encoding cannot be detected
try
{
    $process = array(&$_GET, &$_POST, &$_REQUEST);
    while (list($key, $val) = each($process)) {
        foreach ($val as $k => $v) {
            unset($process[$key][$k]);
            if (is_array($v)) {
                $process[$key][@mb_convert_encoding($k,'UTF-8','auto')] = $v;
                $process[] = &$process[$key][@mb_convert_encoding($k,'UTF-8','auto')];
            } else {
                $process[$key][@mb_convert_encoding($k,'UTF-8','auto')] = @mb_convert_encoding($v,'UTF-8','auto');
            }
        }
    }
    unset($process);
}
catch(Exception $ex){}

Estuve buscando soluciones para la codificación desde hace siglos , ¡y esta página es probablemente la conclusión de años de búsqueda! Probé algunas de las sugerencias que mencionaste y aquí están mis notas:

Esta es mi cadena de prueba:

¡Esta es una cadena de "escritura escrita", pero necesité más "especiales" para verlos, convertidos por conexión! & ¡Eso es!

Hago un INSERT para guardar esta cadena en una base de datos en un campo que está configurado como utf8_general_ci

El conjunto de caracteres de mi página es UTF-8.

Si hago un INSERTAR así, en mi base de datos, probablemente tenga algunos personajes procedentes de Marte ...

Entonces necesito convertirlos en algún UTF-8 "sano". Lo intenté utf8_encode(), pero aún los personajes extraterrestres estaban invadiendo mi base de datos ...

Así que intenté usar la función forceUTF8publicada en el número 8, pero en la base de datos la cadena guardada se ve así:

esta es una cadena de "escritura escrita", pero no tuve que llamar a alguien especial para verlos, ¡convertidos por fécton! & ¡Eso es!

Entonces, al recopilar más información en esta página y fusionarla con otra información en otras páginas, resolví mi problema con esta solución:

$finallyIDidIt = mb_convert_encoding(
  $string,
  mysql_client_encoding($resourceID),
  mb_detect_encoding($string)
);

Ahora en mi base de datos tengo mi cadena con la codificación correcta.

NOTA: ¡ Solo la nota para cuidar está en funcionamiento mysql_client_encoding! Debe estar conectado a la base de datos, porque esta función quiere un ID de recurso como parámetro.

Pero bueno, acabo de volver a codificar antes de mi INSERT, así que para mí no es un problema.

Es muy sencillo: cuando se consigue algo que no es UTF-8, debe codificar que en UTF-8.

Por lo tanto, cuando va a buscar una determinada fuente que es ISO 8859-1, analícela utf8_encode.

Sin embargo, si va a buscar una fuente UTF-8, no necesita hacer nada.

php.net/mb_detect_encoding

echo mb_detect_encoding($str, "auto");

o

echo mb_detect_encoding($str, "UTF-8, ASCII, ISO-8859-1");

Realmente no sé cuáles son los resultados, pero te sugiero que solo tomes algunos de tus feeds con diferentes codificaciones y pruebes si mb_detect_encodingfunciona o no.

la actualización
automática es la abreviatura de "ASCII, JIS, UTF-8, EUC-JP, SJIS". devuelve el juego de caracteres detectado, que puede usar para convertir la cadena a utf-8 con iconv .

<?php
function convertToUTF8($str) {
    $enc = mb_detect_encoding($str);

    if ($enc && $enc != 'UTF-8') {
        return iconv($enc, 'UTF-8', $str);
    } else {
        return $str;
    }
}
?>

No lo he probado, así que no hay garantía. y tal vez hay una manera más simple.

@harpax que funcionó para mí. En mi caso, esto es lo suficientemente bueno:

if (isUTF8($str)) { 
    echo $str; 
}
else
{
    echo iconv("ISO-8859-1", "UTF-8//TRANSLIT", $str);
}

Después de ordenar sus scripts php, no olvide decirle a mysql qué conjunto de caracteres está pasando y le gustaría recibir.

Ejemplo: establecer el conjunto de caracteres utf8

Pasar datos utf8 a una tabla latin1 en una sesión de E / S latin1 da esos desagradables birdfeets. Lo veo cada dos días en las tiendas de comercio electrónico. Atrás y cuarto puede parecer correcto. Pero phpmyadmin mostrará la verdad. Al decirle a mysql qué conjunto de caracteres está pasando, manejará la conversión de datos de mysql por usted.

Cómo recuperar los datos mysql revueltos existentes es otro hilo a tratar. :)

Esta versión es para el idioma alemán, pero puede modificar los $ CHARSETS y los $ TESTCHARS

class CharsetDetector
{
private static $CHARSETS = array(
"ISO_8859-1",
"ISO_8859-15",
"CP850"
);
private static $TESTCHARS = array(
"€",
"ä",
"Ä",
"ö",
"Ö",
"ü",
"Ü",
"ß"
);
public static function convert($string)
{
    return self::__iconv($string, self::getCharset($string));
}
public static function getCharset($string)
{
    $normalized = self::__normalize($string);
    if(!strlen($normalized))return "UTF-8";
    $best = "UTF-8";
    $charcountbest = 0;
    foreach (self::$CHARSETS as $charset) {
        $str = self::__iconv($normalized, $charset);
        $charcount = 0;
        $stop   = mb_strlen( $str, "UTF-8");

        for( $idx = 0; $idx < $stop; $idx++)
        {
            $char = mb_substr( $str, $idx, 1, "UTF-8");
            foreach (self::$TESTCHARS as $testchar) {

                if($char == $testchar)
                {

                    $charcount++;
                    break;
                }
            }
        }
        if($charcount>$charcountbest)
        {
            $charcountbest=$charcount;
            $best=$charset;
        }
        //echo $text."<br />";
    }
    return $best;
}
private static function __normalize($str)
{

$len = strlen($str);
$ret = "";
for($i = 0; $i < $len; $i++){
    $c = ord($str[$i]);
    if ($c > 128) {
        if (($c > 247)) $ret .=$str[$i];
        elseif ($c > 239) $bytes = 4;
        elseif ($c > 223) $bytes = 3;
        elseif ($c > 191) $bytes = 2;
        else $ret .=$str[$i];
        if (($i + $bytes) > $len) $ret .=$str[$i];
        $ret2=$str[$i];
        while ($bytes > 1) {
            $i++;
            $b = ord($str[$i]);
            if ($b < 128 || $b > 191) {$ret .=$ret2; $ret2=""; $i+=$bytes-1;$bytes=1; break;}
            else $ret2.=$str[$i];
            $bytes--;
        }
    }
}
return $ret; 
}
private static function __iconv($string, $charset)
{
    return iconv ( $charset, "UTF-8" , $string );
}
}

Obtenga codificación de encabezados y conviértalo a utf-8.

$post_url='http://website.domain';

/// Get headers ////////////////////////////////////////////////////////////
function get_headers_curl($url) 
{ 
    $ch = curl_init(); 

    curl_setopt($ch, CURLOPT_URL,            $url); 
    curl_setopt($ch, CURLOPT_HEADER,         true); 
    curl_setopt($ch, CURLOPT_NOBODY,         true); 
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); 
    curl_setopt($ch, CURLOPT_TIMEOUT,        15); 

    $r = curl_exec($ch); 
    return $r; 
}
$the_header = get_headers_curl($post_url);
/// check for redirect /////////////////////////////////////////////////
if (preg_match("/Location:/i", $the_header)) {
    $arr = explode('Location:', $the_header);
    $location = $arr[1];

    $location=explode(chr(10), $location);
    $location = $location[0];

$the_header = get_headers_curl(trim($location));
}
/// Get charset /////////////////////////////////////////////////////////////////////
if (preg_match("/charset=/i", $the_header)) {
    $arr = explode('charset=', $the_header);
    $charset = $arr[1];

    $charset=explode(chr(10), $charset);
    $charset = $charset[0];
    }
///////////////////////////////////////////////////////////////////////////////
// echo $charset;

if($charset && $charset!='UTF-8') { $html = iconv($charset, "UTF-8", $html); }

Ÿes Mojibake para ß. En su base de datos, puede tener hexadecimal

DF if the column is "latin1",
C39F if the column is utf8 -- OR -- it is latin1, but "double-encoded"
C383C5B8 if double-encoded into a utf8 column

Usted debe no utilizar cualquier codificación / decodificación de funciones en PHP; en su lugar, debe configurar la base de datos y la conexión a ella correctamente.

Si MySQL está involucrado, vea: Problemas con los caracteres utf8; lo que veo no es lo que almacené

Encuentro la solución aquí http://deer.org.ua/2009/10/06/1/

class Encoding
{
    /**
     * http://deer.org.ua/2009/10/06/1/
     * @param $string
     * @return null
     */
    public static function detect_encoding($string)
    {
        static $list = ['utf-8', 'windows-1251'];

        foreach ($list as $item) {
            try {
                $sample = iconv($item, $item, $string);
            } catch (\Exception $e) {
                continue;
            }
            if (md5($sample) == md5($string)) {
                return $item;
            }
        }
        return null;
    }
}

$content = file_get_contents($file['tmp_name']);
$encoding = Encoding::detect_encoding($content);
if ($encoding != 'utf-8') {
    $result = iconv($encoding, 'utf-8', $content);
} else {
    $result = $content;
}

Creo que @ es una mala decisión y hago algunos cambios a la solución desde deer.org.ua;

La respuesta más votada no funciona. Aquí está el mío y espero que ayude.

function toUTF8($raw) {
    try{
        return mb_convert_encoding($raw, "UTF-8", "auto"); 
    }catch(\Exception $e){
        return mb_convert_encoding($raw, "UTF-8", "GBK"); 
    }
}

Cuando intentas manejar varios idiomas como el japonés y el coreano, puedes meterte en problemas. mb_convert_encoding con el parámetro 'auto' no funciona bien. Establecer mb_detect_order ('ASCII, UTF-8, JIS, EUC-JP, SJIS, EUC-KR, UHC') no ayuda, ya que detectará EUC- * incorrectamente.

Llegué a la conclusión de que siempre que las cadenas de entrada provengan de HTML, debe usar 'charset' en un meta elemento. Uso Simple HTML DOM Parser porque admite HTML no válido.

El fragmento a continuación extrae el elemento del título de una página web. Si desea convertir toda la página, puede que desee eliminar algunas líneas.

<?php
require_once 'simple_html_dom.php';

echo convert_title_to_utf8(file_get_contents($argv[1])), PHP_EOL;

function convert_title_to_utf8($contents)
{
    $dom = str_get_html($contents);
    $title = $dom->find('title', 0);
    if (empty($title)) {
        return null;
    }
    $title = $title->plaintext;
    $metas = $dom->find('meta');
    $charset = 'auto';
    foreach ($metas as $meta) {
        if (!empty($meta->charset)) { // html5
            $charset = $meta->charset;
        } else if (preg_match('@charset=(.+)@', $meta->content, $match)) {
            $charset = $match[1];
        }
    }
    if (!in_array(strtolower($charset), array_map('strtolower', mb_list_encodings()))) {
        $charset = 'auto';
    }
    return mb_convert_encoding($title, 'UTF-8', $charset);
}

Tuve el mismo problema con phpQuery ( ISO-8859-1 en lugar de UTF-8 ) y este truco me ayudó:

$html = '<?xml version="1.0" encoding="UTF-8" ?>' . $html;

mb_internal_encoding('UTF-8'), phpQuery::newDocumentHTML($html, 'utf-8'), mbstring.internal_encodingY otras manipulaciones no tuvieron ningún efecto.

Probar sin 'auto'

Es decir:

mb_detect_encoding($text)

en vez de:

mb_detect_encoding($text, 'auto')

Puede encontrar más información aquí: mb_detect_encoding