Como obter o tamanho de um objeto JavaScript?

297

Quero saber o tamanho ocupado por um objeto JavaScript.

Execute a seguinte função:

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

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

Agora instanciamos o student:

var stud = new Student();

para que eu possa fazer coisas como

stud.firstName = "new Firstname";

alert(stud.firstName);

stud.marks.maxMarks = 200;

etc.

Agora, o studobjeto ocupará algum tamanho na memória. Possui alguns dados e mais objetos.

Como descubro quanta memória o studobjeto ocupa? Algo como um sizeof()em JavaScript? Seria realmente incrível se eu pudesse descobrir isso em uma única chamada de função como sizeof(stud).

Venho pesquisando na Internet há meses - não consegui encontrá-la (solicitada em alguns fóruns - sem respostas).

user4642212
fonte
41
Existem (surgirão) muitas razões pelas quais eu preciso encontrar o tamanho de um objeto em JavaScript. Eu sou novo no JavaScript, portanto não sigo as melhores práticas. Eu ainda estou aprendendo eles. Eu desenvolvi uma extensão do firefox que, com certeza, está usando mais memória do que deveria. Estou trabalhando em algumas maneiras de (espero) reduzir o uso de memória ... estou falando de milhares de instâncias, muitos objetos por guia, portanto a memória importa! O problema é que eu quero saber se meus esforços de redução de memória realmente ajudam na redução de memória ... e em quanto.
1
Se você criou uma extensão FF, aconselho você a investigar em um nível de linguagem superior ao JS - veja qual é o impacto no FF em si.
annakata
2
Linguagem de nível superior ao JS? o que seria isso neste caso?
24
Não é o tamanho que importa de qualquer maneira. É como você o usa. PS: Que cravo!
Thomas Eding
13
@SpencerRuport O principal motivo para saber o tamanho do objeto seria para aplicativos off-line compatíveis com html5, onde às vezes você tem espaço de armazenamento limitado (5-10Mb podem ser consumidos rapidamente para um aplicativo com uso intenso de dados).
David

Respostas:

181

Eu refiz o código na minha resposta original . Eu removi a recursão e a sobrecarga de existência assumida.

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;
}
Thomas-Peter
fonte
35
você pode querer pensar nas chaves de objeto, bem
zupa
8
Quem chegou aqui procurando o menor tipo para fins de falso / verdadeiro, parece ser indefinido / nulo.
Zupa
3
"よんもじ".lengthtem 4 em Javascript, mas você tem certeza de que tem 8 bytes, conforme o código o retorna?
21713 syockit
8
Sim. Caracteres em JavaScript são armazenados de acordo com ECMA-262 3rd Edition Especificação - bclary.com/2004/11/07/#a-4.3.16
thomas-peter
4
Esta função não conta referências ocultas nos fechamentos. Por exemplo var a={n:1}; var b={a:function(){return a}}; roughSizeOfObject(b)- aqui bmantém referência a a, mas roughSizeOfObject()retorna 0.
Roman Pominov
117

O Google Chrome Heap Profiler permite que você inspecione o uso da memória do objeto.

Você precisa localizar o objeto no rastreamento, o que pode ser complicado. Se você fixar o objeto na janela global, é muito fácil encontrá-lo no modo de listagem "Contenção".

Na captura de tela anexada, criei um objeto chamado "testObj" na janela. Eu então localizei no criador de perfil (depois de fazer uma gravação) e ele mostra o tamanho total do objeto e tudo em "tamanho retido".

Mais detalhes sobre as falhas de memória .

Perfilador Chrome

Na captura de tela acima, o objeto mostra um tamanho retido de 60. Acredito que a unidade seja bytes aqui.

Guy Bedford
fonte
13
Esta resposta resolveu meu problema junto com: developers.google.com/chrome-developer-tools/docs/… . Dica rápida: faça um instantâneo de heap rápido, execute a tarefa que você suspeita estar vazando, faça um novo instantâneo de heap rápido e selecione a comparisonvisualização na parte inferior. Torna óbvio quais objetos foram criados entre os dois instantâneos.
Johnride 28/03
1
Esta é provavelmente a solução mais limpa.
Luca Steeb
A comparação, mencionada por @Johnride, agora é um menu suspenso na parte superior.
Frandroid 7/04
Shallow sizeparece 40 para os objetos { a:"55c2067aee27593c03b7acbe", b:"55c2067aee27593c03b7acbe", c:null, d:undefined }e { c:null, d:undefined }. Tudo bem?
efkan
1
Você também pode usar o Google Chrome Heap Profiler no nó. Se você tiver o nó v8 ou superior, inicie-o com node --inspecte no Chrome, digite about:inspectna barra de URLs e procure abrir o inspetor de nós . Crie seu objeto na CLI do nó e, em seguida, tire uma captura instantânea de heap.
Gregor
74

