php - utf8 - Detecta codificacion y hace todo UTF-8.
ufeff php remove (24)
@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);
}
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:
El "ß" en "Fútbol" debería verse así en mi base de datos: "Ÿ". Si es un "Ÿ", se muestra correctamente.
A veces, el "ß" en "Fútbol" se ve así en mi base de datos: "ß". Entonces se muestra erróneamente, por supuesto.
En otros casos, el "ß" se guarda como un "ß", así que sin ningún cambio. Entonces también se muestra erróneamente.
¿Qué puedo hacer para evitar los casos 2 y 3?
¿Cómo puedo hacer que todo sea de 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 debo hacer nada con la entrada?
¿Puedes ayudarme y decirme cómo hacer que todo sea la misma codificación? Tal vez con la función mb_detect_encoding() ? ¿Puedo escribir una función para esto? Así que mis problemas son:
- ¿Cómo saber qué codificación utiliza el texto?
- ¿Cómo convertirlo a UTF-8, cualquiera que 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?
Cuando intentas manejar varios idiomas como el japonés y el coreano, puedes tener problemas. mb_convert_encoding con el parámetro ''auto'' no funciona bien. La configuración de 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 mientras las cadenas de entrada provienen de HTML, debería usar ''charset'' en un elemento meta. Utilizo Simple HTML DOM Parser porque soporta HTML no válido.
El siguiente fragmento de código extrae el elemento de título de una página web. Si desea convertir toda la página, es posible 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);
}
Después de ordenar sus scripts php, no olvide decirle a mysql qué conjunto de caracteres está pasando y le gustaría recibir.
Ejemplo: conjunto de caracteres conjunto utf8
Al pasar los datos de utf8 a una tabla latin1 en una sesión de E / S latin1, se obtienen esos feos de aves desagradables. Veo esto cada dos días en las tiendas de oscommerce. Atrás y cuarto podría parecer correcto. Pero phpmyadmin mostrará la verdad. Al decirle a mysql qué conjunto de caracteres está pasando, manejará la conversión de los datos mysql por usted.
Cómo recuperar los datos de MySQL codificados existentes es otro hilo para discutir. :)
Detectar la codificación es difícil.
mb_detect_encoding funciona por medio de adivinanzas, basándose en una cantidad de candidatos a los que se le pasa. 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; Puedes implementar tu propia lógica para hacer conjeturas en estos casos. Por ejemplo, es más probable que los datos provenientes de un sitio japonés tengan una codificación japonesa.
Siempre y cuando solo se trate con idiomas de Europa Occidental, las tres codificaciones principales a considerar son utf-8 , iso-8859-1 y cp-1252 . Dado que estos son valores predeterminados para muchas plataformas, también son los que tienen más probabilidades de ser reportados erróneamente. P.ej. Si la gente usa 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 hacer una doble comprobación de que es 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, puedes usar mb_detect_encoding para distinguirlos. Por suerte 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-8 es la única opción sensata). La función utf8_encode transforma ISO-8859-1 a UTF-8 , por lo que solo se puede utilizar para ese tipo de entrada en particular. Para otras codificaciones, use mb_convert_encoding .
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 en la solución de deer.org.ua;
Es simple: cuando obtienes algo que no es UTF8, debes codificar eso EN utf8.
Por lo tanto, cuando está obteniendo un determinado feed, es ISO-8859-1 analizarlo a través de utf8_encode.
Sin embargo, si está obteniendo un feed UTF8, no necesita hacer nada.
Esta hoja de referencia enumera algunas advertencias comunes relacionadas con el manejo de UTF-8 en PHP:
Esta función que detecta caracteres multibyte en una cadena también puede resultar útil ( source ):
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);
}
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 );
}
}
Estaba buscando soluciones para la codificación desde AGES, ¡y esta página es probablemente la conclusión de años de búsqueda! He probado algunas de las sugerencias que mencionaste y aquí están mis notas:
Esta es mi cadena de prueba:
esta es una cuerda "grabada", ya que me he dirigido a p''''sòme ''chàrs especiales para verlos, convertidos por fùnction !! & ¡Eso es!
Hago un INSERT para guardar esta cadena en una base de datos en un campo que se establece como utf8_general_ci
Conjunto de caracteres de mi página es UTF-8
Si hago un INSERTO así, en mi base de datos tengo algunos caracteres que probablemente vienen de Marte ... así que necesito convertirlos en un UTF-8 "sano". Intenté utf8_encode() pero aún así los caracteres extranjeros estaban invadiendo mi base de datos ...
Así que traté de usar la función forceUTF8 publicada en el número 8, pero en la base de datos la cadena guardada se ve así:
esta es una cuerda de "escritura" escrita antes de que me pidieran a los "especiales" chicos que la vieran, convertida por la fama de la versión! & ¡Eso es!
Así que reuní más informaciones en esta página y las fusioné con otras 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 a cuidar es la función mysql_client_encoding ! Debe estar conectado a la base de datos porque esta función desea un ID de recurso como parámetro.
Pero bueno, solo hago esa recodificación antes de mi INSERT para que para mí no sea un problema.
Espero que esto ayude a alguien como esta página me ayudó!
¡Gracias a todos!
Mauro
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");
}
}
Lo interesante de mb_detect_encoding y mb_convert_encoding es que el orden de las codificaciones que sugieres es importante:
// $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. Sin embargo, tenga en cuenta que esto no es infalible.
Necesita probar el conjunto de caracteres en la entrada, ya que las respuestas pueden venir codificadas con diferentes codificaciones.
Obligo a que todo el contenido se envíe a UTF-8 mediante la detección y la traducción utilizando 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 de PHP que provienen del host remoto en UTF-8.
O ignore el valor si la codificación no se pudo detectar o convertir.
Puedes personalizarlo a tus necesidades.
Solo invocalo antes de usar las variables.
Obtenga la codificación de los encabezados y conviértala 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); }
Primero tienes que detectar qué codificación se ha utilizado. Mientras analiza las fuentes RSS (probablemente a través de HTTP), debe leer la codificación del parámetro charset del campo del encabezado HTTP de Content-Type . Si no está presente, lea la codificación del atributo de encoding de la instrucción de procesamiento XML . Si eso también falta, use UTF-8 como se define en la especificación .
Editar Esto es lo que probablemente haría:
cURL para enviar y buscar la respuesta. Eso le permite establecer campos de encabezado específicos y también recuperar el encabezado de respuesta. Después de obtener la respuesta, debe analizar la respuesta HTTP y dividirla en encabezado y cuerpo. El encabezado debe contener el campo de encabezado Content-Type que contiene el tipo MIME y (con suerte) el parámetro charset con la codificación / charset también. Si no, analizaremos el XML PI para la presencia del atributo de encoding y obtendremos la codificación desde allí. 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();
}
}
Sé que esta es una pregunta antigua, pero creo que una respuesta útil nunca duele. 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 en ASCII, y básicamente todo se arruinaría cuando los personajes extranjeros se involucraran.
Aquí está mi solución. Borra su GET / POST / REQUEST (omití las cookies, pero puede agregarlas si lo desea) en cada carga de página antes de procesar. Funciona bien en un encabezado. PHP emitirá 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){}
Si aplica utf8_encode() a una cadena UTF8 ya, devolverá una salida UTF8 confusa.
Hice una función que aborda todos estos problemas. Se llama Encoding::toUTF8() .
No necesitas saber cuál es la codificación de tus cadenas. Puede ser Latin1 (ISO 8859-1), Windows-1252 o UTF8, o la cadena puede tener una mezcla de ellos. Encoding::toUTF8() convertirá todo a UTF8.
Lo hice porque un servicio me estaba dando una fuente de datos desordenados, mezclando UTF8 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
Actualizar:
He incluido otra función, Encoding::fixUFT8() , que solucionará cada cadena UTF8 que se ve 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");
saldrá:
Fédération Camerounaise de Football
Fédération Camerounaise de Football
Fédération Camerounaise de Football
Fédération Camerounaise de Football
Actualización: 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() .
Su codificación se ve como si estuviera codificada en UTF-8 dos veces ; es decir, de alguna otra codificación, en UTF-8, y nuevamente en UTF-8. Como si tuviera iso-8859-1, convirtió de iso-8859-1 a utf-8, y trató 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:
- detecte la codificación utilizando
mb_detect_encoding()o lo que quiera usar - si es UTF-8, conviértalo a iso-8859-1 y repita el paso 1
- Finalmente, convertir de nuevo en UTF-8.
Eso es suponiendo que en la conversión "media" usó iso-8859-1. Si usó windows-1252, entonces conviértalo a windows-1252 (latin1). La codificación fuente original no es importante; El que usaste en defectuoso, segunda conversión es.
Esta es mi suposición de lo que pasó; 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 usa iso-8859-2 y windows-1250 (latin2).
Trabajar la codificación de caracteres de las fuentes RSS parece ser complicated . Incluso las páginas web normales a menudo omiten o mienten acerca de su codificación.
Por lo tanto, podría intentar utilizar la forma correcta de detectar la codificación y luego recurrir a alguna forma de detección automática (adivinación).
Un poco más arriba, 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 latin1 o posiblemente su conexión php-mysql está mal configurada, es decir, php cree que su mysql está configurado para usar utf-8, por lo que envía los datos como utf8, pero su mysql belives php está enviando datos codificados como iso-8859-1, por lo que una vez más puede intentar codificar los datos enviados como utf-8, causando este tipo de problemas.
Echa un vistazo a esto, puede ayudarte: http://php.net/manual/en/function.mysql-set-charset.php
Una forma realmente agradable de implementar una isUTF8 isUTF8 se puede encontrar en php.net :
function isUTF8($string) {
return (utf8_encode(utf8_decode($string)) == $string);
}
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 tomes algunas de tus fuentes con diferentes codificaciones y pruebes si mb_detect_encoding funciona o no.
actualizar
auto es la abreviatura de "ASCII, JIS, UTF-8, EUC-JP, SJIS". devuelve el conjunto de caracteres detectado, que puede utilizar 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 forma más sencilla.
Ÿ es Mojibake para ß . En tu base de datos, puedes tener hex
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
No debe usar ninguna función de codificación / decodificación 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é.
Probar sin ''auto''
Es decir:
mb_detect_encoding($text)
en lugar de:
mb_detect_encoding($text, ''auto'')
Más información se puede encontrar aquí: mb_detect_encoding
Tuve el mismo problema con phpQuery ( ISO-8859-1 en lugar de UTF-8 ) y este truco me ayudó a:
$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.