• To access the object, a method can use the **this** keyword.
• The value of **this** is the object “before dot”, or simply the one that call the method.

let user = {
  name: "John",
  age: 30,
  sayHi() {
    alert(this.name);
  }
};
user.sayHi(); // John

• Technically, it’s also possible to access the object without this, by referencing it via the outer variable, but such code is unreliable as the reference name may change.
• In JavaScript, “**this**” keyword behaves unlike most other programming languages.
• First, it can be used in any function.
  • The value of the following **this** is evaluated during the run-time and it can be anything.

function sayHi() {
  console.log(this.name);
}

• Actually, we can call the function without an object at all.
  • In the following case, **this** is **undefined** in strict mode.
    • If we try to access **this.name**, there will be an error.
  • In non-strict mode, the value of **this** in such case will be the global object (window in a browser).
    • This is a historical behavior that "use strict" fixes.
• Usually a call of a function that uses **this** without an object is not normal, but rather a programming mistake.
  • If a function has **this**, then it is usually meant to be called in the context of an object.

function sayHi() {
  alert(this);
}
sayHi(); // undefined

**this** and Reference Type

• An intricate method call can lose **this** reference.

let user = {
  name: "John",
  hi() { console.log(this.name); },
  bye() { console.log("Bye"); }
};
user.hi(); // John
const targetMethod = (user.name === "John" ? user.hi : user.bye);
targetMethod(); // Undefined, because the context the method call is undefined.

• To make **user.hi()** or targetMethod() calls work, JavaScript uses a trick:
  • The . returns not a function, but a value of the special Reference Type.
  • The Reference Type is a “specification type”, so we can’t explicitly use it, but it is used internally by the language.
• It is a three-value combination **(base, name, strict)**, where:
  • base is the object.
  • name is the property.
  • strict is true if use strict is in effect.
• Therefore, the result of a property access user.hi is not a function, but a value of Reference Type.
• When parentheses () are called on the Reference Type, they receive the full information about the object and its method.

Arrow Functions Have No “this”

• Arrow functions are special: they don’t have their “own” **this**.
• If we reference this from such a function, it’s taken from the outer “normal” function.