Có bao nhiêu byte trong một chuỗi JavaScript?

Tôi có một chuỗi javascript khoảng 500K khi được gửi từ máy chủ trong UTF-8. Làm cách nào để biết kích thước của nó trong JavaScript?

Tôi biết rằng JavaScript sử dụng UCS-2, điều đó có nghĩa là 2 byte cho mỗi ký tự. Tuy nhiên, nó có phụ thuộc vào việc triển khai JavaScript không? Hoặc trên mã hóa trang hoặc có thể là loại nội dung?

Stringcác giá trị không phụ thuộc vào việc triển khai, theo Thông số kỹ thuật của ECMA-262 phiên bản thứ 3 , mỗi ký tự đại diện cho một đơn vị 16 bit của văn bản UTF-16 :

4.3.16 Giá trị chuỗi

Giá trị chuỗi là thành viên của kiểu Chuỗi và là một chuỗi có thứ tự hữu hạn gồm 0 hoặc nhiều giá trị số nguyên 16 bit không dấu.

CHÚ THÍCH: Mặc dù mỗi giá trị thường đại diện cho một đơn vị 16 bit duy nhất của văn bản UTF-16, ngôn ngữ này không đặt ra bất kỳ hạn chế hoặc yêu cầu nào đối với các giá trị ngoại trừ việc chúng là số nguyên 16 bit không dấu.

Hàm này sẽ trả về kích thước byte của bất kỳ chuỗi UTF-8 nào mà bạn chuyển cho nó.

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

Nguồn

Các công cụ JavaScript được miễn phí sử dụng nội bộ UCS-2 hoặc UTF-16. Hầu hết các công cụ mà tôi biết đều sử dụng UTF-16, nhưng bất cứ lựa chọn nào họ đưa ra, đó chỉ là một chi tiết triển khai sẽ không ảnh hưởng đến các đặc tính của ngôn ngữ.

Tuy nhiên, bản thân ngôn ngữ ECMAScript / JavaScript hiển thị các ký tự theo UCS-2, không phải UTF-16.

Nguồn

Nếu bạn đang sử dụng node.js, có một giải pháp đơn giản hơn là sử dụng bộ đệm :

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

Có một lib npm cho điều đó: https://www.npmjs.org/package/utf8-binary-cutter (từ của bạn một cách trung thực)

Bạn có thể sử dụng Blob để lấy kích thước chuỗi tính bằng byte.

Ví dụ:

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

Hãy thử kết hợp này với việc sử dụng hàm js unescape :

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

Ví dụ về quy trình mã hóa đầy đủ:

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

Lưu ý rằng nếu bạn đang nhắm mục tiêu node.js, bạn có thể sử dụng Buffer.from(string).length:

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

UTF-8 mã hóa các ký tự bằng cách sử dụng 1 đến 4 byte cho mỗi điểm mã. Như CMS đã chỉ ra trong câu trả lời được chấp nhận, JavaScript sẽ lưu trữ nội bộ mỗi ký tự bằng cách sử dụng 16 bit (2 byte).

Nếu bạn phân tích cú pháp từng ký tự trong chuỗi qua một vòng lặp và đếm số byte được sử dụng trên mỗi điểm mã, sau đó nhân tổng số với 2, bạn sẽ sử dụng bộ nhớ của JavaScript theo byte cho chuỗi được mã hóa UTF-8 đó. Có lẽ một cái gì đó như thế này:

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

Ví dụ:

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

Đây là 3 cách tôi sử dụng:

1. TextEncoder ()

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

2. Bãi

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

3. Đệm

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

Kích thước của một chuỗi JavaScript là

• Pre-ES6 : 2 byte mỗi ký tự
• ES6 trở lên: 2 byte cho mỗi ký tự, hoặc 5 byte trở lên cho mỗi ký tự
  
  

Pre-ES6
Luôn là 2 byte cho mỗi ký tự. UTF-16 không được phép vì thông số cho biết "giá trị phải là số nguyên không dấu 16 bit". Vì chuỗi UTF-16 có thể sử dụng ký tự 3 hoặc 4 byte, nó sẽ vi phạm yêu cầu 2 byte. Điều quan trọng, mặc dù UTF-16 không thể được hỗ trợ đầy đủ, nhưng tiêu chuẩn yêu cầu hai ký tự byte được sử dụng là ký tự UTF-16 hợp lệ. Nói cách khác, các chuỗi JavaScript Pre-ES6 hỗ trợ một tập hợp con các ký tự UTF-16.

ES6 trở lên
2 byte cho mỗi ký tự hoặc 5 byte trở lên cho mỗi ký tự. Các kích thước bổ sung có tác dụng vì ES6 (ECMAScript 6) bổ sung hỗ trợ cho việc thoát điểm mã Unicode . Sử dụng lối thoát unicode trông giống như sau: \ u {1D306}

Ghi chú thực tế

