Detectar codificação e fazer tudo UTF-8

votos
266

Estou lendo fora muitos textos de vários feeds RSS e inseri-los em meu banco de dados.

Naturalmente, existem várias codificações de caracteres diferentes usados ​​nos alimentos, por exemplo, UTF-8 e ISO-8859-1.

Infelizmente, às vezes há problemas com as codificações dos textos. Exemplo:

1) O ß em Fußball deve ser semelhante a esta no meu banco de dados: ay. Se é um ay, ele será exibido corretamente.

2) Às vezes, o ß em Fußball se parece com isso no meu banco de dados: ß. Em seguida, ele é exibido de forma errada, é claro.

3) Em outros casos, o SS é salvo como um ß - assim, sem qualquer alteração. Em seguida, ele também é exibido de forma errada.

O que posso fazer para evitar os casos 2 e 3?

Como posso fazer tudo a mesma codificação, de preferência UTF-8? Quando eu deve usar utf8_encode (), quando devo usar utf8_decode () (é claro qual o efeito é, mas quando eu devo usar as funções?) E quando devo fazer nada com a entrada?

Você pode me ajudar e me dizer como fazer tudo a mesma codificação? Talvez com a função mb-detectar-codificação ()? Eu posso escrever uma função para isso? Então, meus problemas são: 1) Como descobrir o que codifica a texto usa 2) Como convertê-lo para UTF-8 - qualquer que seja a idade codificação é

EDIT: Será que uma função como este trabalho?

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

Eu testei-lo, mas ele não funciona. O que há de errado com isso?

Publicado 26/05/2009 em 14:50
fonte usuário
Em outras línguas...                            


24 respostas

votos
315

Se você aplicar utf8_encode()para uma string já UTF8 ele irá retornar uma saída UTF8 ilegível.

Eu fiz uma função que aborda todas essas questões. IT'S chamado Encoding::toUTF8().

Você não precisa saber o que a codificação dos seus textos é. Pode ser Latin1 (ISO 8859-1), Windows-1252 ou UTF8, ou a string pode ter uma mistura deles. Encoding::toUTF8()irá converter tudo para UTF8.

Eu fiz isso porque um serviço estava me dando um feed de dados de toda desarrumada, misturando UTF8 e Latin1 na mesma corda.

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);

Download:

https://github.com/neitanod/forceutf8

Atualizar:

Eu incluí uma outra função, Encoding::fixUFT8()que irá corrigir todas as cordas UTF8 que parece ilegível.

Uso:

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

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

Exemplos:

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");

saída de vontade:

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

Update: Eu transformado a função ( forceUTF8) em uma família de funções estáticas em uma classe chamada Encoding. A nova função é Encoding::toUTF8().

Respondeu 13/08/2010 em 19:49
fonte usuário

votos
72

Você primeiro tem que detectar que codificação tem sido usado. Como você está analisando feeds RSS (provavelmente via HTTP), você deve ler a codificação do charsetparâmetro do Content-Typecampo de cabeçalho HTTP . Se ele não estiver presente, leia a codificação do encodingatributo da instrução de processamento XML . Se o que está faltando também, usar UTF-8 como definido na especificação .


Editar    Aqui está o que eu provavelmente faria:

Eu usaria cURL para enviar e buscar a resposta. Isso permite que você defina campos de cabeçalho específicos e buscar o cabeçalho de resposta também. Depois de buscar a resposta, você tem que analisar a resposta HTTP e dividi-lo em cabeçalho e corpo. O cabeçalho deverá então conter o Content-Typecampo de cabeçalho que contém o tipo MIME e (espera-se) o charsetparâmetro com a codificação / charset também. Se não, vamos analisar o PI XML para a presença do encodingatributo e começar a codificação de lá. Se isso é também ausente, as especificações XML definem a usar UTF-8 como codificação.

$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();
    }
}
Respondeu 26/05/2009 em 20:52
fonte usuário

votos
35

Detectando a codificação é difícil.

mb_detect_encodingtrabalha por adivinhar, com base em um número de candidatos que você passá-lo. Em alguns codificações, certos bytes-sequências são inválidos, um, portanto, pode distinguir entre os vários candidatos. Infelizmente, há uma série de codificações, onde os mesmos bytes são válidos (mas diferente). Nestes casos, não há nenhuma maneira de determinar a codificação; Você pode implementar sua própria lógica para fazer suposições nesses casos. Por exemplo, os dados provenientes de um site japonês pode ser mais propensos a ter uma codificação japonês.

