Скільки байтів у рядку JavaScript?

У мене є рядок javascript, який становить близько 500 тис. При надсиланні з сервера в UTF-8. Як я можу визначити його розмір у JavaScript?

Я знаю, що JavaScript використовує UCS-2, тож це означає 2 байти на символ. Однак чи залежить це від реалізації JavaScript? Або на кодуванні сторінки чи, можливо, типу вмісту?

Stringзначення не залежать від реалізації, згідно специфікації ECMA-262 3rd Edition , кожен символ представляє одну 16-бітову одиницю тексту UTF-16 :

4.3.16 Значення рядка

Значення рядка є членом типу String і є скінченною впорядкованою послідовністю з нуля або більше 16-розрядних цілих беззнакових значень.

ПРИМІТКА Хоча кожне значення зазвичай представляє одну 16-бітову одиницю тексту UTF-16, мова не встановлює жодних обмежень чи вимог до значень, за винятком того, що це 16-бітові цілі числа без знака.

Ця функція поверне розмір байта будь-якого рядка UTF-8, який ви йому передасте.

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

Джерело

Двигуни JavaScript можуть безкоштовно використовувати UCS-2 або UTF-16 всередині. Більшість двигунів, які я знаю, використовують UTF-16, але який би вибір вони не зробили, це лише деталь реалізації, яка не вплине на характеристики мови.

Однак сама мова ECMAScript / JavaScript надає символи відповідно до UCS-2, а не UTF-16.

Джерело

Якщо ви використовуєте node.js, існує простіше рішення з використанням буферів :

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

Для цього існує бібліотека npm: https://www.npmjs.org/package/utf8-binary-cutter (з повагою)

Ви можете використовувати Blob, щоб отримати розмір рядка в байтах.

Приклади:

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

Спробуйте цю комбінацію за допомогою функції unescape js:

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

Приклад процесу повного кодування:

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

Зверніть увагу, що якщо ви націлюєтесь на node.js, ви можете використовувати Buffer.from(string).length:

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

UTF-8 кодує символи, використовуючи від 1 до 4 байтів на кодову точку. Як зазначила CMS у прийнятій відповіді, JavaScript буде зберігати кожен символ внутрішньо, використовуючи 16 бітів (2 байти).

Якщо ви проаналізуєте кожен символ у рядку за допомогою циклу і підрахуєте кількість байтів, що використовуються для кожної точки коду, а потім помножите загальний підрахунок на 2, ви повинні використовувати пам'ять JavaScript у байтах для цього кодованого рядка UTF-8. Можливо, щось подібне:

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

Приклади:

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

Це 3 способи, якими я користуюся:

1. TextEncoder ()

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

2. Крапля

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

3. Буфер

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

Розмір рядка JavaScript становить

• Pre-ES6 : 2 байти на символ
• ES6 та новіші версії: 2 байти на символ або 5 або більше байт на символ
  
  

Pre-ES6
Завжди 2 байти на символ. UTF-16 заборонено, оскільки в специфікації сказано, що "значення мають бути 16-бітовими цілими беззнаковими". Оскільки рядки UTF-16 можуть використовувати 3 або 4 байтові символи, це порушить вимогу до 2 байт. Що важливо, хоча UTF-16 не може бути повністю підтриманий, стандарт вимагає, щоб використовувані два байтові символи були дійсними символами UTF-16. Іншими словами, рядки JavaScript Pre-ES6 підтримують підмножину символів UTF-16.

ES6 і пізніші
2 байти на символ, або 5 або більше байт на символ. Додаткові розміри вступають у дію, оскільки ES6 (ECMAScript 6) додає підтримку екранування кодової точки Unicode . Використання екранованого коду Unicode виглядає так: \ u {1D306}

Практичні примітки

• Це не стосується внутрішньої реалізації конкретного двигуна. Наприклад, деякі механізми використовують структури даних і бібліотеки з повною підтримкою UTF-16, але те, що вони надають зовні, не обов’язково має бути повною підтримкою UTF-16. Також двигун може також надавати зовнішню підтримку UTF-16, але це не передбачено.

• Для ES6 практично розмовні символи ніколи не матимуть довжини більше 5 байт (2 байти для точки виходу + 3 байти для кодової точки Unicode), оскільки остання версія Unicode має лише 136 755 можливих символів, які легко поміщаються в 3 байти. Однак це технічно не обмежується стандартом, тому в основному один символ може використовувати скажімо, 4 байти для кодової точки та 6 байт загалом.

• Більшість прикладів коду для розрахунку розміру байтів, здається, не враховують екранні коди ES6 Unicode, тому результати можуть бути неправильними в деяких випадках.

Окремий елемент у рядку JavaScript вважається єдиною кодовою одиницею UTF-16. Тобто символи рядків зберігаються у 16-бітах (1 кодова одиниця), а 16-біт дорівнює 2 байтам (8-біт = 1 байт).

charCodeAt()Метод може бути використаний , щоб повертати ціле число в діапазоні від 0 до 65535 , що становить коду блоку UTF-16 з даного індексу.

codePointAt()Може бути використано , щоб повернути все значення точки коди для символів Unicode, наприклад UTF-32.

Коли символ UTF-16 не може бути представлений в одній 16-бітовій кодовій одиниці, він матиме сурогатну пару і, отже, використовуватиме дві одиниці коду (2 х 16-бітних = 4 байти)

Див. Кодування Unicode щодо різних кодувань та їх діапазонів кодів.

Відповідь від Lauri Oherd добре працює для більшості рядків, що спостерігаються в природі, але не вдасться, якщо рядок містить одинакові символи в діапазоні сурогатних пар, 0xD800 до 0xDFFF. Напр

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

Ця довша функція повинна обробляти всі рядки:

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

Напр

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

Він правильно розрахує розмір для рядків, що містять сурогатні пари:

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

Результати можна порівняти із вбудованою функцією Node Buffer.byteLength:

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

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

Я працюю із вбудованою версією V8 Engine. Я протестував один рядок. Натискання кожного кроку 1000 символів. UTF-8.

Перший тест з однобайтовим (8-бітним, ANSI) символом "A" (шістнадцятковий: 41). Другий тест із двобайтовим символом (16 біт) "Ω" (шістнадцятковий: CE A9) і третій тест із трибайтовим символом (24 біт) "☺" (шістнадцятковий: E2 98 BA).

У всіх трьох випадках пристрій друкує з пам'яті на 888 000 символів із використанням ca. 26 348 кб в оперативній пам'яті.

Результат: символи не зберігаються динамічно. І не лише з 16 бітами. - Гаразд, можливо, лише для мого випадку (вбудований пристрій оперативної пам'яті 128 Мб, движок V8 C ++ / QT) - Кодування символів не має нічого спільного з розміром оперативної пам'яті механізму javascript. Наприклад, кодуванняURI тощо корисно лише для високорівневої передачі та зберігання даних.

Вбудовано чи ні, факт полягає в тому, що символи зберігаються не тільки в 16-бітній. На жаль, я не маю 100% відповіді, що Javascript робить на низькому рівні. До речі. Я тестував те саме (перший тест вище) з масивом символів "А". Кожен крок штовхав 1000 предметів. (Точно такий же тест. Просто замінено рядок на масив) І система виводить пам’ять (потрібна) після 10 416 КБ з використанням і довжиною масиву 1 337 000. Отже, механізм javascript не є простим обмеженням. Це набагато складніше.

Ви можете спробувати це:

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

У мене це спрацювало.