Bir JavaScript nesnesinin boyutu nasıl alınır?

Bir JavaScript nesnesi tarafından kullanılan boyutu bilmek istiyorum.

Aşağıdaki işlevi alın:

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

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

Şimdi student:

var stud = new Student();

öyle şeyler yapabilirim ki

stud.firstName = "new Firstname";

alert(stud.firstName);

stud.marks.maxMarks = 200;

vb.

Şimdi, studnesne bellekte bir miktar yer kaplayacaktır. Bazı verileri ve daha fazla nesnesi var.

studNesnenin ne kadar bellek kapladığını nasıl öğrenebilirim ? sizeof()JavaScript'teki gibi bir şey mi? Tek bir işlev çağrısında bulabilirsem gerçekten harika olurdu sizeof(stud).

İnternette aylardır arama yaptım - bulamadım (birkaç forumda sordum - cevap yok).

Orijinal cevabımdaki kodu yeniden çarpanlarına ayırdım . Özyinelemeyi kaldırdım ve varsayılan varlık yükünü kaldırdım.

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

Google Chrome Öbek Profilcisi, nesne belleği kullanımını incelemenize olanak tanır.

Nesneyi izleme içinde zor olabilecek bir şekilde bulabilmeniz gerekir. Nesneyi Global pencereye sabitlerseniz, "Sınırlama" listeleme modundan bulmak oldukça kolaydır.

Ekli ekran görüntüsünde, pencerede "testObj" adlı bir nesne oluşturdum. Daha sonra profilde yer aldım (bir kayıt yaptıktan sonra) ve "tutulan boyut" altında nesnenin ve içindeki her şeyin tam boyutunu gösterir.

Bellek arızaları hakkında daha fazla bilgi .

Yukarıdaki ekran görüntüsünde, nesne 60 büyüklüğünde bir boyut gösterir. Burada birim bayt olduğuna inanıyorum.

Bunu benzer bir (ish) problemi çözmek için yazdım. Aradığınızı tam olarak yapmaz, yani yorumlayıcının nesneyi nasıl sakladığını dikkate almaz.

Ancak, V8 kullanıyorsanız, harika prototipleme ve gizli sınıflar yükün çoğunu yaladığında size oldukça iyi bir yaklaşım sunmalıdır.

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

Bazen bunu sunucudan istemciye gidebilecek gerçekten büyük nesneleri işaretlemek için kullanıyorum. Bellek ayak izini temsil etmez. Sadece size göndermenin veya depolamanın maliyeti ne kadardır.

Ayrıca, yavaş olduğunu, sadece dev unutmayın. Ancak bir kod satırı ile bir basketbol sahası cevabı almak benim için yararlı oldu.

roughObjSize = JSON.stringify(bigObject).length;

İşte soruna biraz daha kompakt bir çözüm:

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

Bir yoktur nesne sizeof almak için NPM modülü , sen ile yükleyebilirsiniznpm 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));

Bu hacky bir yöntemdir, ancak farklı sayılarla iki kez denedim ve tutarlı görünüyor.

Yapabileceğiniz şey, istediğiniz türde bir veya iki milyon nesne gibi çok sayıda nesneyi ayırmaya çalışmaktır . Çöp toplayıcının onları serbest bırakmasını önlemek için bir dizi nesneleri koyun (bu dizi nedeniyle hafif bir bellek yükü ekleyeceğini unutmayın, ama umarım bu önemli olmamalı ve ayrıca bellekte olan nesneler hakkında endişelenecekseniz , onları bir yerde saklarsınız). Tahsisattan önce ve sonra bir uyarı ekleyin ve her uyarıda Firefox işleminin ne kadar bellek aldığını kontrol edin. Sayfayı testle açmadan önce yeni bir Firefox örneğiniz olduğundan emin olun. Sayfayı açın, "önce" uyarısı gösterildikten sonra bellek kullanımını not edin. Uyarıyı kapatın, belleğin ayrılmasını bekleyin. Yeni belleği eskisinden çıkarın ve ayırma miktarına bölün.

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

Bilgisayarımda bunu denedim ve "önce" uyarısı gösterildiğinde işlem 48352K bellek vardı. Tahsis edildikten sonra Firefox'un 440236K belleği vardı. 2 milyon tahsis için, bu her nesne için yaklaşık 200 bayttır.

Tekrar 1 milyon tahsisat ile denedim ve sonuç benzerdi: nesne başına 196 bayt (2 değirmendeki ekstra verilerin Dizi için kullanıldığını varsayalım).

İşte size yardımcı olabilecek hileli bir yöntem. JavaScript bir nedenden ötürü "sizeof" yöntemi sağlamaz: her JavaScript uygulaması farklıdır. Örneğin Google Chrome'da aynı sayfa her nesne için yaklaşık 66 bayt kullanır (en azından görev yöneticisinden yola çıkarak).

Üzgünüm yorum yapamadım, bu yüzden çalışmaya tomwrong'dan devam ediyorum. Bu geliştirilmiş sürüm nesneyi bir kereden fazla saymaz, böylece sonsuz döngü olmaz. Ayrıca, bir nesnenin anahtarının da kabaca sayılması gerektiğini düşünüyorum.

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

Aynı problemi yaşıyorum. Google'da arama yaptım ve bu çözümü stackoverflow topluluğu ile paylaşmak istiyorum.

Önemli :

Yan Qing tarafından paylaşılan işlevi github'da kullandım 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);

