计算IP地址

/*
*
* 作者：杨志永
* 邮箱：ljy520zhiyong@163.com	
* 版本：V1.0
* 功能：集JavaScript验证于一身
* QQ: 929168233
* 日期：2012-8-17
*
*/

var index = 0;
function MyUtil()
{
	//获取网络地址
	this.getNetWorkAddress = GetNetWorkAddress;
	
	//获取广播地址
	this.getBroadCaseAddress = GetBroadCaseAddress;
	
	//获取可用的主机范围地址
	this.getAllValidateHosts = GetAllValidateHosts;
	
	//返回默认的完整性描述
	this.desc = desc;
}

//获取网络地址
function GetNetWorkAddress(ip, netmask)
{
	//将参数IP地址， 转化为数组，形式类似： var ipArray = ["192", "128", "1", "1"];
	var ipArray = ip.toString().split(".");
	
	//将参数netmask地址， 转化为数组，形式类似： var netmaskArray = ["255", "255", "255", "0"];
	var netmaskArray = netmask.toString().split(".");

	//这个变量用来保存结果，即网络地址的字符串形式表示
	var networkAddress = "";
	
	//开始计算网络地址，公式： 网络地址=IP地址&netmask地址
	for (var i=0; i<ipArray.length; i++)
	{
		//if的判断只是用来使用最后的结果形式为： xxx.xxx.xxx.xxx
		//将最后一个小数点“.”去掉。如果不作判断，结果为：xxx.xxx.xxx.xxx.
		//这样就会在结尾多出一个小数点。
		
		if ( i == (ipArray.length-1) )
		{
			//将IP地址与netmask地址相对应的部分作与运算，然后将结果累加到networkAddress中。
			networkAddress += ( (ipArray[i]) & parseInt(netmaskArray[i]) );
		}
		else
		{
			//将IP地址与netmask地址相对应的部分作与运算，然后将结果累加到networkAddress中。
			networkAddress += ( (ipArray[i]) & parseInt(netmaskArray[i]) ) + ".";
		}
		
	}
	//返回 网络地址 的字符串形式表示
	return ( networkAddress );	
}




function GetBroadCaseAddress(ip, netmask)
{
	//将参数netmask地址， 转化为数组，形式类似： var netmaskArray = ["255", "255", "255", "0"]; 
	var netmaskArray = netmask.toString().split(".")  //255, 255, 255, 0
	
	//这个变量用来保存 netmask 以二进制形式保存时的数组，形式类似：
	// ["11111111", "11111111", "11111111", "00000000"]
	var netmaskBinArray = new Array();
	
	//将参数network地址， 转化为数组，形式类似： var networkArray = ["192", "168", "1", "0"];
	var networkArray = GetNetWorkAddress(ip, netmask).toString().split(".");
	
	//这个变量用来保存 network 地址转化成二进制后的数组。形式类似：
	// ["11111111", "11111111", "11111111", "00000000"]
	var networkBinArray = new Array();
	
	
	//设置一个临时变量，用来保存临时的结果
	var tmp_string = "";
	//设置一个临时数组变量，用来保存临时的数组的结果
	var tmp_array = [0,0,0,0,0,0,0,0];
	
	//netmask 的二进制形式的字符串
	var netmaskString = "";
	
	 //network 的二进制形式的字符串 
	var networkString = "";
	
	//用来保存 广播地址 的数组
	var broadcaseArray = new Array();
	
	//用来保存 广播地址 的最后结果，以字符串形式表示
	var broadcaseString = "";
	
	//设置一个计时器，用来将一个32位的二进制数组分成4组，每数8个数据
	var counter = 0;
	
	
	//在使用之前清空变量
	netmaskString = "";
	var tmptmp = "";
	tmp_array = [0,0,0,0,0,0,0,0];
	
	
	for (var i=0; i<netmaskArray.length; i++)
	{
		 //第i部分的二进制形式的 netmask数组
		 //即将 十进制的 netmask 数据转化为 相应的二进制的形式数据
		 //形式类似： ["1", "1", "1", "1", "1", "1", "1", "1"]
		tmp_string = parseInt(netmaskArray[i]).toString(2).split("");
		
		//如果结果不足八位，则在前面用0来补充，即将结果保存在 临时数组变量 中，要注意相应的位置
		while ( tmp_string.length != 8 )
		{
			for (var qq=8-tmp_string.length, j=0; qq<8 && j< tmp_string.length; qq++, j++)
			{
				
				tmp_array[qq] = tmp_string[j];
				
			}
			tmp_string = tmp_array;
		}
		
		
		if (i == netmaskArray.length -1)
		{
			netmaskString += tmp_string;
		}
		else
		{
			netmaskString += tmp_string + ",";
		}
		
	}
	
	//将 netmaskString 转化为 netmask 数组，是二进制的形式
	netmaskBinArray = netmaskString.split(","); 
	
	//将第一次出现0的位置的索引保存
	var indexOfZeroInnetmaskBinArray = netmaskBinArray.indexOf("0", 0);
	index = (32 - indexOfZeroInnetmaskBinArray);
	
	//将 临时数组变量 清空，以备下一次使用
	tmp_array = [0,0,0,0,0,0,0,0];
	
	for (var i=0; i<networkArray.length; i++)
	{
		 //将 network 地址的第i部分转化为 二进制形式的数组
		tmp_string = parseInt(networkArray[i]).toString(2).split("");
		
		//如果结果不足八位，则在前面用0来补充，即将结果保存在 临时数组变量 中，要注意相应的位置
		while ( tmp_string.length != 8 )
		{
			for (var qq=8-tmp_string.length, j=0; qq<8 && j< tmp_string.length; qq++, j++)
			{
				tmp_array[qq] = tmp_string[j];
				
			}
			tmp_string = tmp_array;
		}
		
		if (i == networkArray.length -1)
		{
			networkString += tmp_string
		}
		else
		
		{
			networkString += tmp_string + ",";
		}
		
	}
	
	// 将network二进制形式的字符串转化为 network 的二进制形式的数组
	networkBinArray = networkString.split(","); 
	
	
	//公式：网络地址中的网络地址部分不变，主机地址变为全1，结果就是广播地址。
	//这里就是将 主机地址全变为1 
	for (var n=indexOfZeroInnetmaskBinArray; n<networkBinArray.length; n++)
	{
		networkBinArray[n] = "1";
	}

	//将 network 地址的二进制形式的数组（32位）分4组，每组8位，结果保存在 broadcaseArray 数组中。
	counter = 0;
	tmp_string = "";
	for (var kk=0; kk<networkBinArray.length; kk++)
	{
		counter++;
		tmp_string  += networkBinArray[kk];
		if ( counter % 8 == 0 )
		{
			broadcaseArray[(counter / 8)  - 1] = tmp_string;
			tmp_string = "";
		}
	}
	
	//清空 broadcaseString 变量
	broadcaseString = "";
	
	//逐个将broadcaseArray数组中的4组二进制数转化为十进制数，结果累加到 broadcaseString
	broadcaseString += BinaryToTen(broadcaseArray[0]) + ".";
	broadcaseString += BinaryToTen(broadcaseArray[1]) + ".";
	broadcaseString += BinaryToTen(broadcaseArray[2]) + ".";
	broadcaseString += BinaryToTen(broadcaseArray[3]);
	
	//返回广播地址
	return (broadcaseString);
}