Contanto que você só lidar com idiomas da Europa Ocidental, as três principais codificações a considerar são utf-8, iso-8859-1e cp-1252. Desde que estes são padrões para muitas plataformas, eles também são os mais propensos a ser relatado erroneamente sobre. Por exemplo. se as pessoas usam diferentes codificações, que são susceptíveis de ser franco sobre isso, uma vez que outra coisa o seu software iria quebrar muito frequentemente. Portanto, uma boa estratégia é confiar o fornecedor, a menos que a codificação é relatado como um dos três. Você ainda deve reverificar que é realmente válido, usando mb_check_encoding(note que válido não é o mesmo que ser - a mesma entrada pode ser válida para muitos codificações). Se é um desses, você pode usarmb_detect_encodingpara distinguir entre eles. Felizmente que é bastante determinista; Você só precisa usar o bom detectar-sequência, que é UTF-8,ISO-8859-1,WINDOWS-1252.

Uma vez que você detectou a codificação que você precisa convertê-lo à sua representação interna ( UTF-8é a única escolha sã). A função utf8_encodetransforma ISO-8859-1a UTF-8, de modo que só pode ser usado para esse tipo de entrada em particular. Para outras codificações, use mb_convert_encoding.

Respondeu 26/05/2009 em 15:38
fonte usuário

votos
11

Um realmente boa maneira de implementar uma isUTF8-função podem ser encontrados no php.net :

function isUTF8($string) {
    return (utf8_encode(utf8_decode($string)) == $string);
}
Respondeu 13/08/2010 em 19:23
fonte usuário

votos
11

Este cheatsheet lista algumas ressalvas comuns relacionados com a UTF 8 de manipulação em PHP: http://developer.loftdigital.com/blog/php-utf-8-cheatsheet

Esta função detectar caracteres de vários bytes em uma string pode também revelar-se útil ( fonte ):


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);
}

Respondeu 09/06/2009 em 15:54
fonte usuário

votos
9

Um pouco de heads-up, você disse que o "ß" deve ser exibido como "Ay" em seu banco de dados.

Este é provavelmente porque você está usando um banco de dados com codificação de caracteres latin1 ou, eventualmente, a sua ligação php-mysql está definido errado, isso é, php acredita o mysql está definido para usar UTF-8, por isso envia dados como UTF-8, mas o seu mysql belives php está enviando dados codificados como iso-8859-1, por isso pode voltar a tentar codificar os seus dados enviados como UTF-8, causando esse tipo de problema.

Dê uma olhada neste, pode ajudá-lo: http://php.net/manual/en/function.mysql-set-charset.php

Respondeu 27/06/2011 em 17:12
fonte usuário

votos
3

Você precisa testar o charset na entrada vez que as respostas podem vir codificadas com diferentes codificações.
Eu forçar todos os conteúdos foram enviados em UTF-8, fazendo a detecção e tradução utilizando a seguinte função:

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;
      }
    }
  }
}

Essa rotina vai virar todas as variáveis PHP que vêm do host remoto em UTF-8.
Ou ignorar o valor se a codificação não pôde ser detectado ou convertidos.
Você pode personalizá-lo às suas necessidades.
Apenas invocá-lo antes de usar as variáveis.

Respondeu 16/12/2011 em 17:46
fonte usuário

votos
3

Sua codificação parece que você codificados em UTF-8 duas vezes ; que é, de algum outro codificação, em UTF-8, e de novo em UTF-8. Como se você tivesse iso-8859-1, convertido a partir de iso-8859-1 para utf-8, e tratado a nova cadeia como iso-8859-1 para outra conversão em UTF-8.

Aqui está um pseudocódigo do que você fez:

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

Você deveria tentar:

  1. detectar codificação usando mb_detect_encoding()ou o que você gostaria de usar
  2. se é UTF-8, converter em iso-8859-1, e repita o passo 1
  3. finalmente, de volta para converter UTF-8

Que está presumindo que na conversão "meio" que utilizou iso-8859-1. Se você usou windows-1252, em seguida, converter em windows-1252 (latin1). A codificação de fonte original não é importante; o que você usou na falho, segunda conversão é.

