CODEWITHSUNDEEP
javascriptv8
AlexGad
AlexGad

Reputation: 6692

Memory Usage/Garbage Collection of Objects Passed Into Functions

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

Upvotes: 1

Views: 224

Answers (1)

I Hate Lazy
I Hate Lazy

Reputation: 48779

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

Upvotes: 1

Related Questions