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: 
You cannot refer to other properties in the declaration as part of a Javascript literal declaration. So, in your Javascript literal declaration:

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

```

`this` is not set to what you want and `a` has not yet been initialized yet so you can't refer to it either. There is simply no way to reach the other properties at the time of the literal declaration. This is a limitation of the current specification for Javascript. You could do this instead:

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

```

because `a` is fully formed at that point so you can then reference other properties in it.

---

Or, in modern browsers, you could even use a getter to get the "live" version of `b` like this (which isn't exactly the same functionality as you were asking for since it's a "live" version of `b` that will track it's value), but shows you another possibility:

```
var a = {
    b: 1,
    get c() {
         return b;
    }
};

console.log(a.c); //results 1

```

---

In your second example:

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

console.log(funcObj.c()) //results 1

```

You are calling `funcObj.c()` and that will set the value of `this` inside of `c` to `funcObj` so thus you can reference other properties via `this`.

---

The main difference here is that `this` is not set to the object inside of Javascript literal definition (your first example), but `this` is set to the object when you invoke a method as in `funcObj.c()`.
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.