Este é o meu palpite sobre o que aconteceu; há muito pouca coisa que poderia ter feito para obter quatro bytes no lugar de um byte ASCII estendido.

língua alemã também usa iso-8859-2 e janelas-1250 (latin2).

Respondeu 04/06/2009 em 11:07
fonte usuário

votos
2

A coisa interessante sobre mb_detect_encodinge mb_convert_encodingé que a ordem das codificações que você sugere que 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)

Então você pode querer usar uma ordem específica ao especificar codificações esperados. Ainda assim, tenha em mente que este não é infalível.

Respondeu 11/03/2012 em 18:58
fonte usuário

votos
2

Eu estava verificando de soluções para codificação desde idades, e esta página é provavelmente a conclusão de anos de pesquisa! Eu testei algumas das sugestões que você mencionou e é aqui minhas notas:

Esta é a minha string de teste:

este é um "escrito errado" string mas eu preciso PU 'alguns' caracteres especiais para vê-los, convertido por função !! & é isso aí!

Eu um INSERT IGNORE para salvar esta corda em um DB em um campo que é definido como utf8_general_ci

Charset de minha página é UTF-8

Se eu um INSERT IGNORE assim mesmo, no meu DB eu tenho alguns caracteres provavelmente vindo de Marte ... então eu preciso convertê-los em algum "sã" UTF-8. Eu tentei utf8_encode(), mas ainda estrangeiros caracteres estavam invadindo meu banco de dados ...

Então, eu tentei usar a função forceUTF8postou no número 8, mas no DB a corda salva parece com isso:

esta é uma string "wròng wrìtten" bùt I IAED para rs Cha especiais pù 'sòme' para ver Tham, convertèd por fùnctìon !! & é isso aí!

Então recolher mais algumas informações sobre esta página e fundi-las com outras informações sobre em outras páginas Eu resolvi meu problema com esta solução:

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

Agora, no meu banco de dados que eu tenho a minha string com codificação correta.

NOTA: Apenas nota para tomar cuidado é em função mysql_client_encoding! Você precisa estar conectado a DB porque esta função quer um ID de recurso como parâmetro.

Mas bem, eu só faço que re-codificação antes do meu INSERIR IGNORE então para mim não é um problema.

Espero que isso vai ajudar alguém como esta página me ajudou!

Obrigado a todos!

Mauro

Respondeu 01/12/2011 em 01:15
fonte usuário

votos
2

Eu sei que isto é uma questão mais velho, mas eu acho que uma resposta útil nunca é demais. Eu estava tendo problemas com a minha codificação entre um aplicativo desktop, SQLite, e GET / POST variáveis. Alguns poderiam estar em UTF-8, alguns estariam em ASCII, e basicamente tudo iria ficar asneira quando os personagens estrangeiras se envolveram.

Aqui está a minha solução. Ela esfrega seu GET / POST / PEDIDO (omiti cookies, mas você pode adicioná-los se desejado) em cada carregamento da página antes do processamento. Ele funciona bem em um cabeçalho. PHP irá lançar avisos se ele não consegue detectar a codificação de fonte automaticamente, assim que estes avisos são suprimidos com @ '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){}
Respondeu 23/05/2010 em 06:52
fonte usuário

votos
2

Trabalhar fora a codificação de caracteres de feeds RSS parece ser complicado . Até mesmo páginas da web normais, muitas vezes omitir ou mentir sobre, sua codificação.

Então você pode tentar usar a maneira correta de detectar a codificação e, em seguida, cair de volta para alguma forma de auto-detecção (supondo).

Respondeu 26/05/2009 em 15:02
fonte usuário

votos
2

É simples: quando você começa algo que não é UTF8, você deve codificar isso em utf8.

Então, quando você está buscando um determinado alimento que é ISO-8859-1 analisá-lo através utf8_encode.

No entanto, se você está buscando uma alimentação UTF8, você não precisa fazer nada.

Respondeu 26/05/2009 em 14:55
fonte usuário

votos
1

@harpax que funcionou para mim. No meu caso, isso é bom o suficiente:

if (isUTF8($str)) { 
    echo $str; 
}
else
{
    echo iconv("ISO-8859-1", "UTF-8//TRANSLIT", $str);
}
Respondeu 26/07/2011 em 23:21
fonte usuário

