¿Cómo obtener el tamaño de un objeto JavaScript?


298

Quiero saber el tamaño ocupado por un objeto JavaScript.

Tome la siguiente función:

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

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

Ahora instanciaré el student:

var stud = new Student();

para poder hacer cosas como

stud.firstName = "new Firstname";

alert(stud.firstName);

stud.marks.maxMarks = 200;

etc.

Ahora, el studobjeto ocupará algún tamaño en la memoria. Tiene algunos datos y más objetos.

¿Cómo averiguo cuánta memoria studocupa el objeto? Algo así como un sizeof()en JavaScript? Sería realmente increíble si pudiera descubrirlo en una sola llamada de función como sizeof(stud).

He estado buscando en Internet durante meses, no pude encontrarlo (preguntado en un par de foros, sin respuestas).


41
Hay (surgirán) muchas razones por las que necesito encontrar el tamaño de un objeto en JavaScript. Soy nuevo en JavaScript, así que no sigo las mejores prácticas. Todavía los estoy aprendiendo. He desarrollado una extensión de Firefox que estoy seguro está usando más memoria de la que debería. Estoy trabajando en algunas formas de (con suerte) reducir el uso de memoria ... estoy hablando de miles de instancias, muchos objetos por pestaña, ¡así que la memoria sí importa! La cuestión es que quiero saber si mis esfuerzos de reducción de memoria realmente ayudan a reducir la memoria ... y en qué medida.

1
Si ha creado una extensión FF, le aconsejo que investigue a un nivel de idioma más alto que JS: vea cuál es el impacto en FF.
annakata

2
Lenguaje de nivel superior que JS? ¿Qué sería eso en este caso?

24
No es el tamaño lo que importa de todos modos. Así es como lo usas. PD: ¡Qué semental!
Thomas Eding

13
@SpencerRuport La razón número uno para conocer el tamaño del objeto sería para aplicaciones con capacidad fuera de línea html5 donde a veces tiene un espacio de almacenamiento limitado (5-10Mb pueden consumirse rápidamente para una aplicación de uso intensivo de datos).
David

Respuestas:


182

He refactorizado el código en mi respuesta original . Eliminé la recursión y eliminé la supuesta existencia por encima.

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
es posible que desee pensar también en las claves de objeto
zupa

8
Cualquiera que aterrizó aquí buscando el tipo más pequeño con el propósito de falso / verdadero, parece ser indefinido / nulo.
zupa

3
"よんもじ".lengthes 4 en Javascript, pero ¿está seguro de que tiene 8 bytes, ya que su código lo devuelve?
syockit

8
Sí. Los caracteres en JavaScript se almacenan de acuerdo con la especificación ECMA-262 3rd Edition - bclary.com/2004/11/07/#a-4.3.16
thomas-peter

44
Esta función no cuenta referencias ocultas en cierres. Por ejemplo var a={n:1}; var b={a:function(){return a}}; roughSizeOfObject(b), aquí btiene referencia a a, pero roughSizeOfObject()regresa 0.
Roman Pominov

118

Google Chrome Heap Profiler le permite inspeccionar el uso de la memoria de objetos.

Debe poder ubicar el objeto en la traza, lo que puede ser complicado. Si fija el objeto a la ventana global, es bastante fácil de encontrar desde el modo de listado "Contención".

En la captura de pantalla adjunta, creé un objeto llamado "testObj" en la ventana. Luego lo ubiqué en el generador de perfiles (después de hacer una grabación) y muestra el tamaño completo del objeto y todo lo que contiene en "tamaño retenido".

Más detalles sobre los desgloses de memoria .

Perfilador de cromo

En la captura de pantalla anterior, el objeto muestra un tamaño retenido de 60. Creo que la unidad es bytes aquí.


13
Esta respuesta resolvió mi problema junto con: developers.google.com/chrome-developer-tools/docs/… . Consejo rápido: tome una instantánea rápida del montón, ejecute la tarea que sospecha que está goteando, tome una nueva instantánea rápida del montón y seleccione la comparisonvista en la parte inferior. Hace obvio qué objetos se crearon entre las dos instantáneas.
Johnride

1
Esta es probablemente la solución más limpia.
Luca Steeb

La comparación, mencionada por @Johnride, ahora es un menú desplegable en la parte superior.
frandroid

Shallow sizeparece 40 para ambos objetos { a:"55c2067aee27593c03b7acbe", b:"55c2067aee27593c03b7acbe", c:null, d:undefined }y { c:null, d:undefined }. ¿Está bien?
efkan

