Wie viele Bytes enthält eine JavaScript-Zeichenfolge?

Ich habe eine Javascript-Zeichenfolge, die ungefähr 500 KB groß ist, wenn sie vom Server in UTF-8 gesendet wird. Wie kann ich die Größe in JavaScript bestimmen?

Ich weiß, dass JavaScript UCS-2 verwendet, das bedeutet also 2 Bytes pro Zeichen. Hängt es jedoch von der JavaScript-Implementierung ab? Oder auf der Seite Kodierung oder vielleicht Inhaltstyp?

StringDie Werte sind nicht implementierungsabhängig. Gemäß der ECMA-262 3rd Edition-Spezifikation repräsentiert jedes Zeichen eine einzelne 16-Bit-Einheit des UTF-16-Textes :

4.3.16 Zeichenfolgenwert

Ein Zeichenfolgenwert ist ein Mitglied vom Typ Zeichenfolge und eine endlich geordnete Folge von null oder mehr 16-Bit-Ganzzahlwerten ohne Vorzeichen.

HINWEIS Obwohl jeder Wert normalerweise eine einzelne 16-Bit-Einheit von UTF-16-Text darstellt, stellt die Sprache keine Einschränkungen oder Anforderungen an die Werte, außer dass es sich um 16-Bit-Ganzzahlen ohne Vorzeichen handelt.

Diese Funktion gibt die Bytegröße aller UTF-8-Zeichenfolgen zurück, die Sie an sie übergeben.

function byteCount(s) {
    return encodeURI(s).split(/%..|./).length - 1;
}

Quelle

JavaScript-Engines können UCS-2 oder UTF-16 intern verwenden. Die meisten mir bekannten Engines verwenden UTF-16, aber was auch immer sie gewählt haben, es ist nur ein Implementierungsdetail, das die Eigenschaften der Sprache nicht beeinflusst.

Die ECMAScript / JavaScript-Sprache selbst macht jedoch Zeichen gemäß UCS-2 und nicht UTF-16 verfügbar.

Quelle

Wenn Sie node.js verwenden, gibt es eine einfachere Lösung mit Puffern :

function getBinarySize(string) {
    return Buffer.byteLength(string, 'utf8');
}

Dafür gibt es eine npm lib: https://www.npmjs.org/package/utf8-binary-cutter (von Ihnen treu)

Sie können den Blob verwenden , um die Zeichenfolgengröße in Bytes abzurufen.

Beispiele:

console.info(
  new Blob(['😂']).size,                             // 4
  new Blob(['👍']).size,                             // 4
  new Blob(['😂👍']).size,                           // 8
  new Blob(['👍😂']).size,                           // 8
  new Blob(['I\'m a string']).size,                  // 12

  // from Premasagar correction of Lauri's answer for
  // strings containing lone characters in the surrogate pair range:
  // https://stackoverflow.com/a/39488643/6225838
  new Blob([String.fromCharCode(55555)]).size,       // 3
  new Blob([String.fromCharCode(55555, 57000)]).size // 4 (not 6)
);

Versuchen Sie diese Kombination mit der Funktion unescape js:

const byteAmount = unescape(encodeURIComponent(yourString)).length

Beispiel für einen vollständigen Codierungsprozess:

const s  = "1 a ф № @ ®"; //length is 11
const s2 = encodeURIComponent(s); //length is 41
const s3 = unescape(s2); //length is 15 [1-1,a-1,ф-2,№-3,@-1,®-2]
const s4 = escape(s3); //length is 39
const s5 = decodeURIComponent(s4); //length is 11

Beachten Sie, dass Sie Folgendes verwenden können, wenn Sie auf node.js abzielen Buffer.from(string).length:

var str = "\u2620"; // => "☠"
str.length; // => 1 (character)
Buffer.from(str).length // => 3 (bytes)

UTF-8 codiert Zeichen mit 1 bis 4 Bytes pro Codepunkt. Wie CMS in der akzeptierten Antwort hervorhob, speichert JavaScript jedes Zeichen intern mit 16 Bit (2 Byte).