Eu acabei de escrever isso para resolver um problema (ish) semelhante. Ele não faz exatamente o que você está procurando, ou seja, não leva em consideração como o intérprete armazena o objeto.

Mas, se você estiver usando o V8, ele deverá fornecer uma aproximação razoavelmente correta, pois as incríveis prototipagens e classes ocultas lambem a maior parte da 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 );
}
Thomas-Peter
fonte
1
@Liangliang Zheng - grande ponto re loop infinito, obrigado. Espero que você não se importa se eu re-show que uma mina pouco e atualização depois do trabalho (?)
thomas-peter
Vou testar isso hoje à noite com o node.js e obter alguns coeficientes melhores.
thomas-peter
A linha 'bytes + = recurse (value [i])' gera um erro no meu FF 14.01: NS_ERROR_FAILURE: Componente retornou o código de falha: 0x80004005 (NS_ERROR_FAILURE) [nsIDOMHTMLInputElement.selectionStart]. Em um dos meus Objetos, se eu tentar um diferente, talvez não seja, um bug do navegador ou o código não funcionará para todos os objetos (o que não funciona contém funções, o que funciona não funciona) t)
TrySpace
1
De um Tom para outro, isso foi super útil como um indicador aproximado de onde eu precisava cortar a cintura de meus objetos. Sua senhora descobriu seu caso com Javascript? Ela é uma amante de alta manutenção.
Tom W Salão
4
É o PHP (gulp) que eu tenho que tomar cuidado - eu parei de amá-la há muito tempo, mas ela paga as contas. De qualquer forma, graças a Tom, o feedback que gosta é muito melhor do que pontos de reputação.
thomas-peter
55

Às vezes eu uso isso para sinalizar objetos realmente grandes que podem estar indo para o cliente a partir do servidor. Não representa o espaço ocupado na memória. Ele fornece a você aproximadamente o custo de enviá-lo ou armazená-lo.

Observe também que é lento, apenas para desenvolvedores. Mas, para obter uma resposta aproximada com uma linha de código, isso tem sido útil para mim.

roughObjSize = JSON.stringify(bigObject).length;
zstew
fonte
2
Nos meus testes, esse método é consideravelmente mais rápido que o tamanho do objeto, porque não possui a chamada lenta _.isObject () do lodash. Além disso, os tamanhos retornados são bastante comparáveis ​​para estimativas aproximadas. Gist gist.github.com/owenallenaz/ff77fc98081708146495 .
Nucleon 29/09/15
5
Não pode usar com estruturas circulares VM1409:1 Uncaught TypeError: Converting circular structure to JSON:( ainda útil embora
givanse
este não é o tamanho binário em bytes, mas simples de usar para obter tamanho aproximado
datdinhquoc
Isso é ótimo se 1) você precisar apenas de uma estimativa aproximada 2) você sabe que não possui referências circulares 3) pode omitir valores grandes e alterá-los separadamente. Tudo isso era verdade no meu caso, então funciona perfeitamente, eu só tinha uma corda grande em um lugar no qual posso medir o comprimento.
OZZIE
45

Aqui está uma solução um pouco mais compacta para o 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);
Dan
fonte
3
então esse é o tamanho em KB? ou bits?
vincent thorpe
2
@ vincent-thorpe Está em bytes.
Dan
3
Bom script, embora precise de modificações para referências cíclicas.
Jim Pedid
1
Acabei de testar seu algoritmo em uma enorme variedade de dados em um processo de nó, ele relata 13 GB, mas o nó está consumindo 22 GB, alguma idéia de onde vem a diferença? Não há mais nada na memória.
Josu Goñi 24/03
3
@ JosuGoñi, eles não calculam quanto o próprio objeto leva, apenas seu valor. Todos os objetos ocupam mais espaço do que apenas seu valor; caso contrário typeof ..., não funcionariam.
Alexis Wilke
42

Há um módulo NPM para obter o tamanho do objeto ; você pode instalá-lo comnpm 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));
Andrei Karpushonak
fonte
sizeof (new Date ()) === 0 e sizeof ({}) === 0. Isso é pretendido?
Philipp Claßen
1
@ PhilippClaßen Obviamente é. Ambos os objetos não têm propriedades.
Robert
18

Este é um método hacky, mas eu tentei duas vezes com números diferentes e parece ser consistente.

