
## Basic Rule

Implicit binding applies when we use a function and invoke it as a method of an object. In that case, the `this` keyword points to the object on which the method was invoked.
In the following examples you will notice that the invocation of `getName` was done using the object `person` and thats what made the `this` keyword point to the `person` object.

```js
var person = {
  firstName: "meher",

  getName: function () {
    console.log(this.firstName)
  },
}

person.getName() // outputs meher
```

## Function Outside the Method

Also, it does not matter whether the function was defined within the object or not. Look at the below example, the function's definition location doesn't matter at all. But because the function again invoked using the `person` object, the `this` keyword understand the context and points the to the `person` object.

```js
function getName() {
  console.log(this.firstName)
}

var person = {
  firstName: "meher",
  getName,
}

person.getName() // outputs meher
```

Now, you can notice that because function location doesn't matter, we can use this property to our advantage and create a reusable function(s) that can be run on different objects and return different result. Imagine, if we had `employee` object somewhere in the codebase and a `person` object. Both object can reuse the `firstName` function.

## When Implicit Binding Fails

If you store the function reference in a variable and then invoke the function later. The implicit binding is lost.

```js
var person = {
  firstName: "meher",

  getName: function () {
    console.log(this.firstName)
  },
}

var fn = person.getName

fn() // looks up globally?
```

## Callbacks

In the case of the callbacks, the general rule these days is that whatever is on the left side, which doesn't work . See why:

```js
function getName() {
  console.log(this.firstName)
}

var person = {
  firstName: "meher",

  getName,
}

function displayFirstName(cb) {
  cb()
}

displayFirstName(person.getName)
```

Even when implicit-lost context is passed, the global issue is still raised.

```js
function getName() {
  console.log(this.firstName)
}

var person = {
  firstName: "meher",

  getName,
}

setTimeout(person.getName, 1000)

// An implementation similar to this could be found in a library or native API:

function setTimeout(fn, delay) {
  fn()
}
```


Implicit Binding - THIS Keyword — Part-3


It’s the most common way to invoke a function. You already know it and have seen it a million times. It looks like this:

```js
function name() {
  console.log(this)
}

name()
```

Now, when you load such a code in your browser window through the dev console or an HTML document. The function `name` gets added to the global object, and in the case of a browser (the other being the Node environment), the global object is your window object.

The `window` object contains a number of functions, namespaces, objects, and constructors, and these are available globally across your codebase. And so when we ask JS about `this` within a function like this, what we get back is `window` object:

```js

Window {

    alert: ƒ alert()

    atob: ƒ atob()

    blur: ƒ blur()

    btoa: ƒ btoa()

    caches: CacheStorage {}

    cancelAnimationFrame: ƒ cancelAnimationFrame()

    cancelIdleCallback: ƒ cancelIdleCallback()

    captureEvents: ƒ captureEvents()

    chrome: {loadTimes: ƒ, csi: ƒ}

    clearInterval: ƒ clearInterval()

    clearTimeout: ƒ clearTimeout()

    ...

}

```

## But Why?

When an identifier, in our case, the function name, is added to the global object.

And when we are invoking the name` function, what JavaScript is actually doing behind the scenes is:

```js
window.name()
```

And it should be clear why this keyword is pointing to the window object because our `call-site` clearly shows that name should be invoked from the perspective of the window. And that's why `this` in a function in global scope points to the `window` object.

## Strict Mode

In strict mode, it's quite simple. You will get back `undefined`, which is an appropriate response and avoids all the confusion.

```js
"use strict"

function name() {
  console.log(this) //outputs undefined
}

name()
```

Even this, too...

```js
function name() {
  "use strict"

  console.log(this) //outputs undefined
}

name()
```

So that's one way the value of `this` keyword can have a different value. Now, let's look at the [next part]('/javascript/implicit-binding-this-keyword-part-3) which is [**Implicit Binding**]('/javascript/implicit-binding-this-keyword-part-3')


Default Binding - THIS Keyword — Part-2


In this tutorial, we will look at `this` keyword and break it down into five parts so that each part is bite-sized and easy to comprehend. By the end of this series, you will have a super solid intuitive mental model that will stay with you for the longest time.

## Background

The JavaScript language is quite inspired by the language Scheme. Scheme is the language that has inspired functional programming languages like Haskell and Closure.

But in later stages, the makers of JavaScript noticed a rise in the popularity of Java and decided to make JavaScript look like Java for easier adoption. And that choice brought many features from the object-oriented world into JS. And we know that a functional programming language doesn't have `this` keyword, but object-oriented programming does.

Even though JS decided to mimic the look and feel of Java, from within, JS is very much like Scheme. It does not implement a true object-oriented system, but JS achieves inhertiance by leveraging the prototype model. Although you might say that ES6 has classes, and it is nothing but syntactic sugar over the prototype system.

> ES6 classes are just a syntactic sugar over the Prototype Model.

With all that being said, `this` keyword is very easy concept to understand, and let me show you how.

## Why Do We Need THIS

One way you can see this keyword is as a way to do a 2-dimensional look up in your scope. When you define a variable, the lookup in your scope chain happens from inner to outer functions until you reach the global scope. Now, what if you want one of your variables to look up for data/or-its-value in other parts of your scope? `this` keyword gives us a way to solve it. And there is much more to `this` which we will see in the next part of the series.

Now, you could say that, I could write a function and receive an argument as my data. And you wouldn't be wrong, but that's just another way to solve it.

## Call Site

Call site refers to the location of the function invocation, and it is an important step in determining what the value of `this` keyword is going to be. In some cases, the call-site can get hidden away by libraries and native APIs, e.g., setTimeout, but those cases are limited and predictable.

There is an informal rule that says, whatever is on the left is what this keyword points to. It's a good conclusion to some extent, but nevertheless, how we reach that conclusion is important too.

> 'this' is a run-time binding and not an author-time binding.

## Rules for Call Site

The value of this keyword depends on _how_ the function is invoked. We should now ask ourselves, **how many ways** can a function be invoked in JavaScript? The answer to that question is, there are four ways to invoke a function:

- **Default Binding**

- **Implicit Binding**

- **Explicit binding**

- **new operator Binding**

& then you have your arrow functions. And the value of `this` keyword is determined by those five ways.

In the [next part](/javascript/default-binding-this-keyword-part-2), we will see how [**Default Binding**](/javascript/default-binding-this-keyword-part-2) works.


TIME BUG

Tutorials

They said something about this being the last level of the first chapter... whatever that means!

Implicit Binding - THIS Keyword — Part-3

Default Binding - THIS Keyword — Part-2

THIS Keyword in JavaScript — Part-1

Subscribe to
Savvy Saturday

TIME BUG

Tutorials

They said something about this being the last level of the first chapter... whatever that means!

Implicit Binding - THIS Keyword — Part-3

Default Binding - THIS Keyword — Part-2

THIS Keyword in JavaScript — Part-1

Subscribe to Savvy Saturday

Subscribe to
Savvy Saturday