0

In the Google Getting started with Node.js tutorial they perform the following operation

data = {...data};

in the code for sending data to Firestore.

You can see it on their Github, line 63.

As far as I can tell this doesn't do anything.

Is there a good reason for doing this?

Is it potentially future proofing, so that if you added your own data you'd be less likely to do something like data = {data, moreData}?

Sam Dean
  • 433
  • 7
  • 22

2 Answers2

2

@Manu's answer details what the line of code is doing, but not why it's there.

I don't know exactly why the Google code example uses this approach, but I would guess at the following reason (and would do the same myself in this situation):

Because objects in JavaScript are passed by reference, it becomes necessary to rebuild the 'data' object from it's constituent parts to avoid the original data object being further modified by the ref.set(data) call on line 64 of the example code:

await ref.set(data);

For example, in MongoDB, when you pass an object into a write or update method, Mongo will actually modify the object to add extra properties such as the datetime it was insert into a collection or it's ID within the collection. I don't know for sure if Firestore does the same, but if it doesn't now, it's possible that it may in future. If it does, and if your original code that calls the update method from Google's example code goes on to further manipulate the data object that it originally passed, that object would now have extra properties on it that may cause unexpected problems. Therefore, it's prudent to rebuild the data object from the original object's properties to avoid contamination of the original object elsewhere in code.

I hope that makes sense - the more I think about it, the more I'm convinced that this must be the reason and it's actually a great learning point.

I include the full original function from Google's code here in case others come across this in future, since the code is subject to change (copied from https://github.com/GoogleCloudPlatform/nodejs-getting-started/blob/master/bookshelf/books/firestore.js at the time of writing this answer):

// Creates a new book or updates an existing book with new data.
async function update(id, data) {
  let ref;
  if (id === null) {
    ref = db.collection(collection).doc();
  } else {
    ref = db.collection(collection).doc(id);
  }

  data.id = ref.id;
  data = {...data};
  await ref.set(data);
  return data;
}
Steve Griffiths
  • 108
  • 6
0

It's making a shallow copy of data; let's say you have a third-party function that mutates the input:

const foo = input => {
  input['changed'] = true;
}

And you need to call it, but don't want to get your object modified, so instead of:

data = {life: 42}
foo(data)

// > data
// { life: 42, changed: true }

You may use the Spread Syntax:

data = {life: 42}
foo({...data})

// > data
// { life: 42 }

Not sure if this is the particular case with Firestone but the thing is: spreading an object you get a shallow copy of that obj.

===

Related: Object copy using Spread operator actually shallow or deep?

Manu Artero
  • 9,238
  • 6
  • 58
  • 73
  • 1
    `It's making a copy of data;` I would probably write _shallow copy_ to make clear that no deep copy is made. – t.niese Nov 10 '21 at 12:11
  • Your related link seems to contradict the first bit of your answer. "It deep copies the data if it is not nested. For nested data, it deeply copies the topmost data and shallow copies of the nested data." – Sam Dean Nov 10 '21 at 12:43
  • Also in this instance it doesn't seem to matter what kind of copy it is because the new copy is being assigned to the original variable. So there isn't a new variable for deep/shallow to matter against. – Sam Dean Nov 10 '21 at 12:44