Hacker News Reader

Comment by RedShift1 | Hacker News Reader

I only clone data using JSON.parse(JSON.stringify(someThing)), and thus avoid all the mess that comes with trying to clone anything else than primitives types.

View on HN

This fails, among other scenarios, if `someThing` includes a Date object.

  >>> const z = { d: new Date() }
  undefined
  >>> typeof z.d
  "object"
  >>> const a = JSON.parse(JSON.stringify(z))
  undefined
  >>> typeof a.d
  "string"
  >>>

After the roundtrip, the property `d` is now a string, not a Date object.

All the data comes from a JSON API and thus doesn't contain Date objects to begin with.

Makes sense for the most part with these constraints then. I missed the "primitive types" portion in the original comment.

The following isn't applicable for pure JSON responses, but is applicable for primitive types:

An additional condition for bigint is necessary, which is a primitive type. Otherwise JSON.stringify throws:

  >>> const x = { i: BigInt("0x1fffffffffffff") }
  undefined
  >>> typeof x.i
  "bigint"
  >>> const b = JSON.parse(JSON.stringify(x))
  Exception: TypeError: JSON.stringify cannot serialize BigInt.
  >>>

... and for the symbol primitive, which JSON.stringifys to undefined, and thus can't be JSON.parsed.

Consider the Date object harmful, use ISO strings instead, and problem solved.

So how do you manipulate ISO dates as strings?

Although ISO date strings can be fairly trivial to read and manipulate with RexExp or a custom parser, depending on the complexity of the task, I would recommend using something like iso-fns.

https://iso-fns.org

It's too bad this library (and approach) never took off, but it's there to use nevertheless.

Even without iso-fns, it's not as if mid level developer can't figure out how to write a function to perform a specific operation on an ISO date string.

After over 10 years of web development, I do think this is the best known approach and is even better than storing UNIX time. Even if there were no existing libraries to help with manipulating ISO strings, I will gladly take the inconvenience in exchange for the rest of the advantages.

With ISO strings, you don't get any behavioral quirks from Date; they are totally compatible with JSON; you can store the time zone along with the time; there is nothing to stop you from changing the time zone while leaving all the other values intact; ISO strings also support durations.

Basically, they support most of what a software developer will be expected to do with times and dates but without any behavior or assumptions about the client time zone that introduce bugs like with Date. `<input type="datetime-local">` also uses ISO strings out of the box, which can be really convenient, and values from `<input type="date">` can be easily appended into an actual ISO string.

ISO datetimes are not monotonic. That’s already one good reason not to use them for storage.

Which is the first method they mention and just flat out tell to avoid it.

"cloneJSON is very slow and can’t do much. Please avoid it."

I mean, I also use it since forever.

But I might look into the winner cloneLib.

If it is really faster, it might be worth it, but I likely still won't trust it for anything complex.

Emphasis on _data_. I don't have a need to clone complex objects (what the article is trying to do). The data I need to clone are usually small so when it comes to performance it's negligible, not worth adding another dependency to the project.

I sure hope `someThing` is never `undefined`, for your sake.

Any cloning happens on data retrieved from an API, which is always JSON, and cannot contain undefined by definition.

Just chuck a check in front of it

That seems to be a logical thing to ensure has been validated before this code is run, so no need to complicate the simple example in a HN post?

> avoid all the mess that comes with trying to clone anything else than primitives types

is an odd way to suffix code that will throw a SyntaxError when handed a primitive type.

Or NaN or Infinity.

There's this really nifty concept called "guarding" that helps with recovering from that sort of thing.

Reply on news.ycombinator.com