Memory Usage/Garbage Collection of Objects Passed Into Functions

Question

When an object is passed into a function, the object is passed by value (although the value for an object is a reference). I am passing very large objects into my functions, but only accessing a handful of properties (6-12) from within the function. Memorywise, would it be better to only pass the properties instead of the whole object? Or would this actually create more of a memory issue if my properties are strings?

Given the two functions below, what happens memorywise? In f1, does javascript/v8 create a new object foo in memory or is it really just a pointer? Does it remain just a pointer if I access a string property or does V8 then make a copy of that string for use within the function. In f2, I assume that a completely new copy of the string foo is made for the function. Is this a correct assumption?

function f1(x) {
  var y = x.foo;
}

function f2(foo) {
  var y = foo;
}

var obj = {foo: "test"};
f1(obj);
f2(obj.foo);

Yes, the value is just a pointer. For the strings I don't there's made a copy, because strings are immutable - again it's just a pointer into the memory. — Bergi
– Bergi, Commented Oct 18, 2012 at 20:29

I Hate Lazy · Accepted Answer · 2012-10-18 19:36:38Z

1

"Memorywise, would it be better to only pass the properties instead of the whole object? Or would this actually create more of a memory issue if my properties are strings? "

That would require more memory. Doesn't really matter if they're strings, since strings are generally implemented as Reference Types as well, but for each argument, there will be a copy of the value instead of just a single copy of the Object reference.

The object reference is very light weight, so you just as just copy that instead of all individual members of the object.

Also, this will be required if you rely on mutations of the object within the function.

In your examples, there's only one property being passed (a string). If your code doesn't rely on mutations of the object itself, then there'll be no significant difference between the two.

In the example that passes the object, the only copy is the object reference. It isn't a pointer, but it is very light weight, and nothing to be concerned about.

In the example that passes the string, it would seem as though it makes a copy of the entire string, but since stings are immutable in JavaScript, implementations generally implement them as reference types as well.

Therefore it's as efficient to pass a single character string as it is to pass a 10,000 character string.

answered Oct 18, 2012 at 19:36

I Hate Lazy

49k13 gold badges89 silver badges79 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

AlexGad Over a year ago

I'm not doing any mutations within the functions. Their purpose is to determine what should happen within the function: ie: if(obj.foo =x)... So, I guess the one big object is the way to go. Basically, this is an API, and I need to track lots of state information for a request (who the client is - its a multiclient app, who the user is, what they are requesting, how they are requesting it, etc.) so I have created a requestContext object that contains other large objects and I pass this requestContext object all over the place which started to concern me, thus the question. Thanks!

I Hate Lazy Over a year ago

@AlexGad: You're welcome, and yes definitely pass the object. If I were to guess, I'd say it's probably 64 bits you're passing. But ultimately do what makes sense for the API. If a particular function only needs to validate a single value, then pass that if it makes more sense in the given circumstance.

Collectives™ on Stack Overflow

Memory Usage/Garbage Collection of Objects Passed Into Functions

1 Answer 1

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related