Как получить размер объекта JavaScript?


298

Я хочу знать размер, занимаемый объектом JavaScript.

Возьмите следующую функцию:

function Marks(){
  this.maxMarks = 100;
}

function Student(){
  this.firstName = "firstName";
  this.lastName = "lastName";
  this.marks = new Marks();
}

Теперь я создаю экземпляр student:

var stud = new Student();

так что я могу делать такие вещи, как

stud.firstName = "new Firstname";

alert(stud.firstName);

stud.marks.maxMarks = 200;

и т.п.

Теперь studобъект будет занимать некоторый размер в памяти. У него есть некоторые данные и больше объектов.

Как узнать, сколько памяти studзанимает объект? Что-то вроде sizeof()в JavaScript? Было бы действительно здорово, если бы я мог найти это в одном вызове функции, как sizeof(stud).

Я искал в Интернете несколько месяцев - не смог его найти (спросили на нескольких форумах - нет ответов).


41
Есть (возникнет) множество причин, по которым мне нужно найти размер объекта в JavaScript. Я новичок в JavaScript, поэтому я не следую лучшим практикам. Я все еще учу их. Я разработал расширение Firefox, которое, я уверен, использует больше памяти, чем следовало бы. Я работаю над некоторыми способами (надеюсь) уменьшить использование памяти. Я говорю о тысячах экземпляров, много объектов на вкладке, так что память имеет значение! Дело в том, что я хочу знать, действительно ли мои усилия по уменьшению памяти помогают уменьшить память ... и насколько.

1
Если вы создали расширение FF, я бы посоветовал вам изучить язык на более высоком уровне, чем JS, - посмотрите, как это повлияет на сам FF.
Annakata

2
Язык более высокого уровня, чем JS? что бы это было в этом случае?

24
Это не размер, который имеет значение в любом случае. Это то, как вы используете это. PS: какой жеребец!
Томас Эдинг

13
@SpencerRuport. Одна из причин, по которой нужно знать размер объекта, - это приложения с поддержкой html5, которые иногда имеют ограниченный объем памяти (5-10 МБ можно быстро использовать для приложений, интенсивно использующих данные).
Дэвид

Ответы:


182

Я пересмотрел код в моем первоначальном ответе . Я удалил рекурсию и удалил предполагаемые накладные расходы на существование.

function roughSizeOfObject( object ) {

    var objectList = [];
    var stack = [ object ];
    var bytes = 0;

    while ( stack.length ) {
        var value = stack.pop();

        if ( typeof value === 'boolean' ) {
            bytes += 4;
        }
        else if ( typeof value === 'string' ) {
            bytes += value.length * 2;
        }
        else if ( typeof value === 'number' ) {
            bytes += 8;
        }
        else if
        (
            typeof value === 'object'
            && objectList.indexOf( value ) === -1
        )
        {
            objectList.push( value );

            for( var i in value ) {
                stack.push( value[ i ] );
            }
        }
    }
    return bytes;
}

35
Вы также можете подумать о ключах объекта
zupa

8
Любой, кто приземлился здесь в поисках наименьшего типа для целей false / true, кажется, что он не определен / null.
Зупа

3
"よんもじ".lengthэто 4 в Javascript, но вы уверены, что это 8 байтов, как ваш код возвращает его?
syockit

8
Ага. Символы в JavaScript хранятся в соответствии со спецификацией ECMA-262 3rd Edition - bclary.com/2004/11/07/#a-4.3.16
-peter

4
Эта функция не учитывает ссылки, скрытые в замыканиях. Например var a={n:1}; var b={a:function(){return a}}; roughSizeOfObject(b)- здесь bсодержится ссылка на a, но roughSizeOfObject()возвращается 0.
Роман Поминов

118

Google Chrome Heap Profiler позволяет вам контролировать использование памяти объекта.

Вы должны быть в состоянии найти объект в трассировке, что может быть сложно. Если вы прикрепите объект к глобальному окну, его будет легко найти в режиме списка «Containment».

На прикрепленном скриншоте я создал объект «testObj» в окне. Затем я расположился в профилировщике (после создания записи), и он показывает полный размер объекта и все, что в нем находится в «сохраненном размере».

Подробнее о поломках памяти .

Chrome профилировщик

На приведенном выше снимке экрана объект показывает оставшийся размер 60. Я полагаю, что единица измерения - это байты.


