How to handle optional date parameters?

Question

When creating a function to be reusable throughout the project I came across something strange. After looking at this function it looks very much like it could be refactored.

The function should only return the short month and day, in that order. If it receives a parameter, it will be a Firestore Timestamp with the following format:

{
   "seconds":1667420699,
   "nanoseconds":394000000
}

If it does not receive a parameter, it must return today's month and day. So I did this:

function shortMonthDay(timestamp = undefined) {
  let date

  if (timestamp) {
    date = new Date(timestamp.seconds * 1000 + timestamp.nanoseconds / 1000000)
  } else {
    date = new Date()
  }

  return date.toLocaleDateString('en-US', {
    month: 'short',
    day: 'numeric'
  }) // Nov 2
}

The function works as it should, it doesn't return any errors. But I wonder if it could be improved and how.

Answer 1

Minor points

• Default parameters eg shortMonthDay(timestamp = undefined) are only assigned to arguments that are undefined or contain undefined. To assign the default undefined will do nothing and is just code noise.

• The timestamp object is not vetted. If it contains seconds, it may not have nanoseconds (and visa versa), or either or both may not hold a number. You need to ensure that you do not pass NaN to the Date constructor when parsing the timestamp

Function roles

shortMonthDay would be better as two functions.

1. timestampToDate to convert a timestamp if given to a date.
2. formatDate to format the date object, which you can curry with the locale format. Thus you don't need to touch the timestampToDate to change the output format

Rewrite

We can rewrite the function as follows

const formatDate = (loc = "en-US", format = {month: "short", day: "numeric"}) => 
  date => date.toLocaleDateString(loc, format);
const timestampToDate = (timestamp = {}) => new Date(
  (isNaN(timestamp.seconds) ? Date.now() : Number(timestamp.seconds) * 1000) +
  (isNaN(timestamp.nanoseconds) ? 0 : timestamp.nanoseconds * 1e-6)
);    
const toMonthDay = formatDate();

// basic tests
const timestamps = [undefined,   // current local date
  {seconds: 1670263910, nanoseconds: 394000000}, // ~ Dec 6 GMT+0800 for rest
  {seconds: 1670263910, nanoseconds: "blah"},
  {seconds: 1670263910},
  {seconds: "foo", nanoseconds: 1667420699000 + 394}
].forEach(timestamp => console.log(toMonthDay(timestampToDate(timestamp))));

Note As a habit I avoid divides as generally divides are slower than multiplies. Its just a habit, in this case the difference between * 1e-6 and / 1e6 is inconsequential.

Note In timestampToDate the names are a little noisy and because the variable timestamp is being used so often one could also write it as

const timestampToDate = (stamp = {}) => new Date(
    (isNaN(stamp.seconds) ? Date.now() : Number(stamp.seconds) * 1000) +
    (isNaN(stamp.nanoseconds) ? 0 : stamp.nanoseconds * 1e-6)
  );    

Answer 2

Considering the discussion from the comment if nanoseconds matter default value can be passed with || if timestamp don't have any of the property.

Can be demonstrated as

function shortMonthDay(timestamp) {
    let date = new Date(timestamp?.seconds * 1000 || Date.now() + (timestamp?.nanoseconds || 0) / 1000000);
    return date.toLocaleDateString('en-US', {
        month: 'short',
        day: 'numeric'
    })
}

const timestamp = {
    "seconds": 1667420699,
    "nanoseconds": 394000000
};

console.log(`with timestamp ${shortMonthDay(timestamp)}`);
console.log(`without timestamp ${shortMonthDay()}`);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Without the timestamp parameter it compromises nanoseconds to 0 and seconds to the current timestamp.

---

Performance

with old snippet

function shortMonthDay(timestamp = undefined) {
  let date

  if (timestamp) {
    date = new Date(timestamp.seconds * 1000 + timestamp.nanoseconds / 1000000)
  } else {
    date = new Date()
  }

  return date.toLocaleDateString('en-US', {
    month: 'short',
    day: 'numeric'
  }) // Nov 2
}

const timestamp = {
    "seconds": 1667420699,
    "nanoseconds": 394000000
};

let res = [];
for(let i = 0; i< 10; i++){
  let start = window.performance.now();
  shortMonthDay(timestamp);
  res.push(window.performance.now() - start);
}
console.log(res);

.as-console-wrapper { max-height: 100% !important; top: 0; }

With the altered snippet

function shortMonthDay(timestamp) {
    let date = new Date(timestamp?.seconds * 1000 || Date.now() + (timestamp?.nanoseconds || 0) / 1000000);
    return date.toLocaleDateString('en-US', {
        month: 'short',
        day: 'numeric'
    })
}

const timestamp = {
    "seconds": 1667420699,
    "nanoseconds": 394000000
};

let res = [];
for(let i = 0; i< 10; i++){
  let start = window.performance.now();
shortMonthDay(timestamp);
res.push(window.performance.now() - start);
}
console.log(res);

.as-console-wrapper { max-height: 100% !important; top: 0; }