Wenn Sie jedes Zeichen in der Zeichenfolge über eine Schleife analysieren und die Anzahl der pro Codepunkt verwendeten Bytes zählen und dann die Gesamtzahl mit 2 multiplizieren, sollte die Speichernutzung von JavaScript in Bytes für diese UTF-8-codierte Zeichenfolge angegeben werden. Vielleicht so etwas:

      getStringMemorySize = function( _string ) {
        "use strict";

        var codePoint
            , accum = 0
        ;

        for( var stringIndex = 0, endOfString = _string.length; stringIndex < endOfString; stringIndex++ ) {
            codePoint = _string.charCodeAt( stringIndex );

            if( codePoint < 0x100 ) {
                accum += 1;
                continue;
            }

            if( codePoint < 0x10000 ) {
                accum += 2;
                continue;
            }

            if( codePoint < 0x1000000 ) {
                accum += 3;
            } else {
                accum += 4;
            }
        }

        return accum * 2;
    }

Beispiele:

getStringMemorySize( 'I'    );     //  2
getStringMemorySize( '❤'    );     //  4
getStringMemorySize( '𠀰'   );     //  8
getStringMemorySize( 'I❤𠀰' );     // 14

Dies sind 3 Möglichkeiten, die ich benutze:

1. TextEncoder ()

   (new TextEncoder().encode("myString")).length)

2. Klecks

   new Blob(["myString"]).size)

3. Puffer

   Buffer.byteLength("myString", 'utf8'))

Die Antwort von Lauri Oherd funktioniert gut für die meisten in freier Wildbahn gesehenen Zeichenfolgen, schlägt jedoch fehl, wenn die Zeichenfolge einzelne Zeichen im Bereich der Ersatzpaare 0xD800 bis 0xDFFF enthält. Z.B

byteCount(String.fromCharCode(55555))
// URIError: URI malformed

Diese längere Funktion sollte alle Zeichenfolgen verarbeiten:

function bytes (str) {
  var bytes=0, len=str.length, codePoint, next, i;

  for (i=0; i < len; i++) {
    codePoint = str.charCodeAt(i);

    // Lone surrogates cannot be passed to encodeURI
    if (codePoint >= 0xD800 && codePoint < 0xE000) {
      if (codePoint < 0xDC00 && i + 1 < len) {
        next = str.charCodeAt(i + 1);

        if (next >= 0xDC00 && next < 0xE000) {
          bytes += 4;
          i++;
          continue;
        }
      }
    }

    bytes += (codePoint < 0x80 ? 1 : (codePoint < 0x800 ? 2 : 3));
  }

  return bytes;
}

Z.B

bytes(String.fromCharCode(55555))
// 3

Die Größe für Zeichenfolgen mit Ersatzpaaren wird korrekt berechnet:

bytes(String.fromCharCode(55555, 57000))
// 4 (not 6)

Die Ergebnisse können mit der integrierten Funktion von Node verglichen werden Buffer.byteLength:

Buffer.byteLength(String.fromCharCode(55555), 'utf8')
// 3

Buffer.byteLength(String.fromCharCode(55555, 57000), 'utf8')
// 4 (not 6)

Die Größe einer JavaScript-Zeichenfolge beträgt

• Pre-ES6 : 2 Bytes pro Zeichen
• ES6 und höher: 2 Bytes pro Zeichen oder 5 oder mehr Bytes pro Zeichen
  
  

Pre-ES6
Immer 2 Bytes pro Zeichen. UTF-16 ist nicht zulässig, da in der Spezifikation angegeben ist, dass "Werte vorzeichenlose 16-Bit-Ganzzahlen sein müssen". Da UTF-16-Zeichenfolgen 3- oder 4-Byte-Zeichen verwenden können, würde dies die 2-Byte-Anforderung verletzen. Entscheidend ist, dass UTF-16 zwar nicht vollständig unterstützt werden kann, der Standard jedoch vorschreibt, dass die beiden verwendeten Bytezeichen gültige UTF-16-Zeichen sind. Mit anderen Worten, JavaScript-Zeichenfolgen vor ES6 unterstützen eine Teilmenge von UTF-16-Zeichen.

ES6 und höher
2 Bytes pro Zeichen oder 5 oder mehr Bytes pro Zeichen. Die zusätzlichen Größen kommen ins Spiel, da ES6 (ECMAScript 6) die Unterstützung für Unicode-Codepunkt- Escapezeichen hinzufügt . Die Verwendung eines Unicode-Escape sieht folgendermaßen aus: \ u {1D306}

