La longueur de la chaîne en octets en JavaScript

Dans mon code JavaScript j'ai besoin de rédiger un message à un serveur dans ce format:

<size in bytes>CRLF
<data>CRLF

Exemple:

3
foo

Les données peuvent contenir des caractères unicode. J'ai besoin de les envoyer, comme UTF-8.

Je suis à la recherche pour la plupart de la croix-navigateur de façon à calculer la longueur de la chaîne en octets en JavaScript.

J'ai essayé de composer ma charge utile:

return unescape(encodeURIComponent(str)).length + "\n" + str + "\n"

Mais il ne me donne pas de résultats précis pour les anciens navigateurs (ou, peut-être les cordes dans ces navigateurs en UTF-16?).

Toute indices?

Mise à jour:

Exemple: longueur en octets de la chaîne ЭЭХ! Naïve? en UTF-8 est de 15 octets, mais certains navigateurs rapport de 23 octets au lieu.

Double Possible? stackoverflow.com/questions/2219526/...
aucune des réponses à la question que vous avez lié à travailler pour moi.
Quand vous parlez de "ЭЭХ! Naïf?" avez vous la mettez dans un particulier forme normale? unicode.org/reports/tr15
J'ai tapé au hasard éditeur de texte (en mode UTF-8) et l'a sauvé. Tout comme n'importe quel utilisateur de ma bibliothèque devrait le faire. Cependant, il semble que j'ai compris ce qui n'allait pas — voir ma réponse.

InformationsquelleAutor Alexander Gladysh | 2011-04-01

javascript unicode

80

~~Il n'y a aucun moyen de le faire en JavaScript natif.~~ (Voir Riccardo Galli réponse pour une approche moderne.)

Pour référence historique ou où TextEncoder Api sont toujours indisponible.

Si vous connaissez le codage des caractères, vous pouvez calculer vous-même si.

encodeURIComponent suppose l'UTF-8 comme encodage des caractères, donc si vous avez besoin que l'encodage, vous pouvez le faire,
```
function lengthInUtf8Bytes(str) {
  //Matches only the 10.. bytes that are non-initial characters in a multi-byte sequence.
  var m = encodeURIComponent(str).match(/%[89ABab]/g);
  return str.length + (m ? m.length : 0);
}
```
Cela devrait fonctionner en raison de la façon UTF-8 code multi-séquences d'octets. Le premier octet codé commence toujours avec un peu élevé de zéro pour une seule séquence d'octets, ou un octet dont le premier chiffre hexadécimal est C, D, E ou F. La deuxième et les suivantes octets sont ceux dont les deux premiers bits sont 10. Ce sont les octets supplémentaires que vous souhaitez compter en UTF-8.