13
Этот ответ решил мою проблему вместе с: developers.google.com/chrome-developer-tools/docs/… . Быстрый совет: сделайте быстрый снимок кучи, запустите задачу, которая, как вы подозреваете, просачивается, сделайте новый быстрый снимок кучи и выберите comparisonвид внизу. Это делает очевидным, какие объекты были созданы между двумя снимками.
Джонрид

1
Это, наверное, самое чистое решение.
Лука Стиб

Сравнение, упомянутое @Johnride, теперь является выпадающим меню вверху.
frandroid

Shallow sizeкажется как 40 для обоих { a:"55c2067aee27593c03b7acbe", b:"55c2067aee27593c03b7acbe", c:null, d:undefined }и { c:null, d:undefined }объектов. Это нормально?
17

1
Вы также можете использовать Google Chrome Heap Profiler с узла. Если у вас есть узел v8 или выше, запустите его с помощью node --inspectи в Chrome введите about:inspectв строке URL-адреса и найдите открытие инспектора узлов. Создайте свой объект в CLI узла и затем сделайте снимок кучи.
Грегор

75

Я просто написал это, чтобы решить аналогичную проблему. Это не совсем то, что вы можете искать, то есть не учитывает, как интерпретатор хранит объект.

Но если вы используете V8, это должно дать вам довольно хорошее приближение, так как классные прототипы и скрытые классы поглощают большую часть накладных расходов.

function roughSizeOfObject( object ) {

    var objectList = [];

    var recurse = function( value )
    {
        var bytes = 0;

        if ( typeof value === 'boolean' ) {
            bytes = 4;
        }
        else if ( typeof value === 'string' ) {
            bytes = value.length * 2;
        }
        else if ( typeof value === 'number' ) {
            bytes = 8;
        }
        else if
        (
            typeof value === 'object'
            && objectList.indexOf( value ) === -1
        )
        {
            objectList[ objectList.length ] = value;

            for( i in value ) {
                bytes+= 8; // an assumed existence overhead
                bytes+= recurse( value[i] )
            }
        }

        return bytes;
    }

    return recurse( object );
}

1
@Liangliang Zheng - отличный момент, бесконечный цикл, спасибо. Надеюсь, вы не возражаете, если я немного обновлю его и обновлю после работы (?)
Томас Питер

Я собираюсь протестировать это сегодня вечером с node.js и получить несколько лучших коэффициентов на месте.
Томас-Питер

Строка 'bytes + = recurse (value [i])' выдает ошибку в моей FF 14.01: NS_ERROR_FAILURE: компонент возвратил код ошибки: 0x80004005 (NS_ERROR_FAILURE) [nsIDOMHTMLInputElement.selectionStart]. На одном из моих объектов, если я попробую другой, это не так, возможно, ошибка браузера или код не работает для каждого объекта (тот, который не работает, содержит функции, тот, который работает, не ' t)
TrySpace

1
От одного Тома к другому это стало очень полезным в качестве грубого индикатора того, где мне нужно было обрезать линии талии моего объекта. Итак, ваша миссис узнала о вашем романе с Javascript? Она хозяйка с высокими эксплуатационными расходами.
Том У Холл

4
Мне нужно следить за PHP (глотком) - я давно перестал любить ее, но она оплачивает счета. В любом случае, спасибо Тому, отзывы, которые нравятся, намного лучше, чем очки репутации.
Томас-Питер

55

Иногда я использую это для пометки действительно больших объектов, которые могут отправляться клиенту с сервера. Это не представляет в памяти след. Он просто дает вам приблизительно столько, сколько стоило бы отправить его или сохранить.

Также обратите внимание, это медленно, только для разработчиков Но для получения приблизительного ответа с одной строкой кода это было полезно для меня.

roughObjSize = JSON.stringify(bigObject).length;

2
Из моих тестов этот метод значительно быстрее, чем object-sizeof case, потому что у него нет медленного вызова _.isObject () из lodash. Кроме того, возвращенные размеры довольно сопоставимы для приблизительных оценок. Gist gist.github.com/owenallenaz/ff77fc98081708146495 .
Нуклон


5
Не может использоваться с круговыми структурами VM1409:1 Uncaught TypeError: Converting circular structure to JSON:( все еще полезно, хотя
givanse

это не двоичный размер в байтах, а простой в использовании для получения приблизительного размера
datdinhquoc

Это очень хорошо, если 1) вам нужна только приблизительная оценка 2) вы знаете, что у вас нет циклических ссылок 3) вы можете опускать большие значения и обрабатывать их отдельно. Все это было правдой в моем случае, поэтому работает отлично, у меня была только одна большая строка в одном месте, на которой я могу просто измерить длину.
Оззи

