You can achieve this by combining && and ||:

finalData.transactions = (data && data.b && data.b.transactions) || [];

It is making it's way to the ECMA script specification, where we have a null coalescing operator. It is already supported by TypeScript :)

const a = b ?? c;

So right now, if you're using a TypeScript compiler, you can use the operator. However, if you're using just vanilla JS then you will need to implement a null/undefined check manually, unfortunately, due to a general lack of cross-browser support.

At the time of writing, only Chrome and Firefox supports the ?? operator. You can also refer to MDN docs on how it can be used.

You can test here if your browser supports it:

const payload = {
  foo: 0,
  foz: 1,
  bar: '',
  baz: 'Lorem ipsum',
};

console.log(payload.foo ?? 999);  // 0
console.log(payload.foz ?? 999);  // 1
console.log(payload.bar ?? 'Fallback text');  // <empty string>
console.log(payload.baz ?? 'Fallback text');  // Lorem ipsum
console.log(payload.x ?? 'Oh no!'); // Oh no!

console.log(payload.foo || 999);  // 999
console.log(payload.foz || 999);  // 1
console.log(payload.bar || 'Fallback text');  // Fallback text
console.log(payload.baz || 'Fallback text');  // Lorem ipsum
console.log(payload.x || 'Oh no!');  // Oh no!

Is there a builtin function that handles checking for undefined as well as all the arguments?

No, but you can write one yourself.

So maybe I can do this? _call(next, argument1, argument2, ... )

Yes:

function _call(fn, ...args) {
    if (typeof fn == "function") return fn(...args);
}

(using ES6 rest & spread syntax, in ES5 it would be fn.apply(null, Array.prototype.slice.call(arguments, 1))

You can use the qualities of the abstract equality operator to do this:

if (variable == null){
    // your code here.
}

Because null == undefined is true, the above code will catch both null and undefined.

I'm afraid there's no real shorter way of doing this (well technically a minor one and then somewhat more obtuse one)

I tried playing around with the nullish operator ??, but I have to say the working solution seems uglier than what I'm a bout to propose.

Essentially it boils down to the fact, you're looking for the negation of the nullish operator (or alternatively a nullish ternary), neither of which sadly exist (yet).

Here's a relatively compact solution, which just improves upon your solution and simplifies it with the usage of the && logical AND short-circuit operator

const notNullish = (value) =>
  value !== null && typeof value !== 'undefined'

const foo = (a, b) => ({
  ...(notNullish(a) && {a}),
  ...(notNullish(b) && {b}),
 })

console.log('foo(6, 7) =>', foo(6, 2))
console.log('foo(6) =>', foo(6))
console.log('foo() =>', foo())
console.log('foo(0, false) =>', foo(0, false))

Now as I said, there's no optimal way of doing this, because while the you can use the logical ?? to check, it cannot directly assign to object property at the same time. Best I could come up with is:

const notNullish = (key, value) => {
   const nullishCheck = value ?? 'IS_NULLISH'
   return nullishCheck === 'IS_NULLISH'
      ? {}
      : {[key]: value}
}

const foo = (a, b) => ({
   ...notNullish('a', a),
   ...notNullish('b', b)
})

console.log(foo(6, 4))
console.log(foo(6))
console.log(foo())
console.log(foo(0, false))

But personally I find the second snippet kinda ugly and would probably just go with the first option, especially for the following three reasons

1. In my opinion it just looks plain uglier
2. The ?? operator is not yet fully supported on Explorer and Node.js
3. Chances are not a lot of people are even familiar with the operator and it forces you to not even use it directly, but rather as an assignment check.

var lastname = "Hi";

if(typeof lastname !== "undefined")
{
  alert("Hi. Variable is defined.");
} 

It's been years it doesn't make sense anymore to use this construct (unless you don't know whether the variable, not the value, is undefined). undefined is now read only.

Simply use

if (entry[i].getElementsByTagName("url")[0].childNodes[0] === undefined) {

In almost all cases, typeof x === "undefined" is a bad practice.

In the specific case of a DOM element, you can also simply use

if (!entry[i].getElementsByTagName("url")[0].childNodes[0]) {

because you can't have a falsy node, and of course, when the goal is to apply a default value, just use

var foo = entry[i].getElementsByTagName("url")[0].childNodes[0] || 'baar';

(be careful that this test only works when all the parts before the the last [0] are present, it's usually convenient to use querySelector or a DOM selection API like jQuery to make everything less verbose).