Bu konu hakkında ne düşünüyorsun?

Bellek azaltma çabalarımın aslında belleği azaltmada yardımcı olup olmadığını bilmek istiyorum

Bu yorumu takip ederek yapmanız gerekenler: Bir bellek sorunu üretmeye çalışın - Bir sorunla karşılaşıncaya kadar tüm bu nesneleri oluşturan kodu yazın ve üst sınırı kabaca artırın (Tarayıcı çökmesi, Tarayıcı donması veya Out-Of- bellek hatası). İdeal olarak bu deneyi farklı tarayıcılar ve farklı işletim sistemleri ile tekrarlamanız gerekir.

Şimdi iki seçenek var: seçenek 1 - Bellek sorununu üretmeyi başaramadınız. Bu nedenle, hiçbir şey için endişeleniyorsunuz. Bir bellek sorununuz yok ve programınız iyi.

seçenek 2 - bir bellek sorunu yaşadınız. Şimdi kendinize sorunun oluştuğu sınırın makul olup olmadığını sorun (başka bir deyişle: kodunuzun normal kullanımında bu miktarda nesnenin oluşması muhtemeldir). Cevap 'Hayır' ise, sorun yok. Aksi takdirde, artık kodunuzun kaç nesne oluşturabileceğini bilirsiniz. Algoritmayı bu sınırı aşmayacak şekilde yeniden çalışın.

Temel endişeniz Firefox uzantınızın bellek kullanımı ise, Mozilla geliştiricileri ile kontrol etmenizi öneririz.

Mozilla, wiki'sinde bellek sızıntılarını analiz etmek için bir araç listesi sunar .

Bu Javascript kütüphanesi sizeof.jsaynı şeyi yapar. Bu şekilde ekle

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

Sizeof işlevi bir nesneyi parametre olarak alır ve yaklaşık boyutunu bayt cinsinden döndürür. Örneğin:

// 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 işlevi, diğer nesnelere ve özyinelemeli başvurulara birden çok başvuru içeren nesneleri işleyebilir.

Başlangıçta burada yayınlandı .

Chrome geliştirici araçları bu işlevselliğe sahiptir. Bu makaleyi çok yardımcı buldum ve tam olarak ne istediğinizi yapıyorum: https://developers.google.com/chrome-developer-tools/docs/heap-profiling

Bunun için kod üzerinde çalışan herkese çok teşekkürler!

Sadece aynı şeyi aradığımı eklemek istedim, ancak benim durumumda, önbelleğe alınmış ya da bulunmayan ajax çağrılarından nesneleri yeniden ayrıştırmak ve işlemek zorunda kalmamak için işlenmiş nesnelerin önbelleğini yönetmek için tarayıcı tarafından. Bu, özellikle JSON biçiminde olmayan her şey için çok fazla işlem gerektiren nesneler için yararlıdır, ancak bu şeyleri büyük bir projede veya uzun süre çalışacak bir uygulamada / uzantıda önbelleğe almak çok maliyetli olabilir. zaman.

Neyse, böyle bir şey için kullanıyorum:

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

Bu basit bir örnek ve bazı hatalar olabilir, ancak fikir verir, çünkü bir dereceye kadar zeka ile statik nesnelere (içerikler değişmez) tutunmak için kullanabilirsiniz. Bu, nesnenin ilk etapta üretilmesi gereken pahalı işleme gereksinimlerini önemli ölçüde azaltabilir.

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

Chrome geliştirici araçlarının Zaman Çizelgesi sekmesini kullanıyorum , giderek daha fazla miktarda nesne somutlaştırıyorum ve bunun gibi iyi tahminler alıyorum . Aşağıdaki gibi html'yi ısıtıcı plakası olarak kullanabilir ve nesnelerinizin özelliklerini (özelliklerin sayısı ve türleri, vb.) Daha iyi simüle etmek için değiştirebilirsiniz. Bir koşudan önce ve sonra o geliştirici araçları sekmesinin altındaki çöp biti simgesini tıklamak isteyebilirsiniz.

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

Her biri yalnızca bir mülke sahip 2 milyon nesne (yukarıdaki bu kodda olduğu gibi) oluşturmak, şu anda Chromium'umda nesne başına 50 baytlık kaba bir hesaplamaya yol açıyor. Nesne başına rastgele bir dize oluşturmak için kodu değiştirmek, nesne başına yaklaşık 30 bayt ekler.

Programlı olarak aproks olup olmadığını kontrol etmeniz gerekiyorsa. nesnelerin boyutunu da bu kütüphane için http://code.stephenmorley.org/javascript/finding-the-memory-usage-of-objects/ nesnelerin boyutu için kullanabildiğim kontrol edebilirsiniz .

Aksi takdirde Chrome / Firefox Yığın Profilcisi'ni kullanmanızı öneririm.

'Dizi'yi eklemeyi unuttuğuna inanıyorum.

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

Ben biliyorum bu kesinlikle bunu yapmak için doğru bir yol değildir, henüz it've yaklaşık nesne dosya boyutunu almak için geçmişte bana birkaç kez yardım etti:

Nesnenizi / yanıtınızı konsola veya yeni bir sekmeye yazın, sonuçları yeni bir not defteri dosyasına kopyalayın, kaydedin ve dosya boyutunu kontrol edin. Not defteri dosyasının kendisi sadece birkaç bayttır, bu nedenle oldukça doğru bir nesne dosyası boyutu alırsınız.