// 将参数中的二进制数，转化为相应的 十进制数
function BinaryToTen(bin)
{
	var orignaly = bin.toString().split("");
	var result = new Number();
	if ( bin != "" )
	{
		for (var i=orignaly.length-1, j=0; i>=0 && j<orignaly.length; i--, j++)
		{
			result += parseInt(orignaly[j]) * Math.pow(2, i)   ;
		}

		return result;
	}
}


//获取有效的主机IP地址范围
//公式 ：网络地址+1即为第一个主机地址，广播地址-1即为最后一个主机地址

function GetAllValidateHosts(ip, netmask)
{
	var networkAddress = GetNetWorkAddress(ip, netmask).toString().split(".");
	var broadcaseAddress = GetBroadCaseAddress(ip, netmask).toString().split(".");
	//alert("net = " + networkAddress + "<br />" + " broad = " + broadcaseAddress);
	
	var startHost = ( parseInt(networkAddress[3]) + 1 );
	var endHost = ( parseInt(broadcaseAddress[3]) -1);
	
	var startString = "";
	var endString = "";
	
	startString += networkAddress[0] + ".";
	startString += networkAddress[1] + ".";
	startString += networkAddress[2] + ".";
	startString += startHost;
	
	endString += broadcaseAddress[0] + ".";
	endString += broadcaseAddress[1] + ".";
	endString += broadcaseAddress[2] + ".";
	endString += endHost;
	
	return (startString + "--" + endString);
	
}

// 返回默认的结果
//有效主机数为： 主机的数量=2二进制的主机位数-2 

function desc(ip, netmask)
{
	var string = "IP地址为：" + ip + "<br />";
	string += "子网掩码为：" + netmask + "<br />";
	string += "网络地址为：" + ( GetNetWorkAddress(ip, netmask) ) + "<br />";
	string += "广播地址为：" + GetBroadCaseAddress(ip, netmask) + "<br />";
	string += "有效主机范围为：" + GetAllValidateHosts(ip, netmask) + "<br />";
	string += "有效主机数共为："　+　( Math.pow(2, index) - 2 ) + "台<br />";
	
	return string;
}