Question: Let's say I have two objects like

```
var a = {
    b: 1,
    c: this.b
};

```

And 

```
var funcObj = {
    b : function() {
        return 1;
    },
    c: function() {
       console.log(return this.b())
    }
}

```

On logging these two like

```
console.log(a.c)//results undefined
console.log(funcObj.c()) //results 1

```

Why can't the first function use the this property but the second one can?
I am really confused.

Answer: 
The answer depends on what `this` refers to in each context. In JavaScript, `this` is bound to whatever object was on the left of the dot (.) when the current function was called. If we're not in a function, things get a little hairier -- `this` is either the global `window` object or `undefined`, depending on the environment.

In your first example, the value of `this` is dependent on the surrounding context. As JavaScript builds your object `a`, it evaluates `this.b`. Whatever object `this` is currently bound to has no `b` property, so the `c` property is set to `undefined`.

In your second example, when you call `funcObj.c()` the `this` in the function gets bound to `funcObj`. So, when you ask for the `b` property, you get the `b` you defined above. The fact that `funcObj.b` is a function is actually irrelevant. The following would work just as well:

```
var funcObj = {
    b :  1,
    c: function() {
       console.log(return this.b)
    }
}

```
I know this post is a bit old, but I came across it while trying to figure out how to solve a similar issue.

I was wanting to do something like:

```
const x = {
  a: 12,
  b: a + 1
}
console.log(x) //results undefined

```

(That's extremely simplified compared to what I was actually doing, but the principle is the same.)

---

My solution was to first create a function that would build the object I wanted, then pass in the primary value I was trying to act on (in this example, the value in 'a'):

```
function buildObj (val) {
  const response = {
    a: val,
    b: val + 1
  };
  return response;
}

```

And then:

```
const x = buildObj(12)

console.log(x) // results { a: 12, b: 13 }

```

---

Once x has been initialized, any subsequent attempt to access 

```
x.a 

```

or

```
x.b

```

will return the values stored therein.

---

If a future searcher comes across this question because they're wanting to take an action on a value stored in a nested key within the same object, hopefully this will help.