Tag: Javascript

// number.toString( [ baseTo ] ); returns number in desired base.
(3).toString( 2 ); 		// returns "11"
(54).toString( 2 );		// returns "110110"
(120).toString( 16 );		// returns "78"

var hex = 0xFF		// hex is 255 in decimal
hex = 0x01 		// now hex is 1 in decimal
var oct = 013		// oct = 11

// parseInt( { number | string }, [ baseFrom ] ); returns decimal number.
num = "110110";
parseInt( num );		// displays 110110 because default base 10.
parseInt( num, 2 );		// displays 54
parseInt( "dad", 16 );		// displays 3501, "dad" is valid hex;
 
var hex = "badDad";	
parseInt( hex, 16 );		// returns 12246445
+("0x"+ hex );			// returns 12246445 (Alternative way to parse hex.)

// Convert from baseA( Binary ) to baseB( Hexadecimal). 
// Note: Both baseA and baseB must be between 2 and 36.
var baseA = 2, baseB = 16;
var binary = 1010111, hex, dec;
dec = parseInt( binary, baseA );		// dec = 87
hex = dec.toString( baseB );		// hex = 57

// Convert from baseA to baseB
// Note: Both baseA and baseB must be between 2 and 36.
var convertNumToBase = function( num, baseA, baseB ){
	if( !( baseA < 2 || baseB < 2 || isNaN( baseA ) 
		|| isNaN(baseB) || baseA > 36 || baseB > 36) ){
        return parseInt( num, baseA ).toString( baseB );
    }
};	
convertNumToBase( 1111, 2, 10 );		// return "15"
convertNumToBase( 10101111, 2, 16 );		// return "af"
convertNumToBase( "FF", 16, 2 ); 		// return "11111111"

var getStrCopy = function (str, copies) {
	var newStr = str;
	copies = (copies > 0) ? copies : 1;
	while (--copies) {
		newStr += str;
	}
	return newStr;
},
convertDecToBase = function ( dec, base, length, padding ) {
	padding = padding || '0' ;
	var num = dec.toString( base );
	length = length || num.length;
	if (num.length !== length) {
		if (num.length < length) {
			num = getStrCopy( padding, (length - num.length)) + num;
		}
		else {
			throw new Error("convertDecToBase(): num(" + num + ").length > length(" + length + ") too long.");
		}
	}
	return num;
};
 
// Usage
convertDecToBase( 23, 2, 8 );            //returns "00010111"
convertDecToBase( 23, 2, 8, 'x' );       //returns "xxx10111"

var num = 70;
~num;			// returns -71
~num.toString(2);	// returns -1000111

binaryStr = "1110001100110001";
binaryStr.replace( /\d{4}/g, '$& ' ).replace( /\s$/,'') // return "1110 0011 0011 0001"
parseInt( binaryStr, 2).toString( 16 );                   // returns "e331"

clear();
var a = parseInt( "1010", 2 );	// a = 10
var b = parseInt( "1100", 2 );	// b = 12
 
(a & b).toString(2);		// a AND b returns dec = 8, binary = 1000
(a | b).toString(2);	        // a OR b returns dec = 14, binary = 1110
(a ^ b);    		        // a XOR b returns dec = 6, binary = 0110
 
//Invalid binary number because of the negative sign.
~b.toString(2);     		// a NOT returns dec = -13, binary = "-1101"
(~( a & b )).toString(2); 	// a NAND b returns dec = -7, binary = "-1001"
(~( a | b )).toString(2);	// a NOR b returns dec = -15, binary = "-1111"
~( a ^ b );                	// a NXOR b returns dec = -7, binary = "-1001"
 
var num = 13; 		        // 13 is "1101" in binary;
var position = 3;
 
// access bit position
(num >> position).toString(2)		// returns 1
(num >> position) & 0x01;		// returns 1
num.toString(2).charAt( position );	// Alternative method, returns '1'
 
// set a bit
( 1 << position ).toString(2);		// returns "1000"
num &= ( 1 << position );		// returns  8, binary "1000"
 
// clear a bit
( 0 << position ).toString(2);		// returns "1000"
num &= ( 0 << position );		// returns 0
 
// Toggle a bit
num ^= ( 1 << position );		// returns 8, binary = "1000"
 
// Test a bit
(num >> position) & 1;			//returns 1
 
// left shift with 0's
num >>> position;			// returns 1
 
// right shift with 0's
num << position;			// returns 64, binary = "1000000"