45

Вот несколько более компактное решение проблемы:

const typeSizes = {
  "undefined": () => 0,
  "boolean": () => 4,
  "number": () => 8,
  "string": item => 2 * item.length,
  "object": item => !item ? 0 : Object
    .keys(item)
    .reduce((total, key) => sizeOf(key) + sizeOf(item[key]) + total, 0)
};

const sizeOf = value => typeSizes[typeof value](value);

3
так это размер в килобайтах? или биты?
Винсент Торп

2
@ Винсент-Торп Это в байтах.
Дан

3
Хороший сценарий, требует изменений для циклических ссылок, хотя.
Джим Педид

1
Я только что проверил ваш алгоритм на огромном массиве данных внутри процесса узла, он сообщает о 13 ГБ, но узел потребляет 22 ГБ, есть идеи о том, откуда взялась разница? В памяти больше ничего нет.
Хосу Гони

3
@ JosuGoñi, они не рассчитывают, сколько стоит сам объект, только его стоимость. Все объекты занимают больше места, чем просто их значение, иначе typeof ...не будут работать.
Алексис Уилке

43

Существует модуль NPM, чтобы получить размер объекта , вы можете установить его сnpm install object-sizeof

  var sizeof = require('object-sizeof');

  // 2B per character, 6 chars total => 12B
  console.log(sizeof({abc: 'def'}));

  // 8B for Number => 8B
  console.log(sizeof(12345));

  var param = { 
    'a': 1, 
    'b': 2, 
    'c': {
      'd': 4
    }
  };
  // 4 one two-bytes char strings and 3 eighth-bytes numbers => 32B
  console.log(sizeof(param));

sizeof (new Date ()) === 0 и sizeof ({}) === 0. Это предназначено?
Филипп Классен

1
@ PhilippClaßen Очевидно, это так. Оба объекта не имеют свойств.
Роберт

18

Это хакерский метод, но я попробовал его дважды с разными числами, и он, кажется, соответствует.

Вы можете попытаться выделить огромное количество объектов, например, один или два миллиона объектов того типа, который вам нужен. Поместите объекты в массив, чтобы сборщик мусора не освободил их (обратите внимание, что это приведет к небольшим накладным расходам памяти из-за массива, но я надеюсь, что это не должно иметь значения, кроме того, если вы будете беспокоиться о том, что объекты находятся в памяти храните их где-нибудь). Добавьте предупреждение до и после выделения и в каждом предупреждении проверьте, сколько памяти занимает процесс Firefox. Прежде чем открыть страницу с тестом, убедитесь, что у вас есть свежий экземпляр Firefox. Откройте страницу, обратите внимание на использование памяти после появления предупреждения «до». Закройте оповещение, дождитесь выделения памяти. Вычтите новую память из старой и разделите ее на количество выделенных ресурсов.

function Marks()
{
  this.maxMarks = 100;
}

function Student()
{
  this.firstName = "firstName";
  this.lastName = "lastName";
  this.marks = new Marks();
}

var manyObjects = new Array();
alert('before');
for (var i=0; i<2000000; i++)
    manyObjects[i] = new Student();
alert('after');

Я попробовал это на своем компьютере, и у процесса было 48352 КБ памяти, когда было показано предупреждение «до». После выделения Firefox имел 440236 КБ памяти. Для 2 миллионов выделений это около 200 байтов для каждого объекта.

Я попробовал это снова с распределением в 1 миллион, и результат был похож: 196 байтов на объект (я полагаю, дополнительные данные в 2mill использовались для Array).

Итак, вот хакерский метод, который может вам помочь. JavaScript не предоставляет метод «sizeof» по причине: каждая реализация JavaScript отличается. Например, в Google Chrome та же страница использует около 66 байт для каждого объекта (судя по крайней мере из диспетчера задач).


Привет .. спасибо за технику. У меня было это, поскольку у плана Б не было прямого способа измерить использование памяти.

4
Каждая реализация C и C ++ также отличается. ;) Размер типа данных в C или C ++ зависит от конкретной реализации. Я не вижу причин, по которым JavaScript не может поддерживать такой оператор, хотя он не будет служить той же цели или иметь то же значение, что и в C или C ++ (которые являются языками нижнего уровня и измеряют фактический размер фиксированного тип данных size во время компиляции, а не переменный размер динамического объекта JavaScript во время выполнения).
Бамбамс

12

