Quanti byte in una stringa JavaScript?

Ho una stringa javascript che è di circa 500K quando viene inviata dal server in UTF-8. Come posso dire la sua dimensione in JavaScript?

So che JavaScript utilizza UCS-2, quindi significa 2 byte per carattere. Tuttavia, dipende dall'implementazione di JavaScript? O sulla codifica della pagina o forse sul tipo di contenuto?

Stringi valori non dipendono dall'implementazione, secondo la specifica ECMA-262 3a edizione , ogni carattere rappresenta una singola unità a 16 bit di testo UTF-16 :

4.3.16 Valore stringa

Un valore stringa è un membro del tipo String ed è una sequenza ordinata finita di zero o più valori interi senza segno a 16 bit.

NOTA Sebbene ogni valore in genere rappresenti una singola unità di testo UTF-16 a 16 bit, la lingua non pone alcuna restrizione o requisito sui valori tranne che sono numeri interi senza segno a 16 bit.

Questa funzione restituirà la dimensione in byte di qualsiasi stringa UTF-8 che le passi.

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

fonte

I motori JavaScript sono liberi di utilizzare internamente UCS-2 o UTF-16. La maggior parte dei motori che conosco utilizza UTF-16, ma qualunque scelta abbiano fatto, è solo un dettaglio di implementazione che non influirà sulle caratteristiche del linguaggio.

Il linguaggio ECMAScript / JavaScript stesso, tuttavia, espone i caratteri secondo UCS-2, non UTF-16.

fonte

Se stai usando node.js, c'è una soluzione più semplice usando i buffer :

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

C'è una libreria npm per questo: https://www.npmjs.org/package/utf8-binary-cutter (dalla tua fedelmente)

È possibile utilizzare il BLOB per ottenere la dimensione della stringa in byte.

Esempi:

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

Prova questa combinazione con l'utilizzo della funzione js di unescape :

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

Esempio di processo di codifica completo:

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

Tieni presente che se scegli come target node.js puoi utilizzare Buffer.from(string).length:

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

UTF-8 codifica i caratteri utilizzando da 1 a 4 byte per punto di codice. Come CMS ha sottolineato nella risposta accettata, JavaScript memorizzerà ogni carattere internamente utilizzando 16 bit (2 byte).

Se analizzi ogni carattere nella stringa tramite un ciclo e conti il ​​numero di byte utilizzati per punto di codice, quindi moltiplichi il conteggio totale per 2, dovresti avere l'utilizzo della memoria di JavaScript in byte per quella stringa con codifica UTF-8. Forse qualcosa del genere:

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

Esempi:

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

Questi sono 3 modi in cui uso:

1. TextEncoder ()

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

2. Blob

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

3. Buffer

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

La dimensione di una stringa JavaScript è

• Pre-ES6 : 2 byte per carattere
• ES6 e versioni successive: 2 byte per carattere o 5 o più byte per carattere
  
  

Pre-ES6
Sempre 2 byte per carattere. UTF-16 non è consentito perché la specifica dice "i valori devono essere interi senza segno a 16 bit". Poiché le stringhe UTF-16 possono utilizzare caratteri a 3 o 4 byte, violerebbe il requisito di 2 byte. Fondamentalmente, mentre UTF-16 non può essere completamente supportato, lo standard richiede che i due caratteri byte utilizzati siano caratteri UTF-16 validi. In altre parole, le stringhe JavaScript pre-ES6 supportano un sottoinsieme di caratteri UTF-16.

ES6 e versioni successive
2 byte per carattere o 5 o più byte per carattere. Le dimensioni aggiuntive entrano in gioco perché ES6 (ECMAScript 6) aggiunge il supporto per gli escape del punto di codice Unicode . L'utilizzo di un'escape Unicode ha questo aspetto: \ u {1D306}

Note pratiche

