Javascript object properties and functions

Your code snippet isn't quite valid, but here are a few things it raises:

Property initializers, object initializers

You've asked what shell: cracked is. It's a property initializer. You find them in object initializers (aka "object literals"), which are written like this:

var obj = {
    propName: "propValue"
};

That's equivalent to:

var obj = {};
obj.propName = "propValue";

Both of the above create an object with a property called propName which has a string value "propValue". Note that this doesn't come into it.

Functions

There are a couple of places where functions typically come into it vis-a-vis objects:

Constructor functions

There are constructor functions, which are functions you call via the new operator. Here's an example:

// Constructor function
function Foo(name) {
    this.name = name;
}

// Usage
var f = new Foo("Fred");

Note the use of the keyword this in there. That's where you've seen that (most likely). When you call a constructor function via new, this refers to the new object created by the new operator.

this is a slippery concept in JavaScript (and completely different from this in C++, Java, or C#), I recommend these two (cough) posts on my blog:

• You must remember this
• Mythical methods

Builder/factory functions

You don't have to use constructor functions and new, another pattern uses "builder" or "factory" functions instead:

// A factory function
function fooFactory(name) {
    var rv = {}; // A new, blank object

    rv.name = name;

    return rv;
}

// Usage
var f = fooFactory("Fred");

Private properties

You mentioned "private" properties in your question. JavaScript doesn't have private properties at all (yet, they're on their way). But you see people simulate them, by defining functions they use on the object as closures over an execution context (typically a call to a constructor function or a factory function) which contains variables no one else can see, like this:

// Constructor function
function EverUpwards() {
    var counter = 0;

    this.increment = function() {
        return ++counter;
    };
}

// Usage:
var e = new EverUpwards();
console.log(e.increment()); // "1"
console.log(e.increment()); // "2"

(That example uses a constructor function, but you can do the same thing with a factory function.)

Note that even though the function we assign to increment can access counter, nothing else can. So counter is effectively a private property. This is because the function is a closure. More: Closures are not complicated

You are mixing syntaxes between object property declaration and simple javascript statements.

// declare an object named someObject with one property
var someObject = {
    key: value
};

// declare an anonymous function with some statements in it
// and assign that to a variable named "someFunction"
var someFunction = function () {
    // any javascript statements or expressions can go here
};

There's a key distinction in JavaScript between objects and functions. Objects hold a bunch of data (including functions), and functions can be used to make or modify objects, but they aren't inherently the same thing. OOP in JavaScript is based around using functions as classes. For example, take the following class:

Test = function(){
    this.value = 5;
}

If you just call the function Test(), then nothing will happen. Even if you say var x = Test(), the value of x will be undefined. However, using the new keyword, magic happens! So if we say var x = new Test(), then now the variable x will contain a Test object. If you do console.log(x.value), it would print 5.

That's how we can use functions to make objects. There's also a key different in syntax--a function can contain any sort of JavaScript block you want, whether that's if statements or for loops or what have you. When declaring an object, though, you have to use the key: value syntax.

Hope that clears things up a little bit!