Извините, я не смог прокомментировать, поэтому я просто продолжаю работу от tomwrong. Эта расширенная версия не будет считать объект более одного раза, таким образом, нет бесконечного цикла. Кроме того, я считаю, что ключ объекта также должен быть приблизительно посчитан.

function roughSizeOfObject( value, level ) {
    if(level == undefined) level = 0;
    var bytes = 0;

    if ( typeof value === 'boolean' ) {
        bytes = 4;
    }
    else if ( typeof value === 'string' ) {
        bytes = value.length * 2;
    }
    else if ( typeof value === 'number' ) {
        bytes = 8;
    }
    else if ( typeof value === 'object' ) {
        if(value['__visited__']) return 0;
        value['__visited__'] = 1;
        for( i in value ) {
            bytes += i.length * 2;
            bytes+= 8; // an assumed existence overhead
            bytes+= roughSizeOfObject( value[i], 1 )
        }
    }

    if(level == 0){
        clear__visited__(value);
    }
    return bytes;
}

function clear__visited__(value){
    if(typeof value == 'object'){
        delete value['__visited__'];
        for(var i in value){
            clear__visited__(value[i]);
        }
    }
}

roughSizeOfObject(a);

Я думаю, что это более точно, так как он подсчитывает ключи, хотя он действительно считает ключ «__visited__»
Сэм Хаслер

Проверка typeof value === 'object'не достаточна, и у вас будут исключения, если значение равно null.
Флорион

Это было невероятно быстро для моего объекта (который, я уверен, имеет размер более 5 МБ), по сравнению с любым из дублированных ответов @ tomwrong. Это также было более точным (как говорится, 3mb или около того), но все еще слишком далеко от реальности. Есть какие-то подсказки, на что это может не рассчитывать?
Cregox

Не работает для меня Объект levelсодержит данные, но roughSizeOfObject(level)возвращает ноль. (Конечно, мой уровень переменных не следует путать с вашим аргументом. Я не думаю, что затенение переменных должно вызывать здесь проблему, а также, когда я переименую «уровень» в вашем скрипте, я получаю тот же результат.) Снимок экрана : snipboard.io/G7E5yj.jpg
Люк

11

Имея ту же проблему. Я искал в Google и хочу поделиться с сообществом stackoverflow этим решением.

Важно :

Я использовал функцию, которой поделился Ян Цин на github https://gist.github.com/zensh/4975495

function memorySizeOf(obj) {
    var bytes = 0;

    function sizeOf(obj) {
        if(obj !== null && obj !== undefined) {
            switch(typeof obj) {
            case 'number':
                bytes += 8;
                break;
            case 'string':
                bytes += obj.length * 2;
                break;
            case 'boolean':
                bytes += 4;
                break;
            case 'object':
                var objClass = Object.prototype.toString.call(obj).slice(8, -1);
                if(objClass === 'Object' || objClass === 'Array') {
                    for(var key in obj) {
                        if(!obj.hasOwnProperty(key)) continue;
                        sizeOf(obj[key]);
                    }
                } else bytes += obj.toString().length * 2;
                break;
            }
        }
        return bytes;
    };

    function formatByteSize(bytes) {
        if(bytes < 1024) return bytes + " bytes";
        else if(bytes < 1048576) return(bytes / 1024).toFixed(3) + " KiB";
        else if(bytes < 1073741824) return(bytes / 1048576).toFixed(3) + " MiB";
        else return(bytes / 1073741824).toFixed(3) + " GiB";
    };

    return formatByteSize(sizeOf(obj));
};


var sizeOfStudentObject = memorySizeOf({Student: {firstName: 'firstName', lastName: 'lastName', marks: 10}});
console.log(sizeOfStudentObject);

Что вы думаете об этом?


3
Это пропускает функции. Если я добавлю функцию, объект не будет отображаться как более крупный
Дон Румми

Не считает ключи
ebg11

7

я хочу знать, действительно ли мои усилия по уменьшению памяти помогают уменьшить память

Следуя этому комментарию, вот что вы должны сделать: Попробуйте создать проблему с памятью - напишите код, который создает все эти объекты и постепенно увеличивает верхний предел до тех пор, пока вы не столкнулись с проблемой (сбой браузера, зависание браузера или выход из строя). ошибка памяти). В идеале вы должны повторить этот эксперимент с разными браузерами и разными операционными системами.

Теперь есть два варианта: вариант 1 - вам не удалось создать проблему с памятью. Следовательно, вы беспокоитесь ни за что. У вас нет проблем с памятью, и ваша программа в порядке.