O que você pode fazer é tentar alocar um grande número de objetos, como um ou dois milhões de objetos do tipo que você deseja. Coloque os objetos em uma matriz para impedir que o coletor de lixo os libere (observe que isso adicionará uma pequena sobrecarga de memória por causa da matriz, mas espero que isso não importe e, além disso, se você vai se preocupar com objetos que estão na memória , você as armazena em algum lugar). Adicione um alerta antes e depois da alocação e, em cada alerta, verifique quanta memória o processo do Firefox está consumindo. Antes de abrir a página com o teste, verifique se você tem uma nova instância do Firefox. Abra a página, observe o uso da memória após o alerta "antes" ser exibido. Feche o alerta, aguarde a memória ser alocada. Subtraia a nova memória da antiga e divida-a pela quantidade de alocações.

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

Eu tentei isso no meu computador e o processo tinha 48352K de memória quando o alerta "antes" foi exibido. Após a alocação, o Firefox tinha 440236K de memória. Para alocações de 2 milhões, isso é cerca de 200 bytes para cada objeto.

Tentei novamente com alocações de 1 milhão e o resultado foi semelhante: 196 bytes por objeto (suponho que os dados extras em 2mill foram usados ​​para Array).

Então, aqui está um método hacky que pode ajudá-lo. O JavaScript não fornece um método "sizeof" por um motivo: cada implementação de JavaScript é diferente. No Google Chrome, por exemplo, a mesma página usa cerca de 66 bytes para cada objeto (a julgar pelo gerenciador de tarefas, pelo menos).

Setor ruim
fonte
Ei .. obrigado pela técnica. Eu estava tendo que, como plano B, não havia maneira direta de medir o uso de memória.
4
Cada implementação C e C ++ também é diferente. ;) O tamanho de um tipo de dados em C ou C ++ é específico da implementação. Não vejo razão para o JavaScript não suportar esse operador, embora ele não atenda ao mesmo objetivo ou tenha o mesmo significado que em C ou C ++ (que são linguagens de nível inferior e medem o tamanho real de um serviço fixo- tamanho do tipo de dados em tempo de compilação, em oposição ao tamanho variável de um objeto JavaScript dinâmico em tempo de execução).
BamBams
12

Desculpe por não poder comentar, então continuo o trabalho de errado. Esta versão aprimorada não conta o objeto mais de uma vez, portanto, não há loop infinito. Além disso, acho que a chave de um objeto também deve ser contada, 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);
Liangliang Zheng
fonte
Eu acho que isso é mais preciso, pois é teclas de contagem, embora não conte o '__visited__' chave
Sam Hasler
A verificação typeof value === 'object'não é suficiente e você terá exceções se o valor for null.
Floribon
Isso foi incrivelmente rápido para o meu objeto (que estou bastante confiante com mais de 5mb), em comparação com qualquer uma das respostas enganadas de @ tomwrong. Também era mais preciso (como dizia 3mb ou mais), mas ainda muito longe da realidade. Alguma pista sobre o que pode não estar contando?
Cregox
Não funciona para mim. O objeto levelcontém dados, mas roughSizeOfObject(level)retorna zero. (Meu nível de variável não deve ser confundido com seu argumento, é claro. Não acho que o sombreamento de variáveis ​​deva causar um problema aqui e, também, quando renomeio o 'nível' em seu script, obtenho o mesmo resultado.) : snipboard.io/G7E5yj.jpg
Luc
11

Tendo o mesmo problema. Eu pesquisei no Google e quero compartilhar com a comunidade stackoverflow esta solução.

Importante :

Eu usei a função compartilhada por Yan Qing no 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);

O que você acha disso?

Ala Eddine JEBALI
fonte
3
Isso perde funções. Se eu adicionar uma função, o objeto não será maior.
Don Rhummy
Teclas de contagem does not
ebg11
7

Eu quero saber se meus esforços de redução de memória realmente ajudam na redução de memória

Na sequência deste comentário, eis o que você deve fazer: Tente produzir um problema de memória - escreva um código que crie todos esses objetos e aumente graudalmente o limite superior até encontrar um problema (falha do navegador, congelamento do navegador ou um problema de falta de armazenamento). erro de memória). Idealmente, você deve repetir esse experimento com diferentes navegadores e diferentes sistemas operacionais.

Agora, existem duas opções: opção 1 - Você não conseguiu produzir o problema de memória. Portanto, você está se preocupando por nada. Você não tem um problema de memória e seu programa está bom.

opção 2 - você teve um problema de memória. Agora, pergunte-se se o limite em que o problema ocorreu é razoável (em outras palavras: é provável que essa quantidade de objetos seja criada no uso normal do seu código). Se a resposta for 'Não', você está bem. Caso contrário, agora você sabe quantos objetos seu código pode criar. Retrabalhe o algoritmo de forma que ele não ultrapasse esse limite.

