Question: If I create an object property via [`Object.defineProperty()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty) with a getter/setter method (an accessor descriptor) like:

```
var myObj = function myObj() {
  var myFoo = 'bar';
  Object.defineProperty(this, 'foo', {
    enumerable: true,
    get: function() {
      return myFoo;
    },
    set: function(newValue) {
      myFoo = newValue;
    }
  });
  return this;
};

```

If I do something like `var f = new myObj(); console.log(f)` in Node, the output is something like:

```
{ foo: [Getter/Setter] }

```

`console.log(f.foo)` gets the proper `'bar'` value, but is there a way to indicate that upon logging/inspecting, it should just run the getter and show the value?

Answer: 
First, it's important to understand why this happens. The logging functions don't run getters by design because your getter function could have side effects, whereas the logging function can guarantee that getting the value of a primitive doesn't. 

When you pass an object to [`console.log`](https://github.com/joyent/node/blob/v0.10.25/lib/console.js#L52-54), it's really just passing it off to the `util` module's `inspect` to format into human-readable text. [If we look there](https://github.com/joyent/node/blob/v0.10.25/lib/util.js#L353-409), we see that the very first thing it does is check the property descriptor, and if the property has a getter, it doesn't run it. We can also see that this behavior is unconditional – there's no option to turn it off.

So to force getters to run, you have two options.

The simplest is to convert your object to a string *before* handing it off to `console.log`. Just call `JSON.stringify(obj, null, 4)`, which will produce reasonably human-readable output (but not nearly as nice as `util.inspect`'s). However, you have to take care to ensure that your object doesn't have any circular references and doesn't do something undesired in a [`toJSON` function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#toJSON_behavior).

The other option is to implement a `inspect` function on your object. If `util.inspect` sees a function called `inspect` on an object, it will run that function and use its output. Since the output is entirely up to you, it's a much more involved to produce output that looks like what you'd normally get.

I'd probably start by borrowing code from `util` and stripping out the part about checking for getters.
This behavior is certainly intentional. I know I wouldn't want all the getter functions on an object running whenever I logged that object; that sounds like potential a debugging landmine, where debugging could alter the state of my program.

However, if indeed that *is* the behavior you want, you can add a new function:

```
Object.getPrototypeOf(console).logWithGetters = function(obj) {
    var output = {};
    var propNames = Object.getOwnPropertyNames(obj);

    for(var i=0; i<propNames.length; ++i) {
        var name = propNames[i];
        var prop = Object.getOwnPropertyDescriptor(obj, name);
        if(prop.get) {
            output[name] = prop.get();
        } else {
            output[name] = obj[name];
        }
    }

    // set output proto to input proto; does not work in some IE
    // this is not necessary, but may sometimes be helpful
    output.__proto__ = obj.__proto__;

    return output;
}

```

This allows you to do `console.logWithGetters(f)` and get the output you want. It searches through an object's properties for getters (checking for the existence of `Object.getOwnPropertyDescriptor(obj, propName).get`) and runs them. The output for each property is stored in a new object, which is logged.

Note that this is a bit of a hacky implementation, as it doesn't climb the object's prototype chain.