this rules are the same — what differs is the outer context in browser vs Node.

Top-level this

That's why a beginner trying this === global in a Node script gets false — they're in CJS module scope.

Inside functions

The call site determines this:

function f() { console.log(this); }
f();                          // strict: undefined; sloppy: globalThis
obj.f = f; obj.f();           // obj
f.call(x);                    // x
new f();                      // new instance

Arrow functions

Arrows capture this lexically from their surrounding scope — they have no own this:

const obj = {
  name: "A",
  fn() { return () => this.name; },
};
obj.fn()();   // "A" — the arrow saw `this` of the method

Strict mode

ES modules and class bodies are strict mode. this inside a plain function call is undefined instead of globalThis — safer, catches bugs.

Class methods

class C {
  greet() { return "hi"; }
}
const c = new C();
const m = c.greet;
m();    // TypeError if greet uses this; m's call site lost the binding

Fix: arrow methods (greet = () => ...) or .bind(this) in constructor — or just call via the instance.

Practical advice

• Use globalThis instead of window/global for portable code.
• Prefer arrow functions for callbacks to avoid binding loss.
• Be explicit (.bind, .call, .apply) when passing methods as callbacks.

Interview framing

"Same this rules everywhere — only the outer context differs. In a browser non-module script, top-level this is window. In a Node CommonJS module, it's module.exports, not global. In any ES module, it's undefined. Inside functions, call site wins (object, call/apply/bind, new); arrows capture lexically. Strict mode (everywhere in modules and classes) makes loose calls return undefined instead of the global, which catches bugs. Use globalThis for portable code."