算法与设计模式系列2之实现子网掩码的从数字到常用格式的转换

preface

因为linux系统信息采集的需要，需要把数字类型的掩码转换为255.255.0.0这样的格式，尽管python官网提供了IPy这样的模块可以处理这样的事情，，但是本人懒得安装了，所以自己写了 一个算法来做，有兴趣的同学可以参考下。目前还未测试出bug，如果有问题请随时联系本人邮箱18500777133@sina.cn

Python版本

def calc_netmask(netmask):
    '''
    计算子网掩码，由数字类型转为xx.xxx.xx.xx
    算法是这样的： 得到的数字先除以8，得到的商就是有多少个255，余数就需要再计算，余数等于1，那么最后一位子网眼码就是2**(8-1)，8是一段子网眼码长度，
    为8个1，1111111,二进制计算。最后一段眼码计算方式如下：
    余数为1，即2**7，
    余数为2，即2**7+2**6
    余数为3，即2**7+2**6+2**5
    依次类推
    :param netmask:
    :return:
    '''
    if isinstance(netmask,int):
        factor,remainder =netmask.__divmod__(8)
        mi = 8 - remainder   # 计算这个数字的幂
        last_mask = 0
        while mi <= 7:   # 判断掩码长度是否超过了7，超过了长度跳出循环，因为掩码的长度最多是8.
                last_mask = 2**mi + last_mask
                mi=mi+1
        if factor == 1 and last_mask == 0 :  # 意味着是8位的子网掩码
            return_netmask = "%s%s"%(factor*'255.','0.0.0')
        elif (factor == 1 and last_mask != 0 ) :  #意味着8-24之间的子网掩码
            last_mask = '%s.'%last_mask
            return_netmask = "%s%s%s"%(factor*'255.',last_mask,'0.0')
        elif (factor == 2 and last_mask == 0):    #意味着16位整的子网掩码
            return_netmask = "%s0.0"%(factor*'255.')
        elif( factor == 3 and last_mask == 0 ):    # 意味着24位整的掩码
            return_netmask = "%s%s"%(factor*'255.','0')
        elif( factor == 3 and last_mask != 0 ):  #意味着24-32之间的子网掩码
            return_netmask = "%s%s"%(factor*'255.',last_mask)
        elif (factor == 2 and last_mask != 0):   # 意味着16-24位之间子网掩码
            return_netmask = "%s%s.%s"%(factor*'255.',last_mask,'0')
        elif factor == 4:      # 意味着4个255
            return_netmask = "%s255"%((factor-1)*'255.')
        elif factor == 0:          # 小于8位的掩码
            return_netmask = "%s.0.0.0"%(last_mask)
        return return_netmask
    else:
        return False

for i in range(0,33):
    print(i,calc_netmask(i))

打印结果如下：
第一列数字是掩码的数字，第二列是转换后掩码的格式

0 0.0.0.0
1 128.0.0.0
2 192.0.0.0
3 224.0.0.0
4 240.0.0.0
5 248.0.0.0
6 252.0.0.0
7 254.0.0.0
8 255.0.0.0
9 255.128.0.0
10 255.192.0.0
11 255.224.0.0
12 255.240.0.0
13 255.248.0.0
14 255.252.0.0
15 255.254.0.0
16 255.255.0.0
17 255.255.128.0
18 255.255.192.0
19 255.255.224.0
20 255.255.240.0
21 255.255.248.0
22 255.255.252.0
23 255.255.254.0
24 255.255.255.0
25 255.255.255.128
26 255.255.255.192
27 255.255.255.224
28 255.255.255.240
29 255.255.255.248
30 255.255.255.252
31 255.255.255.254
32 255.255.255.255

go版

import (
    "math"
    "fmt"
)
func calcNetmask(netmask int) (return_netmask string) {
    /*
       计算子网掩码，由数字类型转为xx.xxx.xx.xx
       算法是这样的： 得到的数字先除以8，得到的商就是有多少个255，余数就需要再计算，余数等于1，那么最后一位子网眼码就是2**(8-1)，8是一段子网眼码长度，
       为8个1，1111111,二进制计算。最后一段眼码计算方式如下：
       余数为1，即2**7，
       余数为2，即2**7+2**6
       余数为3，即2**7+2**6+2**5
       依次类推
       :param netmask: tmp netmask
       :return:
    */
    factor := netmask / 8    // 商
    remainder := netmask % 8 // 余数
    mi := 8 - remainder      //  计算这个数字的幂
    var tmp_last_mask float64
    for mi <= 7 { // 判断掩码长度是否超过了7，超过了长度跳出循环，因为掩码的长度最多是8.
        tmp_last_mask = math.Pow(float64(2), float64(mi)) + tmp_last_mask
        mi = mi + 1
    }
    last_mask := int(tmp_last_mask)
    switch {
    case factor == 1 && last_mask == 0: // 意味着是8位的子网掩码
        return_netmask = fmt.Sprintf("%s%s", addStr(factor, "255."), "0.0.0")
    case (factor == 1 && last_mask != 0): //意味着8-24之间的子网掩码
        return_netmask = fmt.Sprintf("%s%d.%s", addStr(factor, "255."), last_mask, "0.0")
    case (factor == 2 && last_mask == 0): //意味着16位整的子网掩码
        return_netmask = fmt.Sprintf("%s0.0", addStr(factor, "255."))
    case (factor == 3 && last_mask == 0): // 意味着24位整的掩码
        return_netmask = fmt.Sprintf("%s%s", addStr(factor, "255."), "0")
    case (factor == 3 && last_mask != 0): // 意味着24-32之间的子网掩码
        return_netmask = fmt.Sprintf("%s%d", addStr(factor, "255."), last_mask)
    case (factor == 2 && last_mask != 0): // 意味着16-24位之间子网掩码
        return_netmask = fmt.Sprintf("%s%d.%s", addStr(factor, "255."), last_mask, "0")
    case factor == 4: // 意味着4个255
        return_netmask = fmt.Sprintf("%s255", addStr(factor-1, "255."))
    case factor == 0: // 小于8位的掩码
        return_netmask = fmt.Sprintf("%d.0.0.0", last_mask)
    }
    return return_netmask
}