вариант 2 - у вас проблемы с памятью. Теперь спросите себя, является ли разумным предел, при котором возникла проблема (другими словами: вероятно ли, что это количество объектов будет создано при обычном использовании вашего кода). Если ответ «Нет», то все в порядке. В противном случае вы теперь знаете, сколько объектов может создать ваш код. Переработайте алгоритм так, чтобы он не нарушал этот предел.


С точки зрения памяти, мое расширение добавляет количество объектов для каждой страницы / вкладки, открытой в Firefox. «Число» пропорционально размеру страницы. Если предположить, что у «опытных» пользователей открыто от 15 до 20 вкладок, и если на веб-странице много контента, браузер через некоторое время станет медленным и разочаровывающе не реагирующим. Это происходит даже без меня, явно пытаясь подчеркнуть приложение. У меня есть планы переписать код, который, я думаю, уменьшит создание объектов. Я просто хотел быть уверен, что нет. уменьшенных объектов составило что-то, так что оно того стоит

@Senthil: но размер объекта не имеет значения, если вы не знаете объем доступной памяти. Поскольку объем памяти, скорее всего, останется загадкой, говорить в терминах #objects так же полезно, как говорить в терминах #bytes
Итай Маман


5

Эта библиотека Javascript sizeof.jsделает то же самое. Включите это так

<script type="text/javascript" src="sizeof.js"></script>

Функция sizeof принимает объект в качестве параметра и возвращает его приблизительный размер в байтах. Например:

// define an object
var object =
    {
      'boolean' : true,
      'number'  : 1,
      'string'  : 'a',
      'array'   : [1, 2, 3]
    };

// determine the size of the object
var size = sizeof(object);

Функция sizeof может обрабатывать объекты, которые содержат несколько ссылок на другие объекты и рекурсивные ссылки.

Первоначально опубликовано здесь .


В моем случае это медленнее и выглядит "менее точным", чем @liangliang.
Cregox


2

Большое спасибо всем, кто работал над кодом для этого!

Я просто хотел добавить, что я искал точно такую ​​же вещь, но в моем случае это для управления кэшем обработанных объектов, чтобы избежать необходимости повторного анализа и обработки объектов из вызовов ajax, которые могли или не могли быть кэшированы. браузером. Это особенно полезно для объектов, которые требуют большой обработки, обычно для всего, что не в формате JSON, но может оказаться очень дорогостоящим хранить эти вещи в большом проекте или в приложении / расширении, которое долго работает время.

Во всяком случае, я использую это для чего-то вроде:

var myCache = {
    cache: {},
    order: [],
    size: 0,
    maxSize: 2 * 1024 * 1024, // 2mb

    add: function(key, object) {
        // Otherwise add new object
        var size = this.getObjectSize(object);
        if (size > this.maxSize) return; // Can't store this object

        var total = this.size + size;

        // Check for existing entry, as replacing it will free up space
        if (typeof(this.cache[key]) !== 'undefined') {
            for (var i = 0; i < this.order.length; ++i) {
                var entry = this.order[i];
                if (entry.key === key) {
                    total -= entry.size;
                    this.order.splice(i, 1);
                    break;
                }
            }
        }

        while (total > this.maxSize) {
            var entry = this.order.shift();
            delete this.cache[entry.key];
            total -= entry.size;
        }

        this.cache[key] = object;
        this.order.push({ size: size, key: key });
        this.size = total;
    },

    get: function(key) {
        var value = this.cache[key];
        if (typeof(value) !== 'undefined') { // Return this key for longer
            for (var i = 0; i < this.order.length; ++i) {
                var entry = this.order[i];
                if (entry.key === key) {
                    this.order.splice(i, 1);
                    this.order.push(entry);
                    break;
                }
            }
        }
        return value;
    },

    getObjectSize: function(object) {
        // Code from above estimating functions
    },
};

Это упрощенный пример и может иметь некоторые ошибки, но он дает идею, поскольку вы можете использовать его для удержания статических объектов (содержимое не изменится) с некоторой степенью интеллекта. Это может значительно сократить любые дорогостоящие требования к обработке, которые объект должен был быть произведен в первую очередь.


1
function sizeOf(parent_data, size)
{
    for (var prop in parent_data)
    {
        let value = parent_data[prop];

        if (typeof value === 'boolean')
        {
            size += 4;
        }
        else if (typeof value === 'string')
        {
            size += value.length * 2;
        }
        else if (typeof value === 'number')
        {
             size += 8;
        }
        else
        {      
            let oldSize = size;
            size += sizeOf(value, oldSize) - oldSize;
        }
    }

    return size;
}