1
También puedes usar el Google Chrome Heap Profiler desde el nodo. Si tiene el nodo v8 o superior, comience con node --inspecty en Chrome, ingrese about:inspecten la barra de URL y busque abrir el inspector de nodos. Cree su objeto en la CLI del nodo y luego tome una instantánea del montón.
Gregor

75

Acabo de escribir esto para resolver un problema similar (ish). No hace exactamente lo que está buscando, es decir, no tiene en cuenta cómo el intérprete almacena el objeto.

Pero, si está utilizando V8, debería darle una aproximación bastante correcta, ya que los impresionantes prototipos y las clases ocultas absorben la mayor parte de la sobrecarga.

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 - gran punto re bucle infinito, gracias. Espero que no le importe que me re-concierto es una mina de bits y la actualización después del trabajo (?)
Thomas-peter

Voy a probar esto esta noche con node.js y obtendré algunos coeficientes mejores.
thomas-peter

La línea 'bytes + = recurse (valor [i])' arroja un error en mi FF 14.01: NS_ERROR_FAILURE: Componente devuelto código de falla: 0x80004005 (NS_ERROR_FAILURE) [nsIDOMHTMLInputElement.selectionStart]. En uno de mis objetos, si intento uno diferente, no funciona, tal vez un error del navegador, o el código no funciona para cada objeto (el que no funciona contiene funciones, el que no funciona) t)
TrySpace

1
De un Tom a otro, esto fue muy útil como un indicador aproximado de dónde necesitaba recortar las cinturas de mis objetos. Entonces, ¿su señora se enteró de su aventura con Javascript? Ella es una amante de alto mantenimiento.
Tom W Hall

44
Tengo que tener cuidado con PHP (trago). Dejé de quererla hace mucho tiempo pero ella paga las cuentas. De todos modos, gracias Tom, los comentarios que me gustan son mucho mejores que los puntos de reputación.
thomas-peter

55

A veces lo uso para marcar objetos realmente grandes que podrían ir al cliente desde el servidor. No representa la huella en memoria. Simplemente le da aproximadamente lo que costaría enviarlo o almacenarlo.

También tenga en cuenta que es lento, solo para desarrolladores. Pero para obtener una respuesta aproximada con una línea de código me ha sido útil.

roughObjSize = JSON.stringify(bigObject).length;

2
Según mis pruebas, este método es considerablemente más rápido que el tamaño de objeto de caso porque no tiene la llamada lenta _.isObject () de lodash. Además, los tamaños devueltos son bastante comparables para estimaciones aproximadas. Gist gist.github.com/owenallenaz/ff77fc98081708146495 .
Nucleon


55
No se puede usar con estructuras circulares VM1409:1 Uncaught TypeError: Converting circular structure to JSON:( sigue siendo útil, sin embargo
givanse

este no es un tamaño binario en bytes, sino que es fácil de usar para obtener un tamaño aproximado
datdinhquoc

Esto es bastante bueno si 1) solo necesita una estimación aproximada 2) sabe que no tiene referencias circulares 3) puede omitir valores grandes y enviarlos por separado. Todo esto era cierto en mi caso, así que funciona perfectamente, solo tenía una cadena grande en un lugar en la que solo puedo medir la longitud.
OZZIE

45

Aquí hay una solución un poco más compacta para el problema:

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
entonces este es el tamaño en KB? o bits?
Vincent Thorpe

2
@ Vincent-Thorpe Está en bytes.
Dan

3
Buen script, aunque necesita modificaciones para referencias cíclicas.
Jim Pedid

1
Acabo de probar su algoritmo en una gran variedad de datos dentro de un proceso de nodo, informa 13 GB, pero el nodo consume 22 GB, ¿alguna idea de dónde viene la diferencia? No hay nada más en la memoria.
Josu Goñi

3
@ JosuGoñi, no calculan cuánto toma el objeto en sí, solo su valor. Todos los objetos ocupan más espacio que su valor, de lo contrario typeof ...no funcionaría.
Alexis Wilke

43

Hay un módulo NPM para obtener el tamaño del objeto , puede instalarlo connpm 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 y sizeof ({}) === 0. ¿Está previsto?
Philipp Claßen

1
@ PhilippClaßen Obviamente lo es. Ambos objetos no tienen propiedades.
Robert

18

Este es un método hacky, pero lo intenté dos veces con diferentes números y parece ser consistente.