Praktische Hinweise

• Dies bezieht sich nicht auf die interne Implementierung eines bestimmten Motors. Beispielsweise verwenden einige Engines Datenstrukturen und Bibliotheken mit vollständiger UTF-16-Unterstützung, aber was sie extern bereitstellen, muss nicht vollständige UTF-16-Unterstützung sein. Ein Motor kann auch externe UTF-16-Unterstützung bieten, ist jedoch nicht dazu verpflichtet.

• Für ES6 werden praktisch keine Zeichen länger als 5 Byte sein (2 Byte für den Escape-Punkt + 3 Byte für den Unicode-Codepunkt), da die neueste Version von Unicode nur 136.755 mögliche Zeichen enthält, was problemlos in 3 Byte passt. Dies ist jedoch technisch nicht durch den Standard beschränkt, so dass im Prinzip ein einzelnes Zeichen beispielsweise 4 Bytes für den Codepunkt und 6 Bytes insgesamt verwenden könnte.

• Die meisten Codebeispiele hier zur Berechnung der Bytegröße scheinen ES6-Unicode-Codepunkt-Escapezeichen nicht zu berücksichtigen, sodass die Ergebnisse in einigen Fällen falsch sein können.

Ich arbeite mit einer eingebetteten Version der V8-Engine. Ich habe eine einzelne Zeichenfolge getestet. Drücken Sie jeden Schritt 1000 Zeichen. UTF-8.

Erster Test mit Einzelbyte (8 Bit, ANSI) Zeichen "A" (hex: 41). Zweiter Test mit zwei Byte (16 Bit) "Ω" (hex: CE A9) und der dritte Test mit drei Byte (24 Bit) "☺" (hex: E2 98 BA).

In allen drei Fällen druckt das Gerät mit 888 000 Zeichen und ca. 26 348 kb im RAM.

Ergebnis: Die Zeichen werden nicht dynamisch gespeichert. Und nicht nur mit 16bit. - Ok, vielleicht nur für meinen Fall (Embedded 128 MB RAM-Gerät, V8 Engine C ++ / QT) - Die Zeichencodierung hat nichts mit der RAM-Größe der Javascript-Engine zu tun. Beispielsweise ist die Codierung von UUR usw. nur für die Übertragung und Speicherung von Daten auf hoher Ebene nützlich.

Eingebettet oder nicht, Tatsache ist, dass die Zeichen nicht nur in 16 Bit gespeichert sind. Leider habe ich keine 100% ige Antwort, was Javascript auf niedriger Ebene macht. Übrigens. Ich habe das gleiche (erster Test oben) mit einem Array von Zeichen "A" getestet. Schob 1000 Gegenstände pro Schritt. (Genau der gleiche Test. Nur String in Array ersetzt) ​​Und das System bringt nach 10 416 KB mit einer Array-Länge von 1 337 000 nicht mehr genügend Speicher (gewünscht). Die Javascript-Engine ist also nicht einfach eingeschränkt. Es ist etwas komplexer.

Ein einzelnes Element in einer JavaScript-Zeichenfolge wird als einzelne UTF-16-Codeeinheit betrachtet. Das heißt, Zeichenfolgenzeichen werden in 16 Bit (1 Codeeinheit) gespeichert, und 16 Bit entspricht 2 Bytes (8 Bit = 1 Byte).

Die charCodeAt()Methode kann verwendet werden, um eine Ganzzahl zwischen 0 und 65535 zurückzugeben, die die UTF-16-Codeeinheit am angegebenen Index darstellt.

Mit codePointAt()kann der gesamte Codepunktwert für Unicode-Zeichen zurückgegeben werden, z. B. UTF-32.

Wenn ein UTF-16-Zeichen nicht in einer einzelnen 16-Bit-Codeeinheit dargestellt werden kann, hat es ein Ersatzpaar und verwendet daher zwei Codeeinheiten (2 x 16-Bit = 4 Byte).

Unter Unicode-Codierungen finden Sie verschiedene Codierungen und ihre Codebereiche.

Sie können dies versuchen:

  var b = str.match(/[^\x00-\xff]/g);
  return (str.length + (!b ? 0: b.length)); 

Es hat bei mir funktioniert.