function roughSizeOfObject(object)
{   
    let size = 0;
    for each (let prop in object)
    {    
        size += sizeOf(prop, 0);
    } // for..
    return size;
}

1

Я использую вкладку « Временная шкала» инструментов Chrome dev , создаю все более и более крупные объекты и получаю такие хорошие оценки. Вы можете использовать html, подобный приведенному ниже, в качестве примера и изменить его, чтобы лучше имитировать характеристики ваших объектов (количество и типы свойств и т. Д.). Возможно, вы захотите щелкнуть значок мусорного ведра в нижней части вкладки инструментов разработчика, до и после запуска.

<html>
<script>
var size = 1000*100
window.onload = function() {
  document.getElementById("quantifier").value = size
}

function scaffold()
{
  console.log("processing Scaffold...");
  a = new Array
}

function start()
{
  size = document.getElementById("quantifier").value
  console.log("Starting... quantifier is " + size);
  console.log("starting test")
  for (i=0; i<size; i++){
    a[i]={"some" : "thing"}
  }
  console.log("done...")
}

function tearDown()
{
  console.log("processing teardown");
  a.length=0
}

</script>
<body>
    <span style="color:green;">Quantifier:</span>
    <input id="quantifier" style="color:green;" type="text"></input>
    <button onclick="scaffold()">Scaffold</button>
    <button onclick="start()">Start</button>
    <button onclick="tearDown()">Clean</button>
    <br/>
</body>
</html>

Создание 2 миллионов объектов только с одним свойством каждый (как в этом коде выше) приводит к грубому вычислению 50 байтов на объект, на моем Chromium, прямо сейчас. Изменение кода для создания случайной строки для объекта добавляет около 30 байт для объекта и т. Д. Надеюсь, это поможет.


1

Если вам нужно программно проверить на aprox. Размер объектов Вы также можете проверить эту библиотеку http://code.stephenmorley.org/javascript/finding-the-memory-usage-of-objects/, которую я смог использовать для размера объектов.

В противном случае я предлагаю использовать Chrome / Firefox Heap Profiler.


-3

Я полагаю, вы забыли включить «массив».

  typeOf : function(value) {
        var s = typeof value;
        if (s === 'object')
        {
            if (value)
            {
                if (typeof value.length === 'number' && !(value.propertyIsEnumerable('length')) && typeof value.splice === 'function')
                {
                    s = 'array';
                }
            }
            else
            {
                s = 'null';
            }
        }
        return s;
    },

   estimateSizeOfObject: function(value, level)
    {
        if(undefined === level)
            level = 0;

        var bytes = 0;

        if ('boolean' === typeOf(value))
            bytes = 4;
        else if ('string' === typeOf(value))
            bytes = value.length * 2;
        else if ('number' === typeOf(value))
            bytes = 8;
        else if ('object' === typeOf(value) || 'array' === typeOf(value))
        {
            for(var i in value)
            {
                bytes += i.length * 2;
                bytes+= 8; // an assumed existence overhead
                bytes+= estimateSizeOfObject(value[i], 1)
            }
        }
        return bytes;
    },

   formatByteSize : function(bytes)
    {
        if (bytes < 1024)
            return bytes + " bytes";
        else
        {
            var floatNum = bytes/1024;
            return floatNum.toFixed(2) + " kb";
        }
    },

1
В JS массив - это объект. В реализациях могут быть некоторые оптимизации, но концептуально массивы и объекты одинаковы.
Крис Уокер

-8

Я знаю, что это абсолютно неправильный способ сделать это, но в прошлом мне уже несколько раз приходилось получать приблизительный размер объектного файла:

Запишите ваш объект / ответ на консоль или новую вкладку, скопируйте результаты в новый файл блокнота, сохраните его и проверьте размер файла. Сам файл блокнота занимает всего несколько байтов, поэтому вы получите довольно точный размер объектного файла.


4
Это совершенно неправильно. Например, рассмотрим число 1/3 = 0,3333333333333333. Это будет 18 байт, используя ваш подход.
korCZis

2
Я сказал, что это было приблизительно . Иногда вам все равно, 1 МБ или 1,00001 МБ, вы просто хотите узнать оценку, тогда этот метод вполне подойдет.
Джеффри Розендал

Нахальное решение X]
Lapys
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.