Lo que puede hacer es tratar de asignar una gran cantidad de objetos, como uno o dos millones de objetos del tipo que desee. Coloque los objetos en una matriz para evitar que el recolector de basura los libere (tenga en cuenta que esto agregará una ligera sobrecarga de memoria debido a la matriz, pero espero que esto no importe y además si se va a preocupar de que los objetos estén en la memoria , los guardas en alguna parte). Agregue una alerta antes y después de la asignación y en cada alerta verifique cuánta memoria está tomando el proceso de Firefox. Antes de abrir la página con la prueba, asegúrese de tener una nueva instancia de Firefox. Abra la página, observe el uso de memoria después de que se muestre la alerta "antes". Cierre la alerta, espere a que se asigne la memoria. Reste la nueva memoria de la anterior y divídala por la cantidad de asignaciones.

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

Intenté esto en mi computadora y el proceso tenía 48352K de memoria cuando se mostró la alerta "antes". Después de la asignación, Firefox tenía 440236K de memoria. Para 2 millones de asignaciones, esto es aproximadamente 200 bytes para cada objeto.

Lo intenté nuevamente con 1 millón de asignaciones y el resultado fue similar: 196 bytes por objeto (supongo que los datos adicionales en 2 millones se usaron para la matriz).

Entonces, aquí hay un método hacky que podría ayudarte. JavaScript no proporciona un método "sizeof" por una razón: cada implementación de JavaScript es diferente. En Google Chrome, por ejemplo, la misma página usa aproximadamente 66 bytes para cada objeto (a juzgar por el administrador de tareas al menos).


Hola ... gracias por la técnica. Tenía eso como plan B en caso de que no hubiera una forma directa de medir el uso de memoria.

44
Cada implementación de C y C ++ también es diferente. ;) El tamaño de un tipo de datos en C o C ++ es específico de la implementación. No veo ninguna razón por la que JavaScript no pueda admitir un operador de este tipo, aunque no serviría para el mismo propósito ni tendría el mismo significado que en C o C ++ (que son lenguajes de nivel inferior y miden el tamaño real de un archivo fijo) tipo de datos de tamaño en tiempo de compilación en oposición al tamaño variable de un objeto JavaScript dinámico en tiempo de ejecución).
bambams

12

Lo siento, no pude comentar, así que solo continúo el trabajo de tomwrong. Esta versión mejorada no contará el objeto más de una vez, por lo tanto, no habrá bucle infinito. Además, creo que la clave de un objeto también debe contarse, aproximadamente.

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

Creo que esto es más preciso ya que cuenta las teclas, aunque sí cuenta la tecla '__visited__'
Sam Hasler

La comprobación typeof value === 'object'no es suficiente y tendrá excepciones si el valor es null.
floribon

Esto fue increíblemente rápido para mi objeto (que estoy bastante seguro de que tiene más de 5 MB), en comparación con cualquiera de las respuestas engañadas de @ tomwrong. También fue más preciso (como decía 3mb más o menos), pero aún estaba demasiado lejos de la realidad. ¿Alguna pista sobre lo que puede no estar contando?
cregox

No funciona para mi El objeto levelcontiene datos pero roughSizeOfObject(level)devuelve cero. (Mi nivel variable no debe confundirse con su argumento, por supuesto. No creo que el sombreado variable deba causar un problema aquí, y también cuando cambio el nombre del 'nivel' en su script obtengo el mismo resultado). : snipboard.io/G7E5yj.jpg
Luc

11

Tener el mismo problema Busqué en Google y quiero compartir con la comunidad stackoverflow esta solución.

Importante :

Usé la función compartida por Yan Qing en 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);

¿Qué piensa usted al respecto?


3
Esto pierde funciones. Si agrego una función, el objeto no se muestra como más grande
Don Rhummy

No cuenta llaves
ebg11

7

Quiero saber si mis esfuerzos de reducción de memoria realmente ayudan a reducir la memoria

A continuación de este comentario, esto es lo que debe hacer: Intente generar un problema de memoria: escriba un código que cree todos estos objetos y aumente gradualmente el límite superior hasta que se encuentre con un problema (bloqueo del navegador, bloqueo del navegador o falta de disponibilidad) error de memoria). Idealmente, debe repetir este experimento con diferentes navegadores y diferentes sistemas operativos.

Ahora hay dos opciones: opción 1: no logró generar el problema de memoria. Por lo tanto, no te preocupas por nada. No tiene un problema de memoria y su programa está bien.

