function sum(){
        var ret = 0;
        for (var i = 0; i < arguments.length; ++i) {
            ret += arguments[i];
        }
        return ret;
    }

    sum(1, 2, 3) //returns 6

Worth noting though that although we use arguments like an array, it’s not an actual javascript Array — it’s just an object. So you can’t do join(), pop(), push(), slice() and so forth.(You can convert it to a real array if you want: “var argArray = Array.prototype.slice.call(arguments);” )

arguments.callee property refers to the function that is currently running. It provides a way for unnamed function to refer to itself. This allows to make nice recursions:

    function fibonacci(){
        if (arguments.length == 1 && arguments[0] > 2) {
            return arguments.callee(arguments[0] - 2, [0, 1]);
        }
        if (arguments[0] == 0) {
            return arguments[1];
        }
        else {
            var len = arguments[1].length;
            return arguments.callee(arguments[0] - 1, arguments[1].concat(arguments[1][len - 1] + arguments[1][len - 2]));
        }
    }
    fibonacci(7) //returns [0, 1, 1, 2, 3, 5, 8]

Notice that “callee” property allows to do recursion with anonymous functions.

arguments.callee.caller property refers to a method called your function. This could be useful for example if you want to forbid public class creating and allow it for Factory only:

    function MyClass(){
        if (arguments.callee.caller != MyFactory.createObject) {
            throw new Error("There is no public constructor for MyClass.");
        }
        this.myproperty = "hello world";
    }

• Use local variables
• Avoid with statement
• do not use too deep properies, redefine them with locals if possible
• Use the if statement when:
  — There are no more than two discrete values for which to test.
  — There are a large number of values that can be easily separated into ranges.
• Use the switch statement when:
  — There are more than two but fewer than 10 discrete values for which to test.
  — There are no ranges for conditions because the values are nonlinear.
• Use array lookup when:
  — There are more than 10 values for which to test.
  — The results of the conditions are single values rather than a number of actions
  to be taken.
• To improve perfomance of loops decrement the iterator toward 0 rather than incrementing toward the total length.

var observer=[]// simplest ever
function foo(){
     this.foo="foo";
     ....
}
function bar(){
     this.bar="bar";
     ....
}

function observe(child){ //MAGIC
	childName=child.name||child.toString().match(/function\s*([^\(])\s*\(/)[1];
	newConst=function(){
	    ret={};
	    child.apply(ret, arguments);
            observer.push(ret);
	    return ret;
	};
	newConst.name=childName;
	window[childName]=newConst;
}

observe(foo);
observe(bar);

var t1=new foo();
var t2=new bar();

observer // t1,t2

someClass(arg1,arg2,...,argN){
.... //implementation
}

having just an Array of arguments [arg1,arg2,...,argN]. First thought was just to use apply. Next was: how can you use apply on a constructor? But it seems you really can:)

var args=[arg1,arg2,...,argN];
var inst={};// this will be instance of our class
someClass.apply(inst,args);// magic here

You see from this point of view javascript constructor is just a method(function) applied to object cloned from its prototype.

Flash is a great technology but it doesn’t give me direct access to all elements of vector graphics elements. So I need some bridges between JavaScript and Actionscript those “almost” similar both ECMAScript languages. That is very sad.

Great to have SVG!

• use [<string>,<string>,<string>].join(“”) for string concatenation (* this is pretty well known rule)
• use prototype method defining rather than defining method inside closure
• Creating a closure is significantly slower then creating an inner function without a closure, and much slower than reusing a static function.

By the way – in the last one “significantly” means(lower is better)
for Chrome2: 20:10:1
for FireFox3: 500:50:1
for IE6: 2:2:1
I think this is really significantly:)

• writing data
• writing data randomly
• reading data
• reading data randomly

I have tested this in following browsers:

• IE
• FF
• Chrome

I want to point out that i am not comparing browsers. I am comparing two methods of storing data in JavaScript.

I have checked perfomance of following pices of code:

writing [ ]

// initialization
var r=[];
//code to evaluate
for (i=0;i<10000;i++){
    this.r[i]=7;
}

writing {}

// initialization
var r={};
//code to evaluate
for (i=0;i<10000;i++){
    this.r[i]=7;
}

writing [ ] randomly

// initialization
var r=[];
//code to evaluate
for (i=0;i<10000;i++){
    this.r[Math.floor(Math.random(1000))]=7;
}

writing { } randomly

// initialization
var r={};
//code to evaluate
for (i=0;i<10000;i++){
    this.r[Math.floor(Math.random(1000))]=7;
}

Here are results in ms:

Ok the result shows us that the perfomance of Array and Object as storage is almost equal.
So semantically i think it is wise to use array for unordered information and object for mapping.

Javascript performance. Array vs Object

Reading and writing perfomance is not differs too much for this two. So you can easily use Object for mapping purposes and Array for unordered stuff.

details:

I have coded a simple profiler to test some siple pieces of code. Here it is:

function Profile(){

}

Profile.prototype.status = 0;//0 free, 1 busy
Profile.prototype.tests = [];

Profile.prototype.testIt = function(){
    if (!this.status && this.tests.length > 0) {
        var atest = this.tests.shift();
        var that = this;
        var l = setTimeout(function(){
            that.process(atest[0], atest[1], atest[2]);
            that.testIt();
        }, 500);
        this.status = 1;
    }
}

Profile.prototype.profile = function(func, name, before){
    Profile.prototype.tests.push([func, name, before]);
    this.testIt();
}
Profile.prototype.process = function(func, name, before){
    var AVGtime = 0;
    for (var i = 0; i < 20; i++) {
        var scope = {};
        before.call(scope);

        var dbefore = new Date();
        func.call(scope);
        var dafter = new Date();

        AVGtime += dafter.getTime() - dbefore.getTime();
    }
    this.report(func, AVGtime / 20, name);
    this.status = 0;
}
Profile.prototype.report = function(func, avg, name){
    var funcDiv = document.createElement("div");
    var report = "<div class='function' style='font-size: small; border: 1px solid #999; margin: 10px 0 3px 10px; padding: 5px;'>" + func.toString() + "</div";
    report += "<div class='avgTime' style='font-weight: bold;margin: 0 0 0 10px'>" + name + ": " + avg + "ms</div>";
    funcDiv.innerHTML = report;
    document.body.appendChild(funcDiv);
}

Here are the rules and results of all perfomance tests i run.

Javascript performance. Array vs Object

I am writhing a js framework named ARIESjs. I know there are a lot of frameworks around but i have my own vision and i want some things which the can not give. I will post the process of development and o lot of examples here, so stay tuned.