• Questo non si riferisce all'implementazione interna di un particolare motore. Ad esempio, alcuni motori utilizzano strutture di dati e librerie con supporto completo UTF-16, ma ciò che forniscono esternamente non deve essere necessariamente un supporto completo UTF-16. Inoltre un motore può fornire anche il supporto UTF-16 esterno, ma non è obbligato a farlo.

• Per ES6, praticamente i caratteri non saranno mai più lunghi di 5 byte (2 byte per il punto di fuga + 3 byte per il punto di codice Unicode) perché l'ultima versione di Unicode ha solo 136.755 caratteri possibili, che si adattano facilmente a 3 byte. Tuttavia questo tecnicamente non è limitato dallo standard, quindi in linea di principio un singolo carattere potrebbe utilizzare, ad esempio, 4 byte per il punto di codice e 6 byte in totale.

• La maggior parte degli esempi di codice qui per il calcolo della dimensione in byte non sembrano prendere in considerazione gli escape del punto di codice Unicode ES6, quindi i risultati potrebbero essere errati in alcuni casi.

Un singolo elemento in una stringa JavaScript è considerato una singola unità di codice UTF-16. Vale a dire, i caratteri delle stringhe vengono memorizzati a 16 bit (1 unità di codice) e 16 bit è uguale a 2 byte (8 bit = 1 byte).

Il charCodeAt()metodo può essere utilizzato per restituire un numero intero compreso tra 0 e 65535 che rappresenta l'unità di codice UTF-16 all'indice specificato.

La codePointAt()può essere utilizzato per restituire l'intero punto di codifica per i caratteri Unicode, ad esempio UTF-32.

Quando un carattere UTF-16 non può essere rappresentato in una singola unità di codice a 16 bit, avrà una coppia surrogata e quindi utilizzerà due unità di codice (2 x 16 bit = 4 byte)

Consulta Codifiche Unicode per diverse codifiche e relativi intervalli di codice.

La risposta di Lauri Oherd funziona bene per la maggior parte delle stringhe viste in natura, ma fallirà se la stringa contiene caratteri solitari nell'intervallo di coppie surrogate, da 0xD800 a 0xDFFF. Per esempio

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

Questa funzione più lunga dovrebbe gestire tutte le stringhe:

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

Per esempio

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

Calcolerà correttamente la dimensione per le stringhe contenenti coppie surrogate:

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

I risultati possono essere confrontati con la funzione incorporata di Node Buffer.byteLength:

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

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

Sto lavorando con una versione incorporata del motore V8. Ho testato una singola stringa. Spingendo ogni passo 1000 caratteri. UTF-8.

Primo test con carattere "A" a byte singolo (8 bit, ANSI) (esadecimale: 41). Secondo test con carattere a due byte (16 bit) "Ω" (hex: CE A9) e terzo test con carattere a tre byte (24 bit) "☺" (hex: E2 98 BA).

In tutti e tre i casi il dispositivo stampa la memoria esaurita a 888 000 caratteri e utilizzando ca. 26348 kb di RAM.

Risultato: i caratteri non vengono archiviati dinamicamente. E non con solo 16 bit. - Ok, forse solo per il mio caso (Embedded 128 MB RAM Device, V8 Engine C ++ / QT) - La codifica dei caratteri non ha nulla a che fare con la dimensione in ram del motore javascript. Ad esempio encodingURI, ecc. È utile solo per la trasmissione e l'archiviazione di dati di alto livello.

Incorporato o no, il fatto è che i caratteri non sono solo memorizzati a 16 bit. Sfortunatamente non ho una risposta al 100%, cosa fa Javascript nell'area di basso livello. Btw. Ho provato lo stesso (primo test sopra) con un array di caratteri "A". Hai spinto 1000 elementi ogni passo. (Esattamente lo stesso test. Ho appena sostituito la stringa nell'array) E il sistema ha esaurito la memoria (richiesta) dopo 10 416 KB utilizzando e una lunghezza dell'array di 1 337 000. Quindi, il motore javascript non è limitato. È un tipo più complesso.

Puoi provare questo:

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

Ha funzionato per me.