opción 2: tienes un problema de memoria. Ahora pregúntese si el límite en el que ocurrió el problema es razonable (en otras palabras: es probable que esta cantidad de objetos se cree con el uso normal de su código). Si la respuesta es 'No', entonces estás bien. De lo contrario, ahora sabe cuántos objetos puede crear su código. Vuelva a trabajar el algoritmo de modo que no viole este límite.


Desde el punto de vista de la memoria, mi extensión agrega una cantidad de objetos para cada página / pestaña que está abierta en Firefox. El "número" es proporcional al tamaño de la página. Suponiendo que los usuarios "avanzados" tengan entre 15 y 20 pestañas abiertas, y si la página web tiene muchos contenidos, el navegador se vuelve lento y frustrantemente no responde después de un tiempo. Esto sucede incluso sin que explícitamente intente enfatizar la aplicación. Tengo planes de reescribir el código que creo que reducirá mucha creación de objetos. Solo quería asegurarme de que el no. de objetos reducidos ascendió a algo para que valga la pena

@Senthil: pero el tamaño del objeto no tiene sentido a menos que conozca la cantidad de memoria disponible. Dado que es probable que la cantidad de memoria siga siendo un misterio, hablar en términos de #objetos es tan útil como hablar en términos de #bytes
Itay Maman


5

Esta biblioteca Javascript sizeof.jshace lo mismo. Inclúyalo así

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

La función sizeof toma un objeto como parámetro y devuelve su tamaño aproximado en bytes. Por ejemplo:

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

La función sizeof puede manejar objetos que contienen múltiples referencias a otros objetos y referencias recursivas.

Originalmente publicado aquí .


Esto es más lento y parece ser "menos preciso" que el de @liangliang, en mi caso de uso.
cregox


2

¡Muchas gracias a todos los que han estado trabajando en el código para esto!

Solo quería agregar que he estado buscando exactamente lo mismo, pero en mi caso es para administrar un caché de objetos procesados ​​para evitar tener que volver a analizar y procesar objetos de llamadas ajax que pueden o no haber sido almacenadas en caché por el navegador Esto es especialmente útil para objetos que requieren mucho procesamiento, generalmente cualquier cosa que no esté en formato JSON, pero puede ser muy costoso mantener estas cosas en caché en un proyecto grande o una aplicación / extensión que se deja en funcionamiento durante mucho tiempo hora.

De todos modos, lo uso para algo como:

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

Es un ejemplo simplista y puede tener algunos errores, pero da la idea, ya que puede usarlo para retener objetos estáticos (el contenido no cambiará) con cierto grado de inteligencia. Esto puede reducir significativamente los costosos requisitos de procesamiento que el objeto tuvo que ser producido en primer lugar.


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

Utilizo la pestaña Línea de tiempo de las herramientas de desarrollo de Chrome , instancia cada vez más grandes cantidades de objetos y obtengo buenas estimaciones como esa. Puede usar html como este a continuación, como repetitivo, y modificarlo para simular mejor las características de sus objetos (número y tipos de propiedades, etc.). Es posible que desee hacer clic en el icono de bit de basura en la parte inferior de esa pestaña de herramientas de desarrollo, antes y después de una ejecución.

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

Instanciar 2 millones de objetos de una sola propiedad cada uno (como en este código anterior) conduce a un cálculo aproximado de 50 bytes por objeto, en mi Chromium, en este momento. Cambiar el código para crear una cadena aleatoria por objeto agrega unos 30 bytes por objeto, etc. Espero que esto ayude.



-3

Creo que olvidó incluir 'array'.

  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
En JS, una matriz es un objeto. Puede haber algunas optimizaciones en las implementaciones, pero conceptualmente las matrices y los objetos son los mismos.
Kris Walker

-8

Yo que esto no es absolutamente la manera correcta de hacerlo, sin embargo it've me ayudó un par de veces en el pasado para obtener el tamaño de archivo de objeto aprox:

Escriba su objeto / respuesta en la consola o en una nueva pestaña, copie los resultados en un nuevo archivo de bloc de notas, guárdelo y verifique el tamaño del archivo. El archivo del bloc de notas en sí es de unos pocos bytes, por lo que obtendrá un tamaño de archivo de objeto bastante preciso.


44
Esto está completamente mal. Por ejemplo, considere el número 1/3 = 0.3333333333333333. Serán 18 bytes usando su enfoque.
korCZis

2
Dije que era aproximado . A veces no te importa si es 1 MB o 1.00001 MB, solo quieres saber una estimación, entonces este método está perfectamente bien.
Jeffrey Roosendaal

Cheeky solution X]
Lapys
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.