"this" value in NodeJS prompt (declared vs expression functions)

Question

I am struggling with the this keyword. I am comparing the value of this within a declared function vs within an expression function.

// Declared function
function declaredFunction() { console.log(this); }

// Expression function
var expressionFunction = (() => { console.log(this); }) ;

I define the two of them in a this.js file and run it with a simple node this.js command.

declaredFunction();
expressionFunction();

declaredFunction() logs the global object in the console :

Object [global] {
  global: [Circular],
  clearInterval: [Function: clearInterval],
  clearTimeout: [Function: clearTimeout],
  setInterval: [Function: setInterval],
  setTimeout: [Function: setTimeout] { [Symbol(util.promisify.custom)]: [Function] },
  queueMicrotask: [Function: queueMicrotask],
  clearImmediate: [Function: clearImmediate],
  setImmediate: [Function: setImmediate] {
    [Symbol(util.promisify.custom)]: [Function]
  }
}

expressionFunction() just logs {}.

Two questions :

1. What is {} (an empty object, obviously, but I don't understand what it is from a semantic point of view); and
2. Why doesn't my expressionFunction() log the global object too?

There is definitely something I don't understand here about how declaring a function differs from assigning a function expression to a variable.

Answer 1

Currently you are comparing the "standard" way of defining JavaScript functions to the 'newer' arrow functions. You can read more about them here.

From the site:

An arrow function expression is a syntactically compact alternative to a regular function expression, although without its own bindings to the this, arguments, super, or new.target keywords. Arrow function expressions are ill suited as methods, and they cannot be used as constructors.

To sum it up, this means that while the this keyword in the arrow function prints an object (which is defined in your program's global scope) the standard one would print empty object (which is defined in its own scope).

Personally, I have been using arrow functions increasingly in projects since sometimes you don't want the function to create its own scope but rather this to point to the main scope.