How to get the size of a JavaScript object

Question

I want to know the size occupied by a JavaScript object   Take the following function   function Marks      this maxMarks   100     function Student      this firstName    firstName     this lastName    lastName     this marks   new Marks        Now I instantiate the student   var stud   new Student      so that I can do stuff like  stud firstName    new Firstname    alert stud firstName    stud marks maxMarks   200    etc   Now  the stud object will occupy some size in memory  It has some data and more objects   How do I find out how much memory the stud object occupies  Something like a sizeof   in JavaScript  It would be really awesome if I could find it out in a single function call like sizeof stud    I   ve been searching the Internet for months   couldn   t find it  asked in a couple of forums   no replies

User · Answer

Here s a slightly more compact solution to the problem   const typeSizes        undefined        gt  0     boolean        gt  4     number        gt  8     string   item   gt  2   item length     object   item   gt   item   0   Object      keys item       reduce  total  key    gt  sizeOf key    sizeOf item key     total  0      const sizeOf   value   gt  typeSizes typeof value  value

User · Answer

If you need to programatically check for aprox  size of objects you can also check this library http   code stephenmorley org javascript finding-the-memory-usage-of-objects  that I have been able to use for objects size    Otherwise I suggest to use the Chrome Firefox Heap Profiler

User · Answer

Chrome developer tools has this functionality  I found this article very helpful and does exactly what you want  https   developers google com chrome-developer-tools docs heap-profiling

User · Answer

There is a NPM module to get object sizeof  you can install it with npm install object-sizeof    var sizeof   require  object-sizeof          2B per character  6 chars total   gt  12B   console log sizeof  abc   def            8B for Number   gt  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   gt  32B   console log sizeof param

User · Answer

Sorry I could not comment  so I just continue the work from tomwrong  This enhanced version will not count object more than once  thus no infinite loop  Plus  I reckon the key of an object should be also counted  roughly   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

User · Answer

I know this is absolutely not the right way to do it  yet it ve helped me a few times in the past to get the approx object file size   Write your object response to the console or a new tab  copy the results to a new notepad file  save it  and check the file size  The notepad file itself is just a few bytes  so you ll get a fairly accurate object file size

User · Answer

I use Chrome dev tools  Timeline tab  instantiate increasingly large amounts of objects  and get good estimates like that  You can use html like this one below  as boilerplate  and modify it to better simulate the characteristics of your objects  number and types of properties  etc      You may want to click the trash bit icon at the bottom of that dev tools tab  before and after a run    lt html gt   lt script gt  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 lt size  i         a i    some     thing         console log  done         function tearDown       console log  processing teardown      a length 0     lt  script gt   lt body gt       lt span style  color green   gt Quantifier  lt  span gt       lt input id  quantifier  style  color green   type  text  gt  lt  input gt       lt button onclick  scaffold    gt Scaffold lt  button gt       lt button onclick  start    gt Start lt  button gt       lt button onclick  tearDown    gt Clean lt  button gt       lt br  gt   lt  body gt   lt  html gt    Instantiating 2 million objects of just one property each  as in this code above  leads to a rough calculation of 50 bytes per object  on my Chromium  right now  Changing the code to create a random string per object adds some 30 bytes per object  etc   Hope this helps

User · Answer

I believe you forgot to include  array      typeOf   function value            var s   typeof value          if  s      object                         if  value                                if  typeof value length      number   amp  amp    value propertyIsEnumerable  length     amp  amp  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  lt  1024              return bytes     bytes           else                       var floatNum   bytes 1024              return floatNum toFixed 2      kb

User · Answer

This is a hacky method  but i tried it twice with different numbers and it seems to be consistent   What you can do is to try and allocate a huge number of objects  like one or two million objects of the kind you want  Put the objects in an array to prevent the garbage collector from releasing them  note that this will add a slight memory overhead because of the array  but i hope this shouldn t matter and besides if you are going to worry about objects being in memory  you store them somewhere   Add an alert before and after the allocation and in each alert check how much memory the Firefox process is taking  Before you open the page with the test  make sure you have a fresh Firefox instance  Open the page  note the memory usage after the  before  alert is shown  Close the alert  wait for the memory to be allocated  Subtract the new memory from the older and divide it by the amount of allocations  Example   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 lt 2000000  i        manyObjects i    new Student    alert  after      I tried this in my computer and the process had 48352K of memory when the  before  alert was shown  After the allocation  Firefox had 440236K of memory  For 2million allocations  this is about 200 bytes for each object   I tried it again with 1million allocations and the result was similar  196 bytes per object  i suppose the extra data in 2mill was used for Array    So  here is a hacky method that might help you  JavaScript doesn t provide a  sizeof  method for a reason  each JavaScript implementaion is different  In Google Chrome for example the same page uses about 66 bytes for each object  judging from the task manager at least

User · Answer

i want to know if my memory reduction efforts actually help in reducing memory   Following up on this comment  here s what you should do  Try to produce a memory problem - Write code that creates all these objects and graudally increase the upper limit until you ran into a problem  Browser crash  Browser freeze or an Out-Of-memory error   Ideally you should repeat this experiment with different browsers and different operating system   Now there are two options  option 1 - You didn t succeed in producing the memory problem  Hence  you are worrying for nothing  You don t have a memory issue and your program is fine   option 2- you did get a memory problem  Now ask yourself whether the limit at which the problem occurred is reasonable  in other words  is it likely that this amount of objects will be created at normal use of your code   If the answer is  No  then you re fine  Otherwise you now know how many objects your code can create  Rework the algorithm such that it does not breach this limit

