Ce se afișează în consolă dacă folosiți this în…

Depinde de contextul apelului console.log și de modul strict al JavaScript ("use strict").

În contextul global (în afara funcțiilor și modulelor):

În modul non-strict ("use strict" absent sau declarat într-o funcție): this face referire la obiectul global (window în browser, global în Node.js).
În modul strict: this va fi undefined.

În interiorul unei funcții:

În modul non-strict: this face referire la obiectul global dacă funcția este apelată ca funcție normală (myFunction()). Dacă funcția este apelată ca metodă a unui obiect (myObject.myMethod()), this face referire la acel obiect (myObject). Dacă funcția este folosită ca constructor (new MyClass()), this face referire la noua instanță a obiectului.
În modul strict: this va fi undefined dacă funcția este apelată ca funcție normală. În alte cazuri (metodă de obiect, constructor), comportamentul este același ca în modul non-strict.

În interiorul unei funcții săgeată (=>):

this este moștenit lexical din contextul înconjurător. Aceasta înseamnă că valoarea lui this în interiorul unei funcții săgeată va fi aceeași cu cea din funcția normală exterioară sau din contextul global în care a fost declarată, indiferent de modul în care este apelată. Funcțiile săgeată nu leagă this de propriul lor context de apel.

Exemplu:

// Context global
console.log(this); // În browser: Window, în Node.js: global (mod non-strict)
                    // În browser: undefined, în Node.js: undefined (mod strict)

// Funcție normală
function showThisNonStrict() {
  console.log(this);
}

showThisNonStrict(); // În browser: Window, în Node.js: global

function showThisStrict() {
  "use strict";
  console.log(this);
}

showThisStrict(); // undefined

const myObject = {
  methodNonStrict: function() {
    console.log(this);
  },
  methodStrict: function() {
    "use strict";
    console.log(this);
  }
};

myObject.methodNonStrict(); // myObject
myObject.methodStrict();   // myObject

// Funcție săgeată
const arrowFunc = () => {
  console.log(this);
};

arrowFunc(); // În browser: Window, în Node.js: global (moștenit din contextul global)

const myObjectWithArrow = {
  arrowMethod: () => {
    console.log(this);
  }
};

myObjectWithArrow.arrowMethod(); // În browser: Window, în Node.js: global (moștenit din contextul de declarație)

Ce se afișează în consolă dacă folosiți this în console.log?