Vérifier si une chaîne est codé en UTF-8

function seems_utf8($str) {
 $length = strlen($str);
 for ($i=0; $i < $length; $i++) {
  $c = ord($str[$i]);
  if ($c < 0x80) $n = 0; # 0bbbbbbb
  elseif (($c & 0xE0) == 0xC0) $n=1; # 110bbbbb
  elseif (($c & 0xF0) == 0xE0) $n=2; # 1110bbbb
  elseif (($c & 0xF8) == 0xF0) $n=3; # 11110bbb
  elseif (($c & 0xFC) == 0xF8) $n=4; # 111110bb
  elseif (($c & 0xFE) == 0xFC) $n=5; # 1111110b
  else return false; # Does not match any model
  for ($j=0; $j<$n; $j++) { # n bytes matching 10bbbbbb follow ?
   if ((++$i == $length) || ((ord($str[$i]) & 0xC0) != 0x80))
    return false;
  }
 }
 return true;
}

J'ai eu ce code de WordPress, je ne sais pas beaucoup sur ce sujet, mais je voudrais savoir ce qu'est exactement happing dans cette fonction.

Si quelqu'un sait s'il vous plaît m'aider?

J'ai besoin de l'idée claire sur le code ci-dessus. Si, ligne par ligne, l'explication sera plus utile.

OriginalL'auteur coderex | 2009-09-24

9

J'utilise deux méthodes pour vérifier si la chaîne est en utf-8 (selon le cas):
```
mb_internal_encoding('UTF-8'); //always needed before mb_ functions, check note below
if (mb_strlen($string) != strlen($string)) {
 ///not single byte
}
```
-- OU --
```
if (preg_match('!\S!u', $string)) {
 //utf8
}
```
Pour la mb_internal_encoding - en raison de certaines inconnu pour moi bug dans php (version 5.3- (ne l'ai pas testé sur 5.3)) en passant le codage en tant que paramètre à la mb_ ne fonctionne pas et le codage interne doit être défini avant toute utilisation de fonctions mb_.

Il suffit donc de ne mb_strlen ($string, 'UTF-8') ensuite.

OriginalL'auteur bisko
7

Cet algorithme est essentiellement de vérifier si la séquence d'octets est conforme au modèle que vous pouvez voir dans la Article de Wikipedia.

La for boucle est de passer par tous les octets dans $str. ord obtient le nombre décimal de l'actuelle de l'octet. Ce nombre est ensuite testé pour certaines propriétés.

Si le nombre si moins de 128 (0x80), c'est un seul octet caractère. Si elle est égale ou supérieure à 128, la longueur des caractères multi-octets est cochée. Qui peut être fait avec le premier caractère d'un de caractères multi-octets de la séquence. Si le premier octet commence par 110xxxxx, c'est un deux octets de caractères; 1110xxxx, c'est un de trois octets de caractères, etc.

Je pense que le plus cryptical sont les parties les expressions comme ($c & 0xE0) == 0xC0. C'est pour vérifier si le nombre en format binaire a certains modèle spécifique. Je vais essayer d'expliquer comment cela fonctionne sur le même exemple.

Puisque tous les nombres que nous testons pour ce motif sont égales ou supérieures à 0x80, le premier octet est toujours de 1, de sorte que le motif est limité à au moins 1xxxxxxxx. Si nous procédons à un bit par bit ET la comparaison avec 11100000 (0xE0), on obtient ce résultat:
```
  1xxxxxxx
& 11100000
= 1xx00000
```
Donc les bits à la position 5 et 6 (lire en partant de la droite, l'indice a commencé à 0) dépendent de ce que notre nombre actuel est. Avoir que l'égalité de 11000000, le 5ème morceau doit être 0 et le 6ème bit doit être 1:
```
  1xxxxxxx
& 11100000
≟ 11000000
   ↓↓
→ 110xxxxx
```
Qui veut dire que les autres éléments de notre numéro peut être arbitraire: 110xxxxx. Et c'est exactement ce que le modèle de l'article de Wikipédia prévoit pour le premier octet deux octets de caractères mot.

Et la dernière l'intérieur for boucle est de vérifier la santé mentale de la suite d'octets de caractères multi-octets. Celles-ci doivent commencer par 10xxxxxx.

OriginalL'auteur Gumbo

Si vous connaissez un peu l'UTF-8, il est assez simple de mise en œuvre.

function seems_utf8($str) {
 # get length, for utf8 this means bytes and not characters
 $length = strlen($str);  

 # we need to check each byte in the string
 for ($i=0; $i < $length; $i++) {

  # get the byte code 0-255 of the i-th byte
  $c = ord($str[$i]);

  # utf8 characters can take 1-6 bytes, how much
  # exactly is decoded in the first character if 
  # it has a character code >= 128 (highest bit set).
  # For all <= 127 the ASCII is the same as UTF8.
  # The number of bytes per character is stored in 
  # the highest bits of the first byte of the UTF8 
  # character. The bit pattern that must be matched
  # for the different length are shown as comment.
  #
  # So $n will hold the number of additonal characters

  if ($c < 0x80) $n = 0; # 0bbbbbbb
  elseif (($c & 0xE0) == 0xC0) $n=1; # 110bbbbb
  elseif (($c & 0xF0) == 0xE0) $n=2; # 1110bbbb
  elseif (($c & 0xF8) == 0xF0) $n=3; # 11110bbb
  elseif (($c & 0xFC) == 0xF8) $n=4; # 111110bb
  elseif (($c & 0xFE) == 0xFC) $n=5; # 1111110b
  else return false; # Does not match any model

  # the code now checks the following additional bytes
  # First in the if checks that the byte is really inside the
  # string and running over the string end.
  # The second just check that the highest two bits of all 
  # additonal bytes are always 1 and 0 (hexadecimal 0x80)
  # which is a requirement for all additional UTF-8 bytes

  for ($j=0; $j<$n; $j++) { # n bytes matching 10bbbbbb follow ?
   if ((++$i == $length) || ((ord($str[$i]) & 0xC0) != 0x80))
    return false;
  }
 }
 return true;
}

Par la voie. Sur le PHP je suppose que c'est un facteur 50 à 100 plus lent que d'une fonction C de sorte que vous ne devriez pas vraiment l'utiliser sur de longues chaînes et les systèmes de production.

OriginalL'auteur Lothar

0

suis tombé sur ce post, avaient le même problème .. mb_detect_encoding a montré utf-8, mais mb_check_encoding retourné false...

pour le résoudre, pour moi la solution a été:
```
 $cur_encoding = mb_detect_encoding($in_str) ;
  if($cur_encoding == "UTF-8" && mb_check_encoding($in_str,"UTF-8"))
    return $in_str;
  else
    return utf8_encode($in_str); 
```
obtenu à partir de là:
http://board.phpbuilder.com/showthread.php?10368156-mb_check_encoding%28-in_str-quot-UTF-8-quot-%29-return-different-results

sry ne pouvait pas poster le lien correctement....

OriginalL'auteur womd

Vous devez vous connecter pour publier un commentaire.