Itay Maman
fonte
Do ponto de vista da memória, minha extensão adiciona vários objetos para cada página / guia aberta no Firefox. O "número" é proporcional ao tamanho da página. Supondo que os usuários "avançados" tenham entre 15 e 20 guias abertas e, se a página da Web tiver muito conteúdo, o navegador ficará lento e frustrantemente sem resposta depois de algum tempo. Isso acontece mesmo sem eu tentar explicitamente enfatizar o aplicativo. Eu tenho planos de reescrever o código que acho que reduzirá muita criação de objeto. Eu só queria ter certeza de que não. de objetos reduzidos totalizou algo de modo que vale a pena
@ Senthil: mas o tamanho do objeto não tem significado, a menos que você saiba a quantidade de memória disponível. Desde quantidade de memória é provável que permanecem um mistério, falando em termos de #objects é tão útil como falar em termos de #bytes
Itay Maman
5

Essa biblioteca Javascript sizeof.jsfaz a mesma coisa. Inclua assim

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

A função sizeof usa um objeto como parâmetro e retorna seu tamanho aproximado em bytes. Por exemplo:

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

A função sizeof pode manipular objetos que contêm várias referências a outros objetos e referências recursivas.

Publicado originalmente aqui .

Jayram
fonte
Isso é mais lento e parece ser "menos preciso" do que o de @liangliang, no meu caso de uso.
Cregox
2

Muito obrigado a todos que estiveram trabalhando no código para isso!

Eu só queria acrescentar que estava procurando exatamente a mesma coisa, mas no meu caso, é para gerenciar um cache de objetos processados ​​para evitar a necessidade de analisar e processar novamente objetos de chamadas ajax que podem ou não ter sido armazenadas em cache pelo navegador. Isso é especialmente útil para objetos que exigem muito processamento, geralmente qualquer coisa que não esteja no formato JSON, mas pode ficar muito caro manter essas coisas armazenadas em cache em um projeto grande ou em um aplicativo / extensão que permanece em execução por um longo período. Tempo.

De qualquer forma, eu 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
    },
};

É um exemplo simplista e pode ter alguns erros, mas dá a ideia, pois você pode usá-lo para segurar objetos estáticos (o conteúdo não muda) com algum grau de inteligência. Isso pode reduzir significativamente os requisitos de processamento caros que o objeto teve que ser produzido em primeiro lugar.

Haravikk
fonte
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;
}
Boris Rayskiy
fonte
1

Uso a guia Linha do tempo das ferramentas de desenvolvimento do Chrome , instanciamos quantidades cada vez maiores de objetos e obtenho boas estimativas como essa. Você pode usar html como este abaixo, como clichê, e modificá-lo para simular melhor as características de seus objetos (número e tipos de propriedades, etc ...). Você pode clicar no ícone da lixeira na parte inferior dessa guia de ferramentas de desenvolvimento, antes e depois de uma execução.

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

A instanciação de 2 milhões de objetos de apenas uma propriedade cada (como neste código acima) leva a um cálculo aproximado de 50 bytes por objeto, no meu Chromium, no momento. Alterar o código para criar uma sequência aleatória por objeto adiciona cerca de 30 bytes por objeto, etc. Espero que isso ajude.

matanster
fonte
-3

Eu acredito que você esqueceu de 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";
        }
    },
fchas15
fonte
1
Em JS, uma matriz é um objeto. Pode haver algumas otimizações nas implementações, mas matrizes e objetos conceitualmente são os mesmos.
Kris Walker #
-8

Eu sei isto não é absolutamente o caminho certo para fazê-lo, ainda it've me ajudou algumas vezes no passado para obter o tamanho aproximado arquivo objeto:

Escreva seu objeto / resposta no console ou em uma nova guia, copie os resultados para um novo arquivo de bloco de notas, salve-o e verifique o tamanho do arquivo. O arquivo do bloco de notas em si tem apenas alguns bytes; portanto, você terá um tamanho de arquivo de objeto bastante preciso.

Jeffrey Roosendaal
fonte
4
Isso está completamente errado. Por exemplo, considere o número 1/3 = 0,3333333333333333. Serão 18 bytes usando sua abordagem.
KorCZis
2
Eu disse que era aproximado . Às vezes, você não se importa se é 1 MB ou 1.00001 MB, só quer saber uma estimativa, então esse método é perfeitamente adequado.
Jeffrey Roosendaal
Solução insolente X]
Lapys 18/06/19