Some (minor) optimizations to base lang.js

Monkey Targets Forums/HTML5/Some (minor) optimizations to base lang.js

Perturbatio

(Posted 2011) [#1]


// Javascript Monkey runtime.
//
// Placed into the public domain 24/02/2011.
// No warranty implied; use at your own risk.

//***** JavaScript Runtime *****

var err_info="",
err_stack=[];

function push_err(){
	err_stack.push( err_info );
}

function pop_err(){
	err_info=err_stack.pop();
}

function stackTrace(){
	var str="",i;
	push_err();
	err_stack.reverse();
	for( i=0;i<err_stack.length;++i ){
		str+=err_stack[i]+"\n";
	}
	err_stack.reverse();
	pop_err();
	return str;
}

function print( str ){
	if( window.console!=undefined ){
		window.console.log( str );
	}
}

function error( err ){
	throw err;
}

function dbg_object( obj ){
	if( obj ) return obj;
	error( "Null object access" );
}

function dbg_array( arr,index ){
	if( index>=0 && index<arr.length ) return arr;
	error( "Array index out of range" );
}

function new_bool_array( len ){
	var arr=Array( len ), i;
	for( i=0;i<len;++i ) arr[i]=false;
	return arr;
}

function new_number_array( len ){
	var arr=Array( len ), i;
	for( i=0;i<len;++i ) arr[i]=0;
	return arr;
}

function new_string_array( len ){
	var arr=Array( len ), i;
	for( i=0;i<len;++i ) arr[i]='';
	return arr;
}

function new_array_array( len ){
	var arr=Array( len ), i;
	for( i=0;i<len;++i ) arr[i]=[];
	return arr;
}

function new_object_array( len ){
	var arr=Array( len ), i;
	for( i=0;i<len;++i ) arr[i]=null;
	return arr;
}

function resize_bool_array( arr,len ){
	var i, ol = arr.length;
	arr.length = len;
	if ( ol < len ){
		for (i = ol-1; i< arr.length; i++){
			if ( typeof arr[i] === 'undefined' ){arr[i] = false;}
		}
	}
	return arr;
}

function resize_number_array( arr,len ){
	var i, ol = arr.length;
	arr.length = len;
	if ( ol < len ){
		for (i = ol-1; i< arr.length; i++){
			if ( typeof arr[i] === 'undefined' ){arr[i] = 0;}
		}
	}
	return arr;
}

function resize_string_array( arr,len ){
	var i, ol = arr.length;
	arr.length = len;
	if ( ol < len ){
		for (i = ol-1; i< arr.length; i++){
			if ( typeof arr[i] === 'undefined' ){arr[i] = '';}
		}
	}
	return arr;
}

function resize_array_array( arr,len ){
	var i, ol = arr.length;
	arr.length = len;
	if ( ol < len ){
		for (i = ol-1; i< arr.length; i++){
			if ( typeof arr[i] === 'undefined' ){arr[i] = [];}
		}
	}
	return arr;
}

function resize_object_array( arr,len ){
	var i, ol = arr.length;
	arr.length = len;
	if ( ol < len ){
		for (i = ol-1; i< arr.length; i++){
			if ( typeof arr[i] === undefined ){arr[i] = null;}
		}
	}
	return arr;
}

function string_join( sep,bits ){
	if( bits.length==0 ) return '';
	return bits.join(sep);
}

function string_trim( str ){
	var i=0,i2=str.length;
	while( i<i2 && str.charCodeAt(i)<=32 ) i+=1;
	while( i2>i && str.charCodeAt(i2-1)<=32 ) i2-=1;
	return str.slice( i,i2 );
}

function string_starts_with( str,substr ){
	return substr.length<=str.length && str.slice(0,substr.length)==substr;
}

function string_ends_with( str,substr ){
	return substr.length<=str.length && str.slice(str.length-substr.length,str.length)==substr;
}

function object_downcast( obj,clas ){
	if( obj instanceof clas ) return obj;
	return null;
}

function extend_class( clas ){
	var tmp=function(){};
	tmp.prototype=clas.prototype;
	return new tmp;
}

Main differences are in array resizing and the string join function, but also grouped var declarations together under 1 var statement where possible.

Not completely tested, but seems to work so far.

Presumably these can also be made to the actionscript file

Beaker

(Posted 2011) [#2]

Here is a note I made recently (Actionscript, possibly js):

function string_join( sep:String,bits:Array ):String{
	if( bits.length==0 ) return '';
	return bits.join(sep);
}

function string_trim( str:String ):String{
	if (str == "") return "";
	var beg = 0, end = str.length-1;
	while (str.charAt(beg).isWhite()) beg++;
	while (str.charAt(end).isWhite()) end--;
	return str.slice(beg, end+1);
}

function string_starts_with( str:String,sub:String ):Boolean{
	return !str.indexOf(sub);
}

function string_ends_with( str:String,sub:String ):Boolean{
	return str.lastIndexOf(sub) == str.length-sub.length;
}

Completely untested.

marksibly

(Posted 2011) [#3]

Hi,

What do these 'optimizations' achieve exactly?

Perturbatio

(Posted 2011) [#4]

The join uses the browser's native array join which should be faster than js.

Grouping var statements at the top of the function is a very minor speed optimization since multiple var statements take longer to parse.

(http://wonko.com/post/try-to-use-one-var-statement-per-scope-in-javascript)

*EDIT*
also, using three equals === is faster since it doesn't do type conversion. (get a javascript console like firebug up and type "0 == false" and the "0 === false" to see)

Perturbatio

(Posted 2011) [#5]

Another potential optimization is when you end up doing feature or browser checks, you can rewrite the function once you know what user agent you have and bypass the need to check each time (especially useful for heavily used functions).

i.e. something like:

var BB = {
	on:function(targetNode, eventName, func){
		if (window.attachEvent){//using IE
			BB.on = function(targetNode, eventName, func){//rewrite the function to use IE's attachEvent
				targetNode.attachEvent(eventName, func);
			};
		} else {//standards compliant
			BB.on = function(targetNode, eventName, func){ //rewrite function with addEventListener
				targetNode.addEventListener(eventName, func, false);
			};
		}
		BB.on(targetNode, eventName, func);//call the new, rewritten function
	} 
};

BB.on(b, "click", function(){alert('here')});

marksibly

(Posted 2011) [#6]

Hi,

> The join uses the browser's native array join which should be faster than js.

OK.

> Grouping var statements at the top of the function is a very minor speed optimization since multiple var statements take longer to parse.

This doesn't sound right to me - JS will only be 'parsed' once into an intermediate format (or they wouldn't be able to get the insane speeds they do) so I don't consider this really worth the obsfucation.

However, I need to remember in general that JS locals aren't properly scoped...

> also, using three equals === is faster since it doesn't do type conversion. (get a javascript console like firebug up and type "0 == false" and the "0 === false" to see)

I thought this did 'identity' comparison? eg: x=5, y=5 but x===y is false as x & y are 'different'?

Not that I've ever used it...

marksibly

(Posted 2011) [#7]

Hi,

> I thought this did 'identity' comparison? eg: x=5, y=5 but x===y is false as x & y are 'different'?

Actually, that's crap...but I do remember having some bizarre issues in php with ===, !== and the like, and ending up hating them with a passion!

But in general, before getting carried away with low-level opts like some of these, I'd kind of like to see some empirical evidence that they actually do something.

I'm a bit worried some of these ideas could do more harm than good - ie: declaring all your vars in one place *can* increase 'register pressure', ie: the chance of a register 'spilling' into memory since you have lots of vars 'live' at one time.

We had the same sort of thing happen in BlitzMax where everyone went byte crazy because 'everyone knows bytes are faster' - but not only are they not faster on 32 bit CPUs, there was also a lot of pointless 'masking' code being generated for the times they had to be converted to ints.

Modern JS engines are pretty awesome, and my inclination is to let them do their thing until we hit some kind of bottle-neck and THEN deal with it.

Beaker

(Posted 2011) [#8]

Agreed. I just couldn't resist tho. It's your code and you need to be happy with maintaining it, but definitely worth a discussion tho.

Perturbatio

(Posted 2011) [#9]

A pretty good explanation of why things like jslint recommend putting vars at the top:

http://stackoverflow.com/questions/1236206/one-var-per-function-in-javascript

The problem is that, whether you realise it or not, javascript invisibly moves all the var declarations to the top of the function scope.

so if you have a function like this

var i = 5
function testvar () {
     alert(i);
     var i=3;
}
testvar();

the alert window will contain undefined. because internally, it's been changed into this:

var i = 5
function testvar () {
     var i;
     alert(i);
     i=3;
}
testvar();

this is called "hoisting". The reason crockford so strongly advocates var declarations go at the top, is that it makes the code visibly match what it's going to do, instead of allowing invisible and unexpected behavior to occur.

Raz	(Posted 2011) [#10]

Speaking from my PHP experience (may be different for js)

=== means the data type needs to be the same.

so

1=="1" would return true
1==="1" would return false because the first is an int, the second is a string

Perturbatio

(Posted 2011) [#11]

=== means the data type needs to be the same.

it's the same in js.