La table dans wikipédia rend plus claire
```
Bits        Last code point Byte 1          Byte 2          Byte 3
  7         U+007F          0xxxxxxx
 11         U+07FF          110xxxxx        10xxxxxx
 16         U+FFFF          1110xxxx        10xxxxxx        10xxxxxx
...
```
Si, au contraire, vous avez besoin de comprendre le codage de la page, vous pouvez utiliser cette astuce:
```
function lengthInPageEncoding(s) {
  var a = document.createElement('A');
  a.href = '#' + s;
  var sEncoded = a.href;
  sEncoded = sEncoded.substring(sEncoded.indexOf('#') + 1);
  var m = sEncoded.match(/%[0-9a-f]{2}/g);
  return sEncoded.length - (m ? m.length * 2 : 0);
}
```
- Eh bien, comment pourrais-je savoir le codage des caractères de données? J'ai besoin de coder quelle que soit la chaîne de l'utilisateur (programmeur) fourni à ma bibliothèque JS.
- lorsque vous envoyez le message au serveur, vous êtes en spécifiant l'encodage de contenu du corps du message par l'intermédiaire d'un en-tête HTTP?
- Eh bien, je suis de codage d'une bibliothèque JS. Je ne sais pas comment l'utilisateur de spécifier l'encodage de contenu. Cependant, je peux mettre ça dans une des exigences. Quelle est la meilleure façon de le faire sort ce dans le readme?
- à moins que vous pouvez dissocier l'encodage à l'aide de votre code, vous devez exiger qu'ils spécifier l'encodage que vous supposez, ou vous avez besoin d'envoyer un message avec le codage de la page. D'éditer mon post pour préciser comment tester le codage de la page.
- donc, vous dites que unescape(encodeURIComponent(str)).length fonctionnerait que si str est en UTF-8?
- - Je voir votre mise à jour, mais je suis confus par le nom de la fonction. lengthInPageEncoding suggère que c'est une longueur en caractères. Est-ce exact? J'ai besoin de la longueur de octets. (Désolé pour la question stupide.)
- unescape(encodeURIComponent(str)).length de ne pas faire quelque chose d'utile depuis unescape n'des choses différentes sur différentes plates-formes. decodeURIComponent(encodeURIComponent(str)).length ne fera que vous donner str.length. Voir xkr.us/articles/javascript/encoder-comparer
- Je vois. Donc, vous suggérez que la bonne façon d'obtenir la longueur de la chaîne en octets dans mon cas, est d'utiliser votre lengthInPageEncoding fonction, est-ce correct?
- si vous pouvez éventuellement obtenir loin sans se soucier de la longueur, en octets, que je le ferais. Mais si vous en avez vraiment besoin, quelque chose comme ça, c'est probablement votre meilleur pari. Il ne sera probablement pas travailler pour étrange encodages comme UTF-7 depuis + est un caractère spécial dans les Uri et nécessite une multi-octet de l'encodage en UTF-7.
- Je ne peux pas sortir sans elle, car le serveur est tellement stupide qu'il ne sait rien à propos de l'Unicode — il traite toutes les chaînes de caractères comme des blobs binaires (et il n'a pas besoin de plus de travail). Je ne vous inquiétez pas de l'UTF-7. En fait, je suis très bien avec l'application de l'UTF-8 (mais que vous souhaitez soutenir l'UTF-16 et CP1251 et comme le bien).
- sur unescape: la chose étrange est que tous les navigateurs sur browsershots.org affichage de la chaîne correcte de la taille de la chaîne UTF-8 que j'ai testé au moins (voir url dans ma réponse). Est-ce un hasard?
- Je suis d'accepter cette réponse, mais à la fin j'ai décidé de prolonger le protocole de soutenir des chaînes UTF-8 en natif. Apparemment, il n'est pas si effrayant: stackoverflow.com/questions/5517205/...
- cool. Si vous êtes l'établissement d'un protocole de, mandat de l'UTF-8 est une excellente idée pour le texte-échange. Un de moins variable qui peut entraîner une incompatibilité. UTF-8 doit être le réseau-l'ordre des octets de l'encodage des caractères.
- Le lengthInUtf8Bytes fonction renvoie 5 pour les non-BMP personnages str.length pour ces retours 2. Je vais écrire une version modifiée de cette fonction pour des réponses.
- Je pense que vous avez raison. Doit la sortie 5 ou 6 octets codant pour les CPs au lieu d'encodage UTF-16 du code-unités?
- Les paires de substitution sont constitués de deux unités de code (''.length == 2) même si il n'y a qu' un caractère Unicode il n'. La personne porteuse moitiés sont exposés comme s'ils étaient des personnages: '' == '\uD834\uDF06'. Source
- Je sais. Par "code UTF-16-parts", je faisais allusion à des mères porteuses.
- github.com/substack/utf8-length/blob/master/index.js
- Cette solution est cool, mais utf8mb4 n'est pas considérée. Par exemple , encodeURIComponent('') est '%F0%9F%8D%80'.
- Dans un commentaire précédent vous avez dit "depuis unescape n'des choses différentes sur différentes plates-formes". Sur la plate-forme ne unescape de ne pas suivre le standard? (Le comportement de unescape dans le standard actuel est le même que dans le premier standard)
- Vous avez peut être juste qu'il n'y a pas de moteurs modernes qui divergent. unescape('%uabcd') ==== '\uabcd' qui n'est pas pour cent de l'encodage. Autant que je me souvienne, c'était un IE changement de Netscape comportement pour le rendre plus facile pour les JS sur la non-UTF8 pages pour interagir avec IIS. Voir "%u"codage re IIS bizarreries.
- Oui, %uabcd n'est pas pour cent de l'encodage (Il n'est même pas valide dans un URI selon RFC3986) - mais cela n'arrive jamais dans unescape(encodeURIComponent(...)). Donc, je persiste à croire que "unescape(encodeURIComponent(str)).length de ne pas faire quelque chose d'utile depuis unescape n'des choses différentes sur différentes plates-formes." n'est pas correct. D'où vient unescape(encodeURIComponent(str)).length pas de travail? (Voir aussi stackoverflow.com/a/619428/2770331)
- Je pense que j'ai déjà reconnu que "ne des choses différentes" est faux aujourd'hui. Vous semblez parler d'un vieux thread que j'avais oublié, donc je ne suis pas clair sur ce que vous voulez faire avec unescape(encodeURIComponent(str)).length.
- Je pense juste que c'est pas bon, qui l'a accepté, plus voté réponse suggère une méthode (var m = encodeURIComponent(str).match(/%[89ABab]/g); return str.length + (m ? m.length : 0);) qui ne fonctionne pas pour codepoints à l'extérieur de la BMP (comme remarqué dans ce comment) quand à la question d'origine contenait déjà une solution, qui fonctionne partout avec tous les codepoints (return unescape(encodeURIComponent(str)).length). Il serait bien, si ce n'était pas seulement visible dans les ...
- ... des commentaires, mais aussi dans la réponse elle-même - qui lit ce nombre de commentaires? Oh, et désolé si j'ai l'air un peu rude - ce n'était pas mon intention. Je ne suis pas un locuteur natif et ont parfois l'habitude, d'être un peu direct...
- Oh, et la citation "unescape(encodeURIComponent(str)).length de ne pas faire quelque chose d'utile depuis unescape n'des choses différentes sur différentes plates-formes." est venu à partir de heresi c'était votre question 🙂
- Cette solution a montré mon 8 octets 24.essayez : عباس en utf8
- Je reçois 8 pour "\u0639\u0628\u0627\u0633".
- Je ne sais pas monsieur,je suis l'aide de l'opéra,html en utf-8 à la page,عباس me donne 24.
- Dans votre développeur de la console, ce que vous obtenez pour encodeURIComponent("\u0639\u0628\u0627\u0633")? Je reçois "%D8%B9%D8%A8%D8%A7%D8%B3".
InformationsquelleAutor Mike Samuel
86

Les années ont passé et aujourd'hui, vous pouvez le faire en natif
```
(new TextEncoder().encode('foo')).length
```
Noter qu'il n'est pas encore pris en charge par IE (ou Edge) (vous pouvez utiliser un polyfill pour ça).

MDN documentation

Les spécifications de la norme
- Quelle fantastique, de la modernité. Merci!
- Notez que selon le MDN documentation, le TextEncoder n'est pas encore pris en charge par Safari (WebKit).
- TextEncode prend en charge uniquement les utf-8 depuis Chrome 53.
- Si vous avez besoin seulement de la longueur, il serait peut-être exagéré d'allouer une nouvelle chaîne, faire la conversion réelle, prenez la longueur, puis les jeter à la chaîne. Voir ma réponse ci-dessus pour une fonction qui calcule la longueur d'une manière efficace.
InformationsquelleAutor Riccardo Galli
58

Ici est beaucoup plus rapide de la version, ce qui ne veut pas utiliser des expressions régulières, ni encodeURIComponent():
```
function byteLength(str) {
  //returns the byte length of an utf8 string
  var s = str.length;
  for (var i=str.length-1; i>=0; i--) {
    var code = str.charCodeAt(i);
    if (code > 0x7f && code <= 0x7ff) s++;
    else if (code > 0x7ff && code <= 0xffff) s+=2;
    if (code >= 0xDC00 && code <= 0xDFFF) i--; //trail surrogate
  }
  return s;
}
```
Ici est un performances comparaison.

Il calcule la longueur en UTF8 de chaque unicode codepoints retourné par charCodeAt() (basé sur wikipédia descriptions des UTF8, et UTF16 caractères de substitution).

Il suit RFC3629 (où les caractères UTF-8 sont au plus 4 octets de long).
- Cela fonctionne comme prévu je vous remercie beaucoup.
InformationsquelleAutor lovasoa
39

Pour le simple encodage UTF-8, avec un peu meilleure compatibilité que TextEncoder, Blob fait le tour. Ne fonctionne pas dans les très vieux navigateurs bien.
```
new Blob([""]).size; //-> 4  
```
InformationsquelleAutor simap
29

Cette fonction retourne la taille en octets de toute chaîne UTF-8 vous passer.
```
function byteCount(s) {
    return encodeURI(s).split(/%..|./).length - 1;
}
```
Source

InformationsquelleAutor Lauri Oherd
15

Une autre approche très simple à l'aide de Buffer (uniquement pour NodeJS):
```
Buffer.from(string).length
```
InformationsquelleAutor Iván Pérez
4

En fait, j'ai compris quel est le problème. Pour que le code fonctionne la page <head> devrait avoir cette balise:
```
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
```
Ou, comme suggéré dans les commentaires, si le serveur envoie une requête HTTP Content-Encoding en-tête, il devrait fonctionner aussi bien.

Ensuite les résultats de différents navigateurs sont compatibles.

Voici un exemple:
```
<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> 
  <title>mini string length test</title>
</head>
<body>

<script type="text/javascript">
document.write('<div style="font-size:100px">' 
    + (unescape(encodeURIComponent("ЭЭХ! Naïve?")).length) + '</div>'
  );
</script>
</body>
</html>
```
Note: je crois que la définition de tout (précis) de codage serait résoudre le problème d'encodage. C'est juste une coïncidence que j'ai besoin de l'UTF-8.
- Le unescape fonction JavaScript ne devrait pas être utilisés pour décoder les Identificateurs de Ressources Uniformes (URI).
- doit jamais être utilisé pour décoder les Uri. Cependant, pour convertir du texte en UTF-8 ça fonctionne fine
- unescape(encodeURIComponent(...)).length calcule toujours la bonne longueur avec ou sans meta http-equiv ... utf8. Sans un encodage spécification de certains navigateurs peuvent tout simplement eu un texte différent (après codage des octets du document en texte html) dont la longueur, ils ont calculé. On peut tester facilement, par l'impression non seulement la durée, mais aussi le texte lui-même.
InformationsquelleAutor Alexander Gladysh
4

M'a fallu du temps pour trouver une solution pour Réagir Natif donc je vais le mettre ici:

D'abord installer le buffer package:
```
npm install --save buffer
```
Alors l'utilisateur le nœud de méthode:
```
const { Buffer } = require('buffer');
const length = Buffer.byteLength(string, 'utf-8');
```
InformationsquelleAutor laurent

Ici est un organisme indépendant et efficace méthode pour compter les octets UTF-8 d'une chaîne.

JS:

//count UTF-8 bytes of a string
function byteLengthOf(s){
	//assuming the String is UCS-2(aka UTF-16) encoded
	var n=0;
	for(var i=0,l=s.length; i<l; i++){
		var hi=s.charCodeAt(i);
		if(hi<0x0080){ //[0x0000, 0x007F]
			n+=1;
		}else if(hi<0x0800){ //[0x0080, 0x07FF]
			n+=2;
		}else if(hi<0xD800){ //[0x0800, 0xD7FF]
			n+=3;
		}else if(hi<0xDC00){ //[0xD800, 0xDBFF]
			var lo=s.charCodeAt(++i);
			if(i<l&&lo>=0xDC00&&lo<=0xDFFF){ //followed by [0xDC00, 0xDFFF]
				n+=4;
			}else{
				throw new Error("UCS-2 String malformed");
			}
		}else if(hi<0xE000){ //[0xDC00, 0xDFFF]
			throw new Error("UCS-2 String malformed");
		}else{ //[0xE000, 0xFFFF]
			n+=3;
		}
	}
	return n;
}

var s="\u0000\u007F\u07FF\uD7FF\uDBFF\uDFFF\uFFFF";
console.log("expect byteLengthOf(s) to be 14, actually it is %s.",byteLengthOf(s));

Note que la méthode peut lancer d'erreur si une chaîne d'entrée est UCS-2 malformé

InformationsquelleAutor fuweichin

2

En NodeJS, de la mémoire Tampon.byteLength est une méthode spécialement à cette fin:
```
let strLengthInBytes = Buffer.byteLength(str); //str is UTF-8
```
Notez que par défaut, la méthode suppose que la chaîne est en UTF-8. Si un codage différent est requis, le passe comme deuxième argument.
- Est-il possible de calculer strLengthInBytes juste en sachant le compte de caractères dans la chaîne? ie var text = "Hello World!; var text_length = text.length; // pass text_length as argument to some method?. Et, juste pour la référence, re Buffer - je suis tombé sur cette réponse qui traite de new Blob(['test string']).size et, dans le nœud, Buffer.from('test string').length. Peut-être que cela aidera certaines personnes trop?
- Le problème, c'est le nombre de caractères n'est pas toujours égal au nombre d'octets. Par exemple, la commune de codage UTF-8 est d'une largeur variable de codage, dans lequel un seul caractère peut être de 1 octet 4 octets la taille. C'est pourquoi une méthode particulière est nécessaire ainsi que l'encodage utilisé.
InformationsquelleAutor Boaz

Ce serait travailler pour BMP et SIP/SMP caractères.

    String.prototype.lengthInUtf8 = function() {
        var asciiLength = this.match(/[\u0000-\u007f]/g) ? this.match(/[\u0000-\u007f]/g).length : 0;
        var multiByteLength = encodeURI(this.replace(/[\u0000-\u007f]/g)).match(/%/g) ? encodeURI(this.replace(/[\u0000-\u007f]/g, '')).match(/%/g).length : 0;
        return asciiLength + multiByteLength;
    }

    'test'.lengthInUtf8();
    //returns 4
    '\u{2f894}'.lengthInUtf8();
    //returns 4
    'سلام علیکم'.lengthInUtf8();
    //returns 19, each Arabic/Persian alphabet character takes 2 bytes. 
    '你好，JavaScript 世界'.lengthInUtf8();
    //returns 26, each Chinese character/punctuation takes 3 bytes.

InformationsquelleAutor chrislau

0

Vous pouvez essayer ceci:
```
function getLengthInBytes(str) {
  var b = str.match(/[^\x00-\xff]/g);
  return (str.length + (!b ? 0: b.length)); 
}
```
Cela fonctionne pour moi.
- retourne 1, "â" dans chrome
- le premier problème pourrait être résolu en changeant \xff à \x7f, mais cela ne résout pas le fait que codepoints entre 0 x 800-0xFFFF sera signalé que la prise de 2 octets, quand ils prennent 3.
InformationsquelleAutor anh tran

Vous devez vous connecter pour publier un commentaire.