// assign an anonymous function to a variablevar greet = function(x) {    alert(“Hello, “ + x);};greet(“MSDN readers”);// passing a function as an argument to anotherfunction square(x) {    return x * x;}function operateOn(num, func) {    return func(num);}// displays 256alert(operateOn(16, square));// functions as return valuesfunction makeIncrementer() {    return function(x) { return x + 1; };}var inc = makeIncrementer();// displays 8alert(inc(7));// functions stored as array elementsvar arr = [];arr[0] = function(x) { return x * x; };arr[1] = arr[0](2);arr[2] = arr[0](arr[1]);arr[3] = arr[0](arr[2]);// displays 256alert(arr[3]);// functions as object propertiesvar obj = { “toString” : function() { return “This is an object.”; } };// calls obj.toString()alert(obj);

function displayQuote() {    // the value of “this” will change; depends on     // which object it is called through    alert(this.memorableQuote);    }var williamShakespeare = {    “memorableQuote”: “It is a wise father that knows his own child.”,     “sayIt” : displayQuote};var markTwain = {    “memorableQuote”: “Golf is a good walk spoiled.”,     “sayIt” : displayQuote};var oscarWilde = {    “memorableQuote”: “True friends stab you in the front.”     // we can call the function displayQuote    // as a method of oscarWilde without assigning it     // as oscarWilde’s method.     //”sayIt” : displayQuote};williamShakespeare.sayIt(); // true, truemarkTwain.sayIt(); // he didn’t know where to play golf// watch this, each function has a method call()// that allows the function to be called as a // method of the object passed to call() as an// argument. // this line below is equivalent to assigning// displayQuote to sayIt, and calling oscarWilde.sayIt().displayQuote.call(oscarWilde); // ouch!

var spot = new Dog(“Spot”);// Dog.prototype is the prototype of spotalert(Dog.prototype.isPrototypeOf(spot));// spot inherits the constructor property// from Dog.prototypealert(spot.constructor == Dog.prototype.constructor);alert(spot.constructor == Dog);// But constructor property doesn’t belong// to spot. The line below displays “false”alert(spot.hasOwnProperty(“constructor”));// The constructor property belongs to Dog.prototype// The line below displays “true”alert(Dog.prototype.hasOwnProperty(“constructor”));

function GreatDane() { }var rover = new GreatDane();var spot = new GreatDane();GreatDane.prototype.getBreed = function() {    return “Great Dane”;};// Works, even though at this point// rover and spot are already created.alert(rover.getBreed());// this hides getBreed() in GreatDane.prototypespot.getBreed = function() {    return “Little Great Dane”;};alert(spot.getBreed()); // but of course, the change to getBreed // doesn’t propagate back to GreatDane.prototype// and other objects inheriting from it,// it only happens in the spot objectalert(rover.getBreed());

function filter(pred, arr) {    var len = arr.length;    var filtered = []; // shorter version of new Array();    // iterate through every element in the array...    for(var i = 0; i < len; i++) {        var val = arr[i];        // if the element satisfies the predicate let it through        if(pred(val)) {            filtered.push(val);        }    }    return filtered;}var someRandomNumbers = [12, 32, 1, 3, 2, 2, 234, 236, 632,7, 8];var numbersGreaterThan100 = filter(    function(x) { return (x > 100) ? true : false; },     someRandomNumbers);// displays 234, 236, 632alert(numbersGreaterThan100);

// class Dog : Pet // public Dog(string name, string breed)function Dog(name, breed) {    // think Dog : base(name)     Pet.call(this, name);    this.getBreed = function() { return breed; };    // Breed doesn’t change, obviously! It’s read only.    // this.setBreed = function(newBreed) { name = newName; };}// this makes Dog.prototype inherits// from Pet.prototypeDog.prototype = new Pet();// remember that Pet.prototype.constructor// points to Pet. We want our Dog instances’// constructor to point to Dog.Dog.prototype.constructor = Dog;// Now we override Pet.prototype.toStringDog.prototype.toString = function() {    return “This dog’s name is: “ + this.getName() +         “, and its breed is: “ + this.getBreed();};// end of class Dogvar dog = new Dog(“Buddy”, “Great Dane”);// test the new toString()alert(dog);// Testing instanceof (similar to the is operator)// (dog is Dog)? yesalert(dog instanceof Dog);// (dog is Pet)? yesalert(dog instanceof Pet);// (dog is Object)? yesalert(dog instanceof Object);

MyNamespace.MyClass = function() {    MyNamespace.MyClass.initializeBase(this);    this._myProperty = null;}Then, you need to define the class members itself in its prototype:MyNamespace.MyClass.prototype = {    get_myProperty: function() { return this._myProperty;},    set_myProperty: function(value) { this._myProperty = value; },    doSomething: function() {        MyNamespace.MyClass.callBaseMethod(this, “doSomething”);        /* do something more */    }}

MyNamespace.MyClass.registerClass(    “MyNamespace.MyClass “, MyNamespace.BaseClass);