votos
1

php.net/mb_detect_encoding

echo mb_detect_encoding($str, "auto");

ou

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

Eu realmente não sei quais são os resultados, mas eu sugiro que você tomar apenas alguns dos seus feeds com codificações diferentes e tentar se mb_detect_encodingfunciona ou não.

atualização
automática é a abreviação de "ASCII, JIS, UTF-8, EUC-JP, SJIS". ele retorna o charset detectado, o que você pode usar para converter a seqüência de utf-8 com iconv .

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

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

Eu não testei isso, então nenhuma garantia. e talvez haja uma maneira mais simples.

Respondeu 26/05/2009 em 15:10
fonte usuário

votos
0

A resposta mais votada não funciona. Aqui é meu e espero que ajude.

function toUTF8($raw) {
    try{
        return mb_convert_encoding($raw, "UTF-8", "auto"); 
    }catch(\Exception $e){
        return mb_convert_encoding($raw, "UTF-8", "GBK"); 
    }
}
Respondeu 29/06/2017 em 03:51
fonte usuário

votos
0

I encontrar solução aqui 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;
}

Eu acho que @ é má decisão, e fazer algumas alterações para solução de deer.org.ua;

Respondeu 13/12/2016 em 15:05
fonte usuário

votos
0

Ÿé mojibake para ß. Em seu banco de dados, você pode ter 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

Você deve não usar quaisquer funções de codificação / decodificação em PHP; em vez disso, você deve configurar o banco de dados ea conexão a ele corretamente.

Se o MySQL está envolvido, consulte: Problemas com caracteres utf8; o que eu vejo não é o que eu armazenados

Respondeu 19/08/2016 em 18:46
fonte usuário

votos
0

Obter codificação de cabeçalhos e convertê-lo para 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); }
Respondeu 01/02/2014 em 10:20
fonte usuário

votos
0

Esta versão é para o idioma alemão, mas você pode modifiy a $ Charsets e os US $ 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 );
}
}

Respondeu 22/02/2012 em 19:47
fonte usuário

votos
0

Após a triagem para fora seus scripts PHP, não se esqueça de dizer mysql o charset que você está passando e gostaria de recceive.

Exemplo: definir conjunto de caracteres utf8

Passando dados utf8 a uma tabela latin1 em uma sessão de I / O latin1 dá essas birdfeets desagradáveis. Eu vejo isso todos os outros dias em lojas de osCommerce. Voltar e quarto pode parecer certo. Mas phpmyadmin vai mostrar a verdade. Ao dizer mysql o charset que você está passando ele vai lidar com a conversão de dados mysql para você.

Como recuperar dados mysql mexidos existente é outro segmento para discutir. :)

Respondeu 18/01/2012 em 20:31
fonte usuário

votos
-1

Experimente sem 'auto'

Isso é:

mb_detect_encoding($text)

ao invés de:

mb_detect_encoding($text, 'auto')

Mais informações podem ser encontradas aqui: mb_detect_encoding

Respondeu 22/07/2017 em 08:55
fonte usuário

votos
-1

Eu tive mesmo problema com phpQuery ( ISO-8859-1 em vez de UTF-8 ) e este hack me ajudou:

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

mb_internal_encoding('UTF-8'), phpQuery::newDocumentHTML($html, 'utf-8'), mbstring.internal_encodingE outras manipulações não tomou qualquer efeito.

Respondeu 15/07/2013 em 21:19
fonte usuário

votos
-1

Ao tentar lidar com múltiplas linguagens como japonês e coreano que você pode ficar em apuros. mb_convert_encoding com o parâmetro 'auto' não funciona bem. Definir mb_detect_order ( 'ASCII, UTF-8, JIS, EUC-JP, SJIS, EUC-KR, UHC') não ajuda, uma vez que irá detectar EUC- * erroneamente.

Cheguei à conclusão de que, enquanto cadeias de entrada vem de HTML, ele deve usar 'charset' em um elemento meta. Eu uso simples HTML DOM Parser porque suporta HTML inválido.

O fragmento abaixo extrai elemento título a partir de uma página da web. Se você gostaria de converter página inteira, então você pode querer remover algumas linhas.

<?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);
}
Respondeu 15/09/2011 em 00:29
fonte usuário

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more