User · Answer

This Javascript library sizeof js does the same thing   Include it like this    lt script type  text javascript  src  sizeof js  gt  lt  script gt    The sizeof function takes an object as a parameter and returns its approximate size in bytes  For example      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     The sizeof function can handle objects that contain multiple references to other objects and recursive references   Originally published here

User · Answer

The Google Chrome Heap Profiler allows you to inspect object memory use   You need to be able to locate the object in the trace which can be tricky  If you pin the object to the Window global  it is pretty easy to find from the  Containment  listing mode   In the attached screenshot  I created an object called  testObj  on the window  I then located in the profiler  after making a recording  and it shows the full size of the object and everything in it under  retained size    More details on the memory breakdowns     In the above screenshot  the object shows a retained size of 60  I believe the unit is bytes here

User · Answer

Building upon the already compact solution from  Dan  here s a self-contained function version of it  Variable names are reduced to single letters for those who just want it to be as compact as possible at the expense of context   x000D   x000D  const ns       ns sizeof   function v      let f   ns sizeof    this needs to match the name of the function itself  since arguments callee name is defunct     o            undefined        gt  0         boolean        gt  4         number        gt  8         string   i   gt  2   i length         object   i   gt   i   0   Object          keys i           reduce  t  k    gt  f k    f i k     t  0           return o typeof v  v       ns undef  ns bool   true  ns num   1  ns string    Hello   ns obj       first name   Brendan     last name   Eich     born  new Date 1961  6  4     contributions    Netscape    JavaScript    Brave    BAT      politically safe  false     console log ns sizeof ns undef    console log ns sizeof ns bool    console log ns sizeof ns num    console log ns sizeof ns string    console log ns sizeof ns obj    console log ns sizeof ns obj contributions    x000D   x000D   x000D

User · Answer

Many thanks to everyone that has been working on code for this   I just wanted to add that I ve been looking for exactly the same thing  but in my case it s for managing a cache of processed objects to avoid having to re-parse and process objects from ajax calls that may or may not have been cached by the browser  This is especially useful for objects that require a lot of processing  usually anything that isn t in JSON format  but it can get very costly to keep these things cached in a large project or an app extension that is left running for a long time   Anyway  I use it for something something like   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  gt  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  lt  this order length    i                    var entry   this order i                   if  entry key     key                        total -  entry size                      this order splice i  1                       break                                                     while  total  gt  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  lt  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             It s a simplistic example and may have some errors  but it gives the idea  as you can use it to hold onto static objects  contents won t change  with some degree of intelligence  This can significantly cut down on any expensive processing requirements that the object had to be produced in the first place

User · Answer

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

User · Answer

I just wrote this to solve a similar  ish  problem  It doesn t exactly do what you may be looking for  ie it doesn t take into account how the interpreter stores the object   But  if you are using V8  it should give you a fairly ok approximation as the awesome prototyping and hidden classes lick up most of the overhead   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               amp  amp  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

User · Answer

If your main concern is the memory usage of your Firefox extension  I suggest checking with Mozilla developers    Mozilla provides on its wiki a list of tools to analyze memory leaks

User · Answer

Sometimes I use this to flag really big objects that might be going to the client from the server  It doesn t represent the in memory footprint   It just gets you approximately what it d cost to send it  or store it   Also note  it s slow  dev only  But for getting an ballpark answer with one line of code it s been useful for me   roughObjSize   JSON stringify bigObject  length

User · Answer

I have re-factored the code in my original answer  I have removed the recursion and removed the assumed existence overhead   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               amp  amp  objectList indexOf  value       -1                                 objectList push  value                 for  var i in value                     stack push  value  i                                        return bytes

User · Answer

Having the same problem  I searched on Google and I want to share with stackoverflow community this solution   Important       I used the function shared by Yan Qing on github   https   gist github com zensh 4975495    x000D   x000D  function memorySizeOf obj    x000D      var bytes   0  x000D   x000D      function sizeOf obj    x000D          if obj     null  amp  amp  obj     undefined    x000D              switch typeof obj    x000D              case  number   x000D                  bytes    8  x000D                  break  x000D              case  string   x000D                  bytes    obj length   2  x000D                  break  x000D              case  boolean   x000D                  bytes    4  x000D                  break  x000D              case  object   x000D                  var objClass   Object prototype toString call obj  slice 8  -1   x000D                  if objClass      Object     objClass      Array     x000D                      for var key in obj    x000D                          if  obj hasOwnProperty key   continue  x000D                          sizeOf obj key    x000D                        x000D                    else bytes    obj toString   length   2  x000D                  break  x000D                x000D            x000D          return bytes  x000D         x000D   x000D      function formatByteSize bytes    x000D          if bytes  lt  1024  return bytes     bytes   x000D          else if bytes  lt  1048576  return bytes   1024  toFixed 3      KiB   x000D          else if bytes  lt  1073741824  return bytes   1048576  toFixed 3      MiB   x000D          else return bytes   1073741824  toFixed 3      GiB   x000D         x000D   x000D      return formatByteSize sizeOf obj    x000D     x000D   x000D   x000D  var sizeOfStudentObject   memorySizeOf  Student   firstName   firstName   lastName   lastName   marks  10     x000D  console log sizeOfStudentObject   x000D   x000D   x000D    What do you think about it

[javascript] How to get the size of a JavaScript object?

Examples related to javascript

Examples related to memory

Examples related to object

Examples related to sizeof