• Điều này không liên quan đến việc triển khai bên trong của một công cụ cụ thể. Ví dụ: một số công cụ sử dụng cấu trúc dữ liệu và thư viện với hỗ trợ UTF-16 đầy đủ, nhưng những gì chúng cung cấp bên ngoài không nhất thiết phải là hỗ trợ UTF-16 đầy đủ. Ngoài ra, một động cơ cũng có thể cung cấp hỗ trợ UTF-16 bên ngoài nhưng không bắt buộc phải làm như vậy.

• Đối với ES6, các ký tự nói trên thực tế sẽ không bao giờ dài quá 5 byte (2 byte cho điểm thoát + 3 byte cho điểm mã Unicode) vì phiên bản mới nhất của Unicode chỉ có 136.755 ký tự khả thi, dễ dàng vừa với 3 byte. Tuy nhiên, về mặt kỹ thuật điều này không bị giới hạn bởi tiêu chuẩn nên về cơ bản, một ký tự đơn lẻ có thể sử dụng, nói là 4 byte cho điểm mã và tổng cộng 6 byte.

• Hầu hết các ví dụ mã ở đây để tính toán kích thước byte dường như không tính đến điểm mã Unicode ES6 thoát ra, vì vậy kết quả có thể không chính xác trong một số trường hợp.

Một phần tử trong Chuỗi JavaScript được coi là một đơn vị mã UTF-16 duy nhất. Có nghĩa là, các ký tự chuỗi được lưu trữ trong 16-bit (1 đơn vị mã), và 16-bit tương đương với 2 byte (8-bit = 1 byte).

Các charCodeAt() phương pháp có thể được sử dụng để trả về một số nguyên giữa 0 và 65535 đại diện cho các đơn vị mã UTF-16 tại các chỉ số nhất định.

Các codePointAt() thể được sử dụng để trả về toàn bộ giá trị điểm mã cho các ký tự Unicode, ví dụ: UTF-32.

Khi một ký tự UTF-16 không thể được biểu diễn trong một đơn vị mã 16 bit, nó sẽ có một cặp thay thế và do đó sử dụng hai đơn vị mã (2 x 16-bit = 4 byte)

Xem bảng mã Unicode để biết các bảng mã khác nhau và phạm vi mã của chúng.

Câu trả lời từ Lauri Oherd hoạt động tốt đối với hầu hết các chuỗi được thấy trong tự nhiên, nhưng sẽ không thành công nếu chuỗi chứa các ký tự đơn lẻ trong phạm vi cặp thay thế, 0xD800 đến 0xDFFF. Ví dụ

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

Hàm dài hơn này sẽ xử lý tất cả các chuỗi:

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

Ví dụ

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

Nó sẽ tính toán chính xác kích thước cho các chuỗi chứa các cặp thay thế:

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

Kết quả có thể được so sánh với chức năng tích hợp của Node Buffer.byteLength:

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

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

Tôi đang làm việc với phiên bản nhúng của Động cơ V8. Tôi đã thử nghiệm một chuỗi đơn. Đẩy mỗi bước 1000 ký tự. UTF-8.

Thử nghiệm đầu tiên với byte đơn (8bit, ANSI) Ký tự "A" (hex: 41). Thử nghiệm thứ hai với hai ký tự byte (16bit) "Ω" (hex: CE A9) và thử nghiệm thứ ba với ký tự ba byte (24bit) "☺" (hex: E2 98 BA).

Trong cả ba trường hợp, thiết bị sẽ in ra khỏi bộ nhớ ở 888 000 ký tự và sử dụng ca. 26 348 kb trong RAM.

Kết quả: Các ký tự không được lưu trữ động. Và không chỉ với 16bit. - Ok, có lẽ chỉ đối với trường hợp của tôi (Thiết bị RAM nhúng 128 MB, V8 Engine C ++ / QT) - Việc mã hóa ký tự không liên quan gì đến kích thước ram của công cụ javascript. Ví dụ: mã hóaURI, v.v. chỉ hữu ích cho việc truyền và lưu trữ dữ liệu cấp cao.

Có nhúng hay không, thực tế là các ký tự không chỉ được lưu trữ trong 16bit. Thật không may, tôi không có câu trả lời 100%, Javascript làm gì ở khu vực cấp thấp. Btw. Tôi đã thử nghiệm tương tự (thử nghiệm đầu tiên ở trên) với một mảng ký tự "A". Đẩy 1000 mặt hàng mỗi bước. (Chính xác là cùng một bài kiểm tra. Chỉ cần thay thế chuỗi thành mảng) Và hệ thống sẽ đưa ra khỏi bộ nhớ (muốn) sau 10 416 KB sử dụng và độ dài mảng là 1 337 000. Vì vậy, công cụ javascript không đơn giản bị hạn chế. Nó là một loại phức tạp hơn.

Bạn có thể thử điều này:

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

Nó đã làm việc cho tôi.