网络IP范围分析工具

专业的网络IP分析工具,支持子网计算、网络信息展示和IP地址验证

IP地址配置
网络基本信息

请输入IP地址和子网掩码,然后点击"分析网络"

IP地址:
子网掩码:
CIDR表示:
网络地址:
广播地址:
可用IP数量:
总IP数量:
IP地址类型:
是否为私有IP:
IP地址范围

分析结果将显示在这里

IP地址范围:
网关地址 (通常):
DNS服务器 (建议):
二进制表示:
IP地址:
子网掩码:
网络地址:
示例代码

各语言示例代码

  • IPAnalyzer (JAVA)
    IPAnalyzer.java
      1import java.util.regex.Pattern;
                          2import java.util.regex.Matcher;
                          3
                          4/**
                          5 * IP地址分析工具 - Java版本
                          6 * 支持IP地址验证、子网计算、网络信息分析
                          7 */
                          8public class IPAnalyzer {
                          9    private String ipAddress;
                         10    private String subnetMask;
                         11    
                         12    // IP地址正则表达式
                         13    private static final Pattern IP_PATTERN = Pattern.compile(
                         14        "^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$"
                         15    );
                         16    
                         17    public IPAnalyzer() {
                         18        this.ipAddress = "";
                         19        this.subnetMask = "";
                         20    }
                         21    
                         22    /**
                         23     * 验证IP地址格式
                         24     * @param ip IP地址字符串
                         25     * @return 是否有效
                         26     */
                         27    public boolean validateIP(String ip) {
                         28        return IP_PATTERN.matcher(ip).matches();
                         29    }
                         30    
                         31    /**
                         32     * 验证子网掩码格式
                         33     * @param mask 子网掩码字符串
                         34     * @return 是否有效
                         35     */
                         36    public boolean validateSubnetMask(String mask) {
                         37        if (!IP_PATTERN.matcher(mask).matches()) {
                         38            return false;
                         39        }
                         40        
                         41        // 检查是否为有效的子网掩码
                         42        String[] parts = mask.split("\\.");
                         43        StringBuilder binary = new StringBuilder();
                         44        for (String part : parts) {
                         45            int num = Integer.parseInt(part);
                         46            binary.append(String.format("%8s", Integer.toBinaryString(num)).replace(' ', '0'));
                         47        }
                         48        
                         49        String binaryStr = binary.toString();
                         50        int lastOne = binaryStr.lastIndexOf('1');
                         51        int firstZero = binaryStr.indexOf('0');
                         52        
                         53        if (lastOne == -1 || firstZero == -1) {
                         54            return false;
                         55        }
                         56        
                         57        return lastOne < firstZero;
                         58    }
                         59    
                         60    /**
                         61     * CIDR转子网掩码
                         62     * @param cidr CIDR值
                         63     * @return 子网掩码
                         64     */
                         65    public String cidrToSubnetMask(int cidr) {
                         66        if (cidr < 0 || cidr > 32) {
                         67            return "";
                         68        }
                         69        
                         70        int mask = (0xFFFFFFFF << (32 - cidr)) & 0xFFFFFFFF;
                         71        return String.format("%d.%d.%d.%d",
                         72            (mask >> 24) & 255,
                         73            (mask >> 16) & 255,
                         74            (mask >> 8) & 255,
                         75            mask & 255);
                         76    }
                         77    
                         78    /**
                         79     * 子网掩码转CIDR
                         80     * @param mask 子网掩码
                         81     * @return CIDR值
                         82     */
                         83    public int subnetMaskToCidr(String mask) {
                         84        if (!validateSubnetMask(mask)) {
                         85            return -1;
                         86        }
                         87        
                         88        String[] parts = mask.split("\\.");
                         89        StringBuilder binary = new StringBuilder();
                         90        for (String part : parts) {
                         91            int num = Integer.parseInt(part);
                         92            binary.append(String.format("%8s", Integer.toBinaryString(num)).replace(' ', '0'));
                         93        }
                         94        
                         95        int count = 0;
                         96        for (char c : binary.toString().toCharArray()) {
                         97            if (c == '1') count++;
                         98        }
                         99        return count;
                        100    }
                        101    
                        102    /**
                        103     * 获取IP类型
                        104     * @param firstOctet 第一个八位字节
                        105     * @return IP类型
                        106     */
                        107    public String getIPClass(int firstOctet) {
                        108        if (firstOctet >= 1 && firstOctet <= 126) {
                        109            return "A类";
                        110        } else if (firstOctet >= 128 && firstOctet <= 191) {
                        111            return "B类";
                        112        } else if (firstOctet >= 192 && firstOctet <= 223) {
                        113            return "C类";
                        114        } else if (firstOctet >= 224 && firstOctet <= 239) {
                        115            return "D类 (多播)";
                        116        } else if (firstOctet >= 240 && firstOctet <= 255) {
                        117            return "E类 (保留)";
                        118        } else {
                        119            return "未知";
                        120        }
                        121    }
                        122    
                        123    /**
                        124     * 判断是否为私有IP
                        125     * @param parts IP地址的四个部分
                        126     * @return 是否为私有IP
                        127     */
                        128    public boolean isPrivateIP(int[] parts) {
                        129        if (parts.length != 4) {
                        130            return false;
                        131        }
                        132        
                        133        int a = parts[0];
                        134        int b = parts[1];
                        135        
                        136        // A类私有: 10.0.0.0 - 10.255.255.255
                        137        if (a == 10) {
                        138            return true;
                        139        }
                        140        
                        141        // B类私有: 172.16.0.0 - 172.31.255.255
                        142        if (a == 172 && b >= 16 && b <= 31) {
                        143            return true;
                        144        }
                        145        
                        146        // C类私有: 192.168.0.0 - 192.168.255.255
                        147        if (a == 192 && b == 168) {
                        148            return true;
                        149        }
                        150        
                        151        // 链路本地: 169.254.0.0 - 169.254.255.255
                        152        if (a == 169 && b == 254) {
                        153            return true;
                        154        }
                        155        
                        156        // 回环地址: 127.0.0.0 - 127.255.255.255
                        157        if (a == 127) {
                        158            return true;
                        159        }
                        160        
                        161        return false;
                        162    }
                        163    
                        164    /**
                        165     * 网络分析结果类
                        166     */
                        167    public static class NetworkResult {
                        168        public String ipAddress;
                        169        public String subnetMask;
                        170        public String cidr;
                        171        public String networkAddress;
                        172        public String broadcastAddress;
                        173        public int usableHosts;
                        174        public int totalHosts;
                        175        public String firstUsableIP;
                        176        public String lastUsableIP;
                        177        public String gatewayIP;
                        178        public String dnsIP;
                        179        public String ipClass;
                        180        public boolean isPrivate;
                        181        public String ipBinary;
                        182        public String subnetBinary;
                        183        public String networkBinary;
                        184    }
                        185    
                        186    /**
                        187     * 分析网络
                        188     * @param ip IP地址
                        189     * @param mask 子网掩码
                        190     * @return 分析结果
                        191     * @throws IllegalArgumentException 如果输入无效
                        192     */
                        193    public NetworkResult analyzeNetwork(String ip, String mask) throws IllegalArgumentException {
                        194        if (!validateIP(ip)) {
                        195            throw new IllegalArgumentException("无效的IP地址格式");
                        196        }
                        197        
                        198        if (!validateSubnetMask(mask)) {
                        199            throw new IllegalArgumentException("无效的子网掩码格式");
                        200        }
                        201        
                        202        // 解析IP和掩码
                        203        String[] ipParts = ip.split("\\.");
                        204        String[] maskParts = mask.split("\\.");
                        205        
                        206        int[] ipNums = new int[4];
                        207        int[] maskNums = new int[4];
                        208        
                        209        for (int i = 0; i < 4; i++) {
                        210            ipNums[i] = Integer.parseInt(ipParts[i]);
                        211            maskNums[i] = Integer.parseInt(maskParts[i]);
                        212        }
                        213        
                        214        // 计算网络地址
                        215        int[] networkNums = new int[4];
                        216        for (int i = 0; i < 4; i++) {
                        217            networkNums[i] = ipNums[i] & maskNums[i];
                        218        }
                        219        String networkAddress = String.format("%d.%d.%d.%d", 
                        220            networkNums[0], networkNums[1], networkNums[2], networkNums[3]);
                        221        
                        222        // 计算广播地址
                        223        int[] broadcastNums = new int[4];
                        224        for (int i = 0; i < 4; i++) {
                        225            broadcastNums[i] = ipNums[i] | (255 - maskNums[i]);
                        226        }
                        227        String broadcastAddress = String.format("%d.%d.%d.%d", 
                        228            broadcastNums[0], broadcastNums[1], broadcastNums[2], broadcastNums[3]);
                        229        
                        230        // 计算CIDR
                        231        int cidr = subnetMaskToCidr(mask);
                        232        
                        233        // 计算可用主机数
                        234        int totalHosts = (int) Math.pow(2, 32 - cidr);
                        235        int usableHosts = totalHosts - 2;
                        236        
                        237        // 计算第一个和最后一个可用IP
                        238        int[] firstUsableNums = networkNums.clone();
                        239        firstUsableNums[3]++;
                        240        String firstUsableIP = String.format("%d.%d.%d.%d", 
                        241            firstUsableNums[0], firstUsableNums[1], firstUsableNums[2], firstUsableNums[3]);
                        242        
                        243        int[] lastUsableNums = broadcastNums.clone();
                        244        lastUsableNums[3]--;
                        245        String lastUsableIP = String.format("%d.%d.%d.%d", 
                        246            lastUsableNums[0], lastUsableNums[1], lastUsableNums[2], lastUsableNums[3]);
                        247        
                        248        // 计算网关IP (通常是第一个可用IP)
                        249        String gatewayIP = firstUsableIP;
                        250        
                        251        // 计算DNS IP (通常是第二个可用IP)
                        252        int[] dnsNums = firstUsableNums.clone();
                        253        dnsNums[3]++;
                        254        String dnsIP = String.format("%d.%d.%d.%d", 
                        255            dnsNums[0], dnsNums[1], dnsNums[2], dnsNums[3]);
                        256        
                        257        // 判断IP类型
                        258        String ipClass = getIPClass(ipNums[0]);
                        259        boolean isPrivate = isPrivateIP(ipNums);
                        260        
                        261        // 二进制表示
                        262        String ipBinary = String.format("%8s.%8s.%8s.%8s", 
                        263            Integer.toBinaryString(ipNums[0]), 
                        264            Integer.toBinaryString(ipNums[1]), 
                        265            Integer.toBinaryString(ipNums[2]), 
                        266            Integer.toBinaryString(ipNums[3])).replace(' ', '0');
                        267        
                        268        String subnetBinary = String.format("%8s.%8s.%8s.%8s", 
                        269            Integer.toBinaryString(maskNums[0]), 
                        270            Integer.toBinaryString(maskNums[1]), 
                        271            Integer.toBinaryString(maskNums[2]), 
                        272            Integer.toBinaryString(maskNums[3])).replace(' ', '0');
                        273        
                        274        String networkBinary = String.format("%8s.%8s.%8s.%8s", 
                        275            Integer.toBinaryString(networkNums[0]), 
                        276            Integer.toBinaryString(networkNums[1]), 
                        277            Integer.toBinaryString(networkNums[2]), 
                        278            Integer.toBinaryString(networkNums[3])).replace(' ', '0');
                        279        
                        280        NetworkResult result = new NetworkResult();
                        281        result.ipAddress = ip;
                        282        result.subnetMask = mask;
                        283        result.cidr = "/" + cidr;
                        284        result.networkAddress = networkAddress;
                        285        result.broadcastAddress = broadcastAddress;
                        286        result.usableHosts = usableHosts;
                        287        result.totalHosts = totalHosts;
                        288        result.firstUsableIP = firstUsableIP;
                        289        result.lastUsableIP = lastUsableIP;
                        290        result.gatewayIP = gatewayIP;
                        291        result.dnsIP = dnsIP;
                        292        result.ipClass = ipClass;
                        293        result.isPrivate = isPrivate;
                        294        result.ipBinary = ipBinary;
                        295        result.subnetBinary = subnetBinary;
                        296        result.networkBinary = networkBinary;
                        297        
                        298        return result;
                        299    }
                        300    
                        301    public static void main(String[] args) {
                        302        IPAnalyzer analyzer = new IPAnalyzer();
                        303        
                        304        // 示例1: 分析192.168.1.100/24网络
                        305        try {
                        306            NetworkResult result = analyzer.analyzeNetwork("192.168.1.100", "255.255.255.0");
                        307            System.out.println("网络分析结果:");
                        308            System.out.println("  IP地址: " + result.ipAddress);
                        309            System.out.println("  子网掩码: " + result.subnetMask);
                        310            System.out.println("  CIDR表示: " + result.cidr);
                        311            System.out.println("  网络地址: " + result.networkAddress);
                        312            System.out.println("  广播地址: " + result.broadcastAddress);
                        313            System.out.println("  可用IP数量: " + result.usableHosts);
                        314            System.out.println("  总IP数量: " + result.totalHosts);
                        315            System.out.println("  IP地址范围: " + result.firstUsableIP + " - " + result.lastUsableIP);
                        316            System.out.println("  网关地址: " + result.gatewayIP);
                        317            System.out.println("  DNS服务器: " + result.dnsIP);
                        318            System.out.println("  IP地址类型: " + result.ipClass);
                        319            System.out.println("  是否为私有IP: " + result.isPrivate);
                        320        } catch (IllegalArgumentException e) {
                        321            System.out.println("分析失败: " + e.getMessage());
                        322        }
                        323        
                        324        System.out.println();
                        325        
                        326        // 示例2: 验证IP地址
                        327        System.out.println("IP地址验证: " + analyzer.validateIP("192.168.1.100")); // true
                        328        System.out.println("IP地址验证: " + analyzer.validateIP("256.1.2.3"));     // false
                        329        
                        330        // 示例3: 验证子网掩码
                        331        System.out.println("子网掩码验证: " + analyzer.validateSubnetMask("255.255.255.0")); // true
                        332        System.out.println("子网掩码验证: " + analyzer.validateSubnetMask("255.255.255.1")); // false
                        333        
                        334        // 示例4: CIDR转换
                        335        System.out.println("CIDR转掩码: " + analyzer.cidrToSubnetMask(24)); // 255.255.255.0
                        336        System.out.println("掩码转CIDR: " + analyzer.subnetMaskToCidr("255.255.255.0")); // 24
                        337    }
                        338}
                        
  • ip_analyzer (GO)
    ip_analyzer.go
      1package main
                          2
                          3import (
                          4	"fmt"
                          5	"net"
                          6	"regexp"
                          7	"strconv"
                          8	"strings"
                          9)
                         10
                         11// IPAnalyzer IP地址分析工具结构体
                         12type IPAnalyzer struct {
                         13	IPAddress  string
                         14	SubnetMask string
                         15}
                         16
                         17// NetworkResult 网络分析结果
                         18type NetworkResult struct {
                         19	IPAddress        string
                         20	SubnetMask       string
                         21	CIDR             string
                         22	NetworkAddress   string
                         23	BroadcastAddress string
                         24	UsableHosts      int
                         25	TotalHosts       int
                         26	FirstUsableIP    string
                         27	LastUsableIP     string
                         28	GatewayIP        string
                         29	DNSIP            string
                         30	IPClass          string
                         31	IsPrivate        bool
                         32	IPBinary         string
                         33	SubnetBinary     string
                         34	NetworkBinary    string
                         35}
                         36
                         37// NewIPAnalyzer 创建新的IP分析器
                         38func NewIPAnalyzer() *IPAnalyzer {
                         39	return &IPAnalyzer{}
                         40}
                         41
                         42// ValidateIP 验证IP地址格式
                         43func (a *IPAnalyzer) ValidateIP(ip string) bool {
                         44	return net.ParseIP(ip) != nil
                         45}
                         46
                         47// ValidateSubnetMask 验证子网掩码格式
                         48func (a *IPAnalyzer) ValidateSubnetMask(mask string) bool {
                         49	// 检查格式
                         50	ipRegex := regexp.MustCompile(`^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$`)
                         51	if !ipRegex.MatchString(mask) {
                         52		return false
                         53	}
                         54
                         55	// 检查是否为有效的子网掩码
                         56	parts := strings.Split(mask, ".")
                         57	var binary strings.Builder
                         58	for _, part := range parts {
                         59		num, _ := strconv.Atoi(part)
                         60		binary.WriteString(fmt.Sprintf("%08b", num))
                         61	}
                         62
                         63	// 检查是否为连续的1后跟连续的0
                         64	binaryStr := binary.String()
                         65	lastOne := strings.LastIndex(binaryStr, "1")
                         66	firstZero := strings.Index(binaryStr, "0")
                         67
                         68	if lastOne == -1 || firstZero == -1 {
                         69		return false
                         70	}
                         71
                         72	return lastOne < firstZero
                         73}
                         74
                         75// CIDRToSubnetMask CIDR转子网掩码
                         76func (a *IPAnalyzer) CIDRToSubnetMask(cidr int) string {
                         77	if cidr < 0 || cidr > 32 {
                         78		return ""
                         79	}
                         80
                         81	mask := uint32(0xFFFFFFFF) << (32 - cidr)
                         82	return fmt.Sprintf("%d.%d.%d.%d",
                         83		(mask>>24)&255,
                         84		(mask>>16)&255,
                         85		(mask>>8)&255,
                         86		mask&255)
                         87}
                         88
                         89// SubnetMaskToCIDR 子网掩码转CIDR
                         90func (a *IPAnalyzer) SubnetMaskToCIDR(mask string) int {
                         91	if !a.ValidateSubnetMask(mask) {
                         92		return -1
                         93	}
                         94
                         95	parts := strings.Split(mask, ".")
                         96	var binary strings.Builder
                         97	for _, part := range parts {
                         98		num, _ := strconv.Atoi(part)
                         99		binary.WriteString(fmt.Sprintf("%08b", num))
                        100	}
                        101
                        102	return strings.Count(binary.String(), "1")
                        103}
                        104
                        105// GetIPClass 获取IP类型
                        106func (a *IPAnalyzer) GetIPClass(firstOctet int) string {
                        107	switch {
                        108	case firstOctet >= 1 && firstOctet <= 126:
                        109		return "A类"
                        110	case firstOctet >= 128 && firstOctet <= 191:
                        111		return "B类"
                        112	case firstOctet >= 192 && firstOctet <= 223:
                        113		return "C类"
                        114	case firstOctet >= 224 && firstOctet <= 239:
                        115		return "D类 (多播)"
                        116	case firstOctet >= 240 && firstOctet <= 255:
                        117		return "E类 (保留)"
                        118	default:
                        119		return "未知"
                        120	}
                        121}
                        122
                        123// IsPrivateIP 判断是否为私有IP
                        124func (a *IPAnalyzer) IsPrivateIP(parts []int) bool {
                        125	if len(parts) != 4 {
                        126		return false
                        127	}
                        128
                        129	a1, b, _, _ := parts[0], parts[1], parts[2], parts[3]
                        130
                        131	// A类私有: 10.0.0.0 - 10.255.255.255
                        132	if a1 == 10 {
                        133		return true
                        134	}
                        135
                        136	// B类私有: 172.16.0.0 - 172.31.255.255
                        137	if a1 == 172 && b >= 16 && b <= 31 {
                        138		return true
                        139	}
                        140
                        141	// C类私有: 192.168.0.0 - 192.168.255.255
                        142	if a1 == 192 && b == 168 {
                        143		return true
                        144	}
                        145
                        146	// 链路本地: 169.254.0.0 - 169.254.255.255
                        147	if a1 == 169 && b == 254 {
                        148		return true
                        149	}
                        150
                        151	// 回环地址: 127.0.0.0 - 127.255.255.255
                        152	if a1 == 127 {
                        153		return true
                        154	}
                        155
                        156	return false
                        157}
                        158
                        159// AnalyzeNetwork 分析网络
                        160func (a *IPAnalyzer) AnalyzeNetwork(ip, mask string) (*NetworkResult, error) {
                        161	if !a.ValidateIP(ip) {
                        162		return nil, fmt.Errorf("无效的IP地址格式")
                        163	}
                        164
                        165	if !a.ValidateSubnetMask(mask) {
                        166		return nil, fmt.Errorf("无效的子网掩码格式")
                        167	}
                        168
                        169	// 解析IP和掩码
                        170	ipParts := strings.Split(ip, ".")
                        171	maskParts := strings.Split(mask, ".")
                        172
                        173	ipNums := make([]int, 4)
                        174	maskNums := make([]int, 4)
                        175
                        176	for i := 0; i < 4; i++ {
                        177		ipNums[i], _ = strconv.Atoi(ipParts[i])
                        178		maskNums[i], _ = strconv.Atoi(maskParts[i])
                        179	}
                        180
                        181	// 计算网络地址
                        182	networkNums := make([]int, 4)
                        183	for i := 0; i < 4; i++ {
                        184		networkNums[i] = ipNums[i] & maskNums[i]
                        185	}
                        186	networkAddress := fmt.Sprintf("%d.%d.%d.%d", networkNums[0], networkNums[1], networkNums[2], networkNums[3])
                        187
                        188	// 计算广播地址
                        189	broadcastNums := make([]int, 4)
                        190	for i := 0; i < 4; i++ {
                        191		broadcastNums[i] = ipNums[i] | (255 - maskNums[i])
                        192	}
                        193	broadcastAddress := fmt.Sprintf("%d.%d.%d.%d", broadcastNums[0], broadcastNums[1], broadcastNums[2], broadcastNums[3])
                        194
                        195	// 计算CIDR
                        196	cidr := a.SubnetMaskToCIDR(mask)
                        197
                        198	// 计算可用主机数
                        199	totalHosts := 1 << (32 - cidr)
                        200	usableHosts := totalHosts - 2
                        201
                        202	// 计算第一个和最后一个可用IP
                        203	firstUsableNums := make([]int, 4)
                        204	copy(firstUsableNums, networkNums)
                        205	firstUsableNums[3]++
                        206	firstUsableIP := fmt.Sprintf("%d.%d.%d.%d", firstUsableNums[0], firstUsableNums[1], firstUsableNums[2], firstUsableNums[3])
                        207
                        208	lastUsableNums := make([]int, 4)
                        209	copy(lastUsableNums, broadcastNums)
                        210	lastUsableNums[3]--
                        211	lastUsableIP := fmt.Sprintf("%d.%d.%d.%d", lastUsableNums[0], lastUsableNums[1], lastUsableNums[2], lastUsableNums[3])
                        212
                        213	// 计算网关IP (通常是第一个可用IP)
                        214	gatewayIP := firstUsableIP
                        215
                        216	// 计算DNS IP (通常是第二个可用IP)
                        217	dnsNums := make([]int, 4)
                        218	copy(dnsNums, firstUsableNums)
                        219	dnsNums[3]++
                        220	dnsIP := fmt.Sprintf("%d.%d.%d.%d", dnsNums[0], dnsNums[1], dnsNums[2], dnsNums[3])
                        221
                        222	// 判断IP类型
                        223	ipClass := a.GetIPClass(ipNums[0])
                        224	isPrivate := a.IsPrivateIP(ipNums)
                        225
                        226	// 二进制表示
                        227	ipBinary := fmt.Sprintf("%08b.%08b.%08b.%08b", ipNums[0], ipNums[1], ipNums[2], ipNums[3])
                        228	subnetBinary := fmt.Sprintf("%08b.%08b.%08b.%08b", maskNums[0], maskNums[1], maskNums[2], maskNums[3])
                        229	networkBinary := fmt.Sprintf("%08b.%08b.%08b.%08b", networkNums[0], networkNums[1], networkNums[2], networkNums[3])
                        230
                        231	return &NetworkResult{
                        232		IPAddress:        ip,
                        233		SubnetMask:       mask,
                        234		CIDR:             fmt.Sprintf("/%d", cidr),
                        235		NetworkAddress:   networkAddress,
                        236		BroadcastAddress: broadcastAddress,
                        237		UsableHosts:      usableHosts,
                        238		TotalHosts:       totalHosts,
                        239		FirstUsableIP:    firstUsableIP,
                        240		LastUsableIP:     lastUsableIP,
                        241		GatewayIP:        gatewayIP,
                        242		DNSIP:            dnsIP,
                        243		IPClass:          ipClass,
                        244		IsPrivate:        isPrivate,
                        245		IPBinary:         ipBinary,
                        246		SubnetBinary:     subnetBinary,
                        247		NetworkBinary:    networkBinary,
                        248	}, nil
                        249}
                        250
                        251func main() {
                        252	analyzer := NewIPAnalyzer()
                        253
                        254	// 示例1: 分析192.168.1.100/24网络
                        255	result, err := analyzer.AnalyzeNetwork("192.168.1.100", "255.255.255.0")
                        256	if err != nil {
                        257		fmt.Printf("分析失败: %v\n", err)
                        258	} else {
                        259		fmt.Println("网络分析结果:")
                        260		fmt.Printf("  IP地址: %s\n", result.IPAddress)
                        261		fmt.Printf("  子网掩码: %s\n", result.SubnetMask)
                        262		fmt.Printf("  CIDR表示: %s\n", result.CIDR)
                        263		fmt.Printf("  网络地址: %s\n", result.NetworkAddress)
                        264		fmt.Printf("  广播地址: %s\n", result.BroadcastAddress)
                        265		fmt.Printf("  可用IP数量: %d\n", result.UsableHosts)
                        266		fmt.Printf("  总IP数量: %d\n", result.TotalHosts)
                        267		fmt.Printf("  IP地址范围: %s - %s\n", result.FirstUsableIP, result.LastUsableIP)
                        268		fmt.Printf("  网关地址: %s\n", result.GatewayIP)
                        269		fmt.Printf("  DNS服务器: %s\n", result.DNSIP)
                        270		fmt.Printf("  IP地址类型: %s\n", result.IPClass)
                        271		fmt.Printf("  是否为私有IP: %t\n", result.IsPrivate)
                        272	}
                        273
                        274	fmt.Println()
                        275
                        276	// 示例2: 验证IP地址
                        277	fmt.Printf("IP地址验证: %t\n", analyzer.ValidateIP("192.168.1.100")) // true
                        278	fmt.Printf("IP地址验证: %t\n", analyzer.ValidateIP("256.1.2.3"))     // false
                        279
                        280	// 示例3: 验证子网掩码
                        281	fmt.Printf("子网掩码验证: %t\n", analyzer.ValidateSubnetMask("255.255.255.0")) // true
                        282	fmt.Printf("子网掩码验证: %t\n", analyzer.ValidateSubnetMask("255.255.255.1")) // false
                        283
                        284	// 示例4: CIDR转换
                        285	fmt.Printf("CIDR转掩码: %s\n", analyzer.CIDRToSubnetMask(24))              // 255.255.255.0
                        286	fmt.Printf("掩码转CIDR: %d\n", analyzer.SubnetMaskToCIDR("255.255.255.0")) // 24
                        287}
                        
  • ip_analyzer (JAVA)
    ip_analyzer.java
      1import java.util.regex.Pattern;
                          2import java.util.regex.Matcher;
                          3
                          4/**
                          5 * IP地址分析工具 - Java版本
                          6 * 支持IP地址验证、子网计算、网络信息分析
                          7 */
                          8public class IPAnalyzer {
                          9    private String ipAddress;
                         10    private String subnetMask;
                         11    
                         12    // IP地址正则表达式
                         13    private static final Pattern IP_PATTERN = Pattern.compile(
                         14        "^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$"
                         15    );
                         16    
                         17    public IPAnalyzer() {
                         18        this.ipAddress = "";
                         19        this.subnetMask = "";
                         20    }
                         21    
                         22    /**
                         23     * 验证IP地址格式
                         24     * @param ip IP地址字符串
                         25     * @return 是否有效
                         26     */
                         27    public boolean validateIP(String ip) {
                         28        return IP_PATTERN.matcher(ip).matches();
                         29    }
                         30    
                         31    /**
                         32     * 验证子网掩码格式
                         33     * @param mask 子网掩码字符串
                         34     * @return 是否有效
                         35     */
                         36    public boolean validateSubnetMask(String mask) {
                         37        if (!IP_PATTERN.matcher(mask).matches()) {
                         38            return false;
                         39        }
                         40        
                         41        // 检查是否为有效的子网掩码
                         42        String[] parts = mask.split("\\.");
                         43        StringBuilder binary = new StringBuilder();
                         44        for (String part : parts) {
                         45            int num = Integer.parseInt(part);
                         46            binary.append(String.format("%8s", Integer.toBinaryString(num)).replace(' ', '0'));
                         47        }
                         48        
                         49        String binaryStr = binary.toString();
                         50        int lastOne = binaryStr.lastIndexOf('1');
                         51        int firstZero = binaryStr.indexOf('0');
                         52        
                         53        if (lastOne == -1 || firstZero == -1) {
                         54            return false;
                         55        }
                         56        
                         57        return lastOne < firstZero;
                         58    }
                         59    
                         60    /**
                         61     * CIDR转子网掩码
                         62     * @param cidr CIDR值
                         63     * @return 子网掩码
                         64     */
                         65    public String cidrToSubnetMask(int cidr) {
                         66        if (cidr < 0 || cidr > 32) {
                         67            return "";
                         68        }
                         69        
                         70        int mask = (0xFFFFFFFF << (32 - cidr)) & 0xFFFFFFFF;
                         71        return String.format("%d.%d.%d.%d",
                         72            (mask >> 24) & 255,
                         73            (mask >> 16) & 255,
                         74            (mask >> 8) & 255,
                         75            mask & 255);
                         76    }
                         77    
                         78    /**
                         79     * 子网掩码转CIDR
                         80     * @param mask 子网掩码
                         81     * @return CIDR值
                         82     */
                         83    public int subnetMaskToCidr(String mask) {
                         84        if (!validateSubnetMask(mask)) {
                         85            return -1;
                         86        }
                         87        
                         88        String[] parts = mask.split("\\.");
                         89        StringBuilder binary = new StringBuilder();
                         90        for (String part : parts) {
                         91            int num = Integer.parseInt(part);
                         92            binary.append(String.format("%8s", Integer.toBinaryString(num)).replace(' ', '0'));
                         93        }
                         94        
                         95        int count = 0;
                         96        for (char c : binary.toString().toCharArray()) {
                         97            if (c == '1') count++;
                         98        }
                         99        return count;
                        100    }
                        101    
                        102    /**
                        103     * 获取IP类型
                        104     * @param firstOctet 第一个八位字节
                        105     * @return IP类型
                        106     */
                        107    public String getIPClass(int firstOctet) {
                        108        if (firstOctet >= 1 && firstOctet <= 126) {
                        109            return "A类";
                        110        } else if (firstOctet >= 128 && firstOctet <= 191) {
                        111            return "B类";
                        112        } else if (firstOctet >= 192 && firstOctet <= 223) {
                        113            return "C类";
                        114        } else if (firstOctet >= 224 && firstOctet <= 239) {
                        115            return "D类 (多播)";
                        116        } else if (firstOctet >= 240 && firstOctet <= 255) {
                        117            return "E类 (保留)";
                        118        } else {
                        119            return "未知";
                        120        }
                        121    }
                        122    
                        123    /**
                        124     * 判断是否为私有IP
                        125     * @param parts IP地址的四个部分
                        126     * @return 是否为私有IP
                        127     */
                        128    public boolean isPrivateIP(int[] parts) {
                        129        if (parts.length != 4) {
                        130            return false;
                        131        }
                        132        
                        133        int a = parts[0];
                        134        int b = parts[1];
                        135        
                        136        // A类私有: 10.0.0.0 - 10.255.255.255
                        137        if (a == 10) {
                        138            return true;
                        139        }
                        140        
                        141        // B类私有: 172.16.0.0 - 172.31.255.255
                        142        if (a == 172 && b >= 16 && b <= 31) {
                        143            return true;
                        144        }
                        145        
                        146        // C类私有: 192.168.0.0 - 192.168.255.255
                        147        if (a == 192 && b == 168) {
                        148            return true;
                        149        }
                        150        
                        151        // 链路本地: 169.254.0.0 - 169.254.255.255
                        152        if (a == 169 && b == 254) {
                        153            return true;
                        154        }
                        155        
                        156        // 回环地址: 127.0.0.0 - 127.255.255.255
                        157        if (a == 127) {
                        158            return true;
                        159        }
                        160        
                        161        return false;
                        162    }
                        163    
                        164    /**
                        165     * 网络分析结果类
                        166     */
                        167    public static class NetworkResult {
                        168        public String ipAddress;
                        169        public String subnetMask;
                        170        public String cidr;
                        171        public String networkAddress;
                        172        public String broadcastAddress;
                        173        public int usableHosts;
                        174        public int totalHosts;
                        175        public String firstUsableIP;
                        176        public String lastUsableIP;
                        177        public String gatewayIP;
                        178        public String dnsIP;
                        179        public String ipClass;
                        180        public boolean isPrivate;
                        181        public String ipBinary;
                        182        public String subnetBinary;
                        183        public String networkBinary;
                        184    }
                        185    
                        186    /**
                        187     * 分析网络
                        188     * @param ip IP地址
                        189     * @param mask 子网掩码
                        190     * @return 分析结果
                        191     * @throws IllegalArgumentException 如果输入无效
                        192     */
                        193    public NetworkResult analyzeNetwork(String ip, String mask) throws IllegalArgumentException {
                        194        if (!validateIP(ip)) {
                        195            throw new IllegalArgumentException("无效的IP地址格式");
                        196        }
                        197        
                        198        if (!validateSubnetMask(mask)) {
                        199            throw new IllegalArgumentException("无效的子网掩码格式");
                        200        }
                        201        
                        202        // 解析IP和掩码
                        203        String[] ipParts = ip.split("\\.");
                        204        String[] maskParts = mask.split("\\.");
                        205        
                        206        int[] ipNums = new int[4];
                        207        int[] maskNums = new int[4];
                        208        
                        209        for (int i = 0; i < 4; i++) {
                        210            ipNums[i] = Integer.parseInt(ipParts[i]);
                        211            maskNums[i] = Integer.parseInt(maskParts[i]);
                        212        }
                        213        
                        214        // 计算网络地址
                        215        int[] networkNums = new int[4];
                        216        for (int i = 0; i < 4; i++) {
                        217            networkNums[i] = ipNums[i] & maskNums[i];
                        218        }
                        219        String networkAddress = String.format("%d.%d.%d.%d", 
                        220            networkNums[0], networkNums[1], networkNums[2], networkNums[3]);
                        221        
                        222        // 计算广播地址
                        223        int[] broadcastNums = new int[4];
                        224        for (int i = 0; i < 4; i++) {
                        225            broadcastNums[i] = ipNums[i] | (255 - maskNums[i]);
                        226        }
                        227        String broadcastAddress = String.format("%d.%d.%d.%d", 
                        228            broadcastNums[0], broadcastNums[1], broadcastNums[2], broadcastNums[3]);
                        229        
                        230        // 计算CIDR
                        231        int cidr = subnetMaskToCidr(mask);
                        232        
                        233        // 计算可用主机数
                        234        int totalHosts = (int) Math.pow(2, 32 - cidr);
                        235        int usableHosts = totalHosts - 2;
                        236        
                        237        // 计算第一个和最后一个可用IP
                        238        int[] firstUsableNums = networkNums.clone();
                        239        firstUsableNums[3]++;
                        240        String firstUsableIP = String.format("%d.%d.%d.%d", 
                        241            firstUsableNums[0], firstUsableNums[1], firstUsableNums[2], firstUsableNums[3]);
                        242        
                        243        int[] lastUsableNums = broadcastNums.clone();
                        244        lastUsableNums[3]--;
                        245        String lastUsableIP = String.format("%d.%d.%d.%d", 
                        246            lastUsableNums[0], lastUsableNums[1], lastUsableNums[2], lastUsableNums[3]);
                        247        
                        248        // 计算网关IP (通常是第一个可用IP)
                        249        String gatewayIP = firstUsableIP;
                        250        
                        251        // 计算DNS IP (通常是第二个可用IP)
                        252        int[] dnsNums = firstUsableNums.clone();
                        253        dnsNums[3]++;
                        254        String dnsIP = String.format("%d.%d.%d.%d", 
                        255            dnsNums[0], dnsNums[1], dnsNums[2], dnsNums[3]);
                        256        
                        257        // 判断IP类型
                        258        String ipClass = getIPClass(ipNums[0]);
                        259        boolean isPrivate = isPrivateIP(ipNums);
                        260        
                        261        // 二进制表示
                        262        String ipBinary = String.format("%8s.%8s.%8s.%8s", 
                        263            Integer.toBinaryString(ipNums[0]), 
                        264            Integer.toBinaryString(ipNums[1]), 
                        265            Integer.toBinaryString(ipNums[2]), 
                        266            Integer.toBinaryString(ipNums[3])).replace(' ', '0');
                        267        
                        268        String subnetBinary = String.format("%8s.%8s.%8s.%8s", 
                        269            Integer.toBinaryString(maskNums[0]), 
                        270            Integer.toBinaryString(maskNums[1]), 
                        271            Integer.toBinaryString(maskNums[2]), 
                        272            Integer.toBinaryString(maskNums[3])).replace(' ', '0');
                        273        
                        274        String networkBinary = String.format("%8s.%8s.%8s.%8s", 
                        275            Integer.toBinaryString(networkNums[0]), 
                        276            Integer.toBinaryString(networkNums[1]), 
                        277            Integer.toBinaryString(networkNums[2]), 
                        278            Integer.toBinaryString(networkNums[3])).replace(' ', '0');
                        279        
                        280        NetworkResult result = new NetworkResult();
                        281        result.ipAddress = ip;
                        282        result.subnetMask = mask;
                        283        result.cidr = "/" + cidr;
                        284        result.networkAddress = networkAddress;
                        285        result.broadcastAddress = broadcastAddress;
                        286        result.usableHosts = usableHosts;
                        287        result.totalHosts = totalHosts;
                        288        result.firstUsableIP = firstUsableIP;
                        289        result.lastUsableIP = lastUsableIP;
                        290        result.gatewayIP = gatewayIP;
                        291        result.dnsIP = dnsIP;
                        292        result.ipClass = ipClass;
                        293        result.isPrivate = isPrivate;
                        294        result.ipBinary = ipBinary;
                        295        result.subnetBinary = subnetBinary;
                        296        result.networkBinary = networkBinary;
                        297        
                        298        return result;
                        299    }
                        300    
                        301    public static void main(String[] args) {
                        302        IPAnalyzer analyzer = new IPAnalyzer();
                        303        
                        304        // 示例1: 分析192.168.1.100/24网络
                        305        try {
                        306            NetworkResult result = analyzer.analyzeNetwork("192.168.1.100", "255.255.255.0");
                        307            System.out.println("网络分析结果:");
                        308            System.out.println("  IP地址: " + result.ipAddress);
                        309            System.out.println("  子网掩码: " + result.subnetMask);
                        310            System.out.println("  CIDR表示: " + result.cidr);
                        311            System.out.println("  网络地址: " + result.networkAddress);
                        312            System.out.println("  广播地址: " + result.broadcastAddress);
                        313            System.out.println("  可用IP数量: " + result.usableHosts);
                        314            System.out.println("  总IP数量: " + result.totalHosts);
                        315            System.out.println("  IP地址范围: " + result.firstUsableIP + " - " + result.lastUsableIP);
                        316            System.out.println("  网关地址: " + result.gatewayIP);
                        317            System.out.println("  DNS服务器: " + result.dnsIP);
                        318            System.out.println("  IP地址类型: " + result.ipClass);
                        319            System.out.println("  是否为私有IP: " + result.isPrivate);
                        320        } catch (IllegalArgumentException e) {
                        321            System.out.println("分析失败: " + e.getMessage());
                        322        }
                        323        
                        324        System.out.println();
                        325        
                        326        // 示例2: 验证IP地址
                        327        System.out.println("IP地址验证: " + analyzer.validateIP("192.168.1.100")); // true
                        328        System.out.println("IP地址验证: " + analyzer.validateIP("256.1.2.3"));     // false
                        329        
                        330        // 示例3: 验证子网掩码
                        331        System.out.println("子网掩码验证: " + analyzer.validateSubnetMask("255.255.255.0")); // true
                        332        System.out.println("子网掩码验证: " + analyzer.validateSubnetMask("255.255.255.1")); // false
                        333        
                        334        // 示例4: CIDR转换
                        335        System.out.println("CIDR转掩码: " + analyzer.cidrToSubnetMask(24)); // 255.255.255.0
                        336        System.out.println("掩码转CIDR: " + analyzer.subnetMaskToCidr("255.255.255.0")); // 24
                        337    }
                        338}
                        
  • ip_analyzer (JS)
    ip_analyzer.js
      1/**
                          2 * IP地址分析工具 - JavaScript版本
                          3 * 支持IP地址验证、子网计算、网络信息分析
                          4 */
                          5
                          6class IPAnalyzer {
                          7    constructor() {
                          8        this.ipAddress = '';
                          9        this.subnetMask = '';
                         10    }
                         11
                         12    /**
                         13     * 验证IP地址格式
                         14     * @param {string} ip - IP地址
                         15     * @returns {boolean} 是否有效
                         16     */
                         17    validateIP(ip) {
                         18        const ipRegex = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
                         19        return ipRegex.test(ip);
                         20    }
                         21
                         22    /**
                         23     * 验证子网掩码格式
                         24     * @param {string} mask - 子网掩码
                         25     * @returns {boolean} 是否有效
                         26     */
                         27    validateSubnetMask(mask) {
                         28        const maskRegex = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
                         29        if (!maskRegex.test(mask)) return false;
                         30        
                         31        const parts = mask.split('.').map(Number);
                         32        const binary = parts.map(part => part.toString(2).padStart(8, '0')).join('');
                         33        return /^1*0*$/.test(binary);
                         34    }
                         35
                         36    /**
                         37     * CIDR转子网掩码
                         38     * @param {number} cidr - CIDR值
                         39     * @returns {string} 子网掩码
                         40     */
                         41    cidrToSubnetMask(cidr) {
                         42        const mask = (0xFFFFFFFF << (32 - cidr)) >>> 0;
                         43        return [
                         44            (mask >>> 24) & 255,
                         45            (mask >>> 16) & 255,
                         46            (mask >>> 8) & 255,
                         47            mask & 255
                         48        ].join('.');
                         49    }
                         50
                         51    /**
                         52     * 子网掩码转CIDR
                         53     * @param {string} mask - 子网掩码
                         54     * @returns {number} CIDR值
                         55     */
                         56    subnetMaskToCidr(mask) {
                         57        const parts = mask.split('.').map(Number);
                         58        const binary = parts.map(part => part.toString(2).padStart(8, '0')).join('');
                         59        return binary.split('1').length - 1;
                         60    }
                         61
                         62    /**
                         63     * 获取IP类型
                         64     * @param {number} firstOctet - 第一个八位字节
                         65     * @returns {string} IP类型
                         66     */
                         67    getIPClass(firstOctet) {
                         68        if (firstOctet >= 1 && firstOctet <= 126) return 'A类';
                         69        if (firstOctet >= 128 && firstOctet <= 191) return 'B类';
                         70        if (firstOctet >= 192 && firstOctet <= 223) return 'C类';
                         71        if (firstOctet >= 224 && firstOctet <= 239) return 'D类 (多播)';
                         72        if (firstOctet >= 240 && firstOctet <= 255) return 'E类 (保留)';
                         73        return '未知';
                         74    }
                         75
                         76    /**
                         77     * 判断是否为私有IP
                         78     * @param {Array} parts - IP地址的四个部分
                         79     * @returns {boolean} 是否为私有IP
                         80     */
                         81    isPrivateIP(parts) {
                         82        const [a, b, c, d] = parts;
                         83        
                         84        // A类私有: 10.0.0.0 - 10.255.255.255
                         85        if (a === 10) return true;
                         86        
                         87        // B类私有: 172.16.0.0 - 172.31.255.255
                         88        if (a === 172 && b >= 16 && b <= 31) return true;
                         89        
                         90        // C类私有: 192.168.0.0 - 192.168.255.255
                         91        if (a === 192 && b === 168) return true;
                         92        
                         93        // 链路本地: 169.254.0.0 - 169.254.255.255
                         94        if (a === 169 && b === 254) return true;
                         95        
                         96        // 回环地址: 127.0.0.0 - 127.255.255.255
                         97        if (a === 127) return true;
                         98        
                         99        return false;
                        100    }
                        101
                        102    /**
                        103     * 分析网络
                        104     * @param {string} ip - IP地址
                        105     * @param {string} mask - 子网掩码
                        106     * @returns {Object} 分析结果
                        107     */
                        108    analyzeNetwork(ip, mask) {
                        109        if (!this.validateIP(ip)) {
                        110            throw new Error('无效的IP地址格式');
                        111        }
                        112        
                        113        if (!this.validateSubnetMask(mask)) {
                        114            throw new Error('无效的子网掩码格式');
                        115        }
                        116
                        117        const ipParts = ip.split('.').map(Number);
                        118        const maskParts = mask.split('.').map(Number);
                        119        
                        120        // 计算网络地址
                        121        const networkParts = ipParts.map((part, i) => part & maskParts[i]);
                        122        const networkAddress = networkParts.join('.');
                        123        
                        124        // 计算广播地址
                        125        const broadcastParts = ipParts.map((part, i) => part | (255 - maskParts[i]));
                        126        const broadcastAddress = broadcastParts.join('.');
                        127        
                        128        // 计算CIDR
                        129        const cidr = this.subnetMaskToCidr(mask);
                        130        
                        131        // 计算可用主机数
                        132        const totalHosts = Math.pow(2, 32 - cidr);
                        133        const usableHosts = totalHosts - 2;
                        134        
                        135        // 计算第一个和最后一个可用IP
                        136        const firstUsableParts = networkParts.map((part, i) => i === 3 ? part + 1 : part);
                        137        const lastUsableParts = broadcastParts.map((part, i) => i === 3 ? part - 1 : part);
                        138        const firstUsableIP = firstUsableParts.join('.');
                        139        const lastUsableIP = lastUsableParts.join('.');
                        140        
                        141        // 计算网关IP (通常是第一个可用IP)
                        142        const gatewayIP = firstUsableIP;
                        143        
                        144        // 计算DNS IP (通常是第二个可用IP)
                        145        const dnsParts = firstUsableParts.map((part, i) => i === 3 ? part + 1 : part);
                        146        const dnsIP = dnsParts.join('.');
                        147        
                        148        // 判断IP类型
                        149        const ipClass = this.getIPClass(ipParts[0]);
                        150        const isPrivate = this.isPrivateIP(ipParts);
                        151        
                        152        // 二进制表示
                        153        const ipBinary = ipParts.map(part => part.toString(2).padStart(8, '0')).join('.');
                        154        const subnetBinary = maskParts.map(part => part.toString(2).padStart(8, '0')).join('.');
                        155        const networkBinary = networkParts.map(part => part.toString(2).padStart(8, '0')).join('.');
                        156        
                        157        return {
                        158            ipAddress: ip,
                        159            subnetMask: mask,
                        160            cidr: '/' + cidr,
                        161            networkAddress: networkAddress,
                        162            broadcastAddress: broadcastAddress,
                        163            usableHosts: usableHosts,
                        164            totalHosts: totalHosts,
                        165            firstUsableIP: firstUsableIP,
                        166            lastUsableIP: lastUsableIP,
                        167            gatewayIP: gatewayIP,
                        168            dnsIP: dnsIP,
                        169            ipClass: ipClass,
                        170            isPrivate: isPrivate,
                        171            ipBinary: ipBinary,
                        172            subnetBinary: subnetBinary,
                        173            networkBinary: networkBinary
                        174        };
                        175    }
                        176}
                        177
                        178// 使用示例
                        179const analyzer = new IPAnalyzer();
                        180
                        181// 示例1: 分析192.168.1.100/24网络
                        182try {
                        183    const result = analyzer.analyzeNetwork('192.168.1.100', '255.255.255.0');
                        184    console.log('网络分析结果:', result);
                        185} catch (error) {
                        186    console.error('分析失败:', error.message);
                        187}
                        188
                        189// 示例2: 验证IP地址
                        190console.log('IP地址验证:', analyzer.validateIP('192.168.1.100')); // true
                        191console.log('IP地址验证:', analyzer.validateIP('256.1.2.3')); // false
                        192
                        193// 示例3: 验证子网掩码
                        194console.log('子网掩码验证:', analyzer.validateSubnetMask('255.255.255.0')); // true
                        195console.log('子网掩码验证:', analyzer.validateSubnetMask('255.255.255.1')); // false
                        196
                        197// 示例4: CIDR转换
                        198console.log('CIDR转掩码:', analyzer.cidrToSubnetMask(24)); // 255.255.255.0
                        199console.log('掩码转CIDR:', analyzer.subnetMaskToCidr('255.255.255.0')); // 24
                        
  • ip_analyzer (PHP)
    ip_analyzer.php
      1<?php
                          2/**
                          3 * IP地址分析工具 - PHP版本
                          4 * 支持IP地址验证、子网计算、网络信息分析
                          5 */
                          6
                          7class IPAnalyzer {
                          8    private $ipAddress;
                          9    private $subnetMask;
                         10    
                         11    public function __construct() {
                         12        $this->ipAddress = '';
                         13        $this->subnetMask = '';
                         14    }
                         15    
                         16    /**
                         17     * 验证IP地址格式
                         18     * @param string $ip IP地址字符串
                         19     * @return bool 是否有效
                         20     */
                         21    public function validateIP($ip) {
                         22        return filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4) !== false;
                         23    }
                         24    
                         25    /**
                         26     * 验证子网掩码格式
                         27     * @param string $mask 子网掩码字符串
                         28     * @return bool 是否有效
                         29     */
                         30    public function validateSubnetMask($mask) {
                         31        // 检查格式
                         32        if (!filter_var($mask, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4)) {
                         33            return false;
                         34        }
                         35        
                         36        // 检查是否为有效的子网掩码
                         37        $parts = explode('.', $mask);
                         38        $binary = '';
                         39        foreach ($parts as $part) {
                         40            $binary .= str_pad(decbin($part), 8, '0', STR_PAD_LEFT);
                         41        }
                         42        
                         43        // 检查是否为连续的1后跟连续的0
                         44        $lastOne = strrpos($binary, '1');
                         45        $firstZero = strpos($binary, '0');
                         46        
                         47        if ($lastOne === false || $firstZero === false) {
                         48            return false;
                         49        }
                         50        
                         51        return $lastOne < $firstZero;
                         52    }
                         53    
                         54    /**
                         55     * CIDR转子网掩码
                         56     * @param int $cidr CIDR值
                         57     * @return string 子网掩码
                         58     */
                         59    public function cidrToSubnetMask($cidr) {
                         60        if ($cidr < 0 || $cidr > 32) {
                         61            return '';
                         62        }
                         63        
                         64        $mask = (0xFFFFFFFF << (32 - $cidr)) & 0xFFFFFFFF;
                         65        return sprintf('%d.%d.%d.%d',
                         66            ($mask >> 24) & 255,
                         67            ($mask >> 16) & 255,
                         68            ($mask >> 8) & 255,
                         69            $mask & 255);
                         70    }
                         71    
                         72    /**
                         73     * 子网掩码转CIDR
                         74     * @param string $mask 子网掩码
                         75     * @return int CIDR值
                         76     */
                         77    public function subnetMaskToCidr($mask) {
                         78        if (!$this->validateSubnetMask($mask)) {
                         79            return -1;
                         80        }
                         81        
                         82        $parts = explode('.', $mask);
                         83        $binary = '';
                         84        foreach ($parts as $part) {
                         85            $binary .= str_pad(decbin($part), 8, '0', STR_PAD_LEFT);
                         86        }
                         87        
                         88        return substr_count($binary, '1');
                         89    }
                         90    
                         91    /**
                         92     * 获取IP类型
                         93     * @param int $firstOctet 第一个八位字节
                         94     * @return string IP类型
                         95     */
                         96    public function getIPClass($firstOctet) {
                         97        if ($firstOctet >= 1 && $firstOctet <= 126) {
                         98            return 'A类';
                         99        } elseif ($firstOctet >= 128 && $firstOctet <= 191) {
                        100            return 'B类';
                        101        } elseif ($firstOctet >= 192 && $firstOctet <= 223) {
                        102            return 'C类';
                        103        } elseif ($firstOctet >= 224 && $firstOctet <= 239) {
                        104            return 'D类 (多播)';
                        105        } elseif ($firstOctet >= 240 && $firstOctet <= 255) {
                        106            return 'E类 (保留)';
                        107        } else {
                        108            return '未知';
                        109        }
                        110    }
                        111    
                        112    /**
                        113     * 判断是否为私有IP
                        114     * @param array $parts IP地址的四个部分
                        115     * @return bool 是否为私有IP
                        116     */
                        117    public function isPrivateIP($parts) {
                        118        if (count($parts) != 4) {
                        119            return false;
                        120        }
                        121        
                        122        $a = $parts[0];
                        123        $b = $parts[1];
                        124        
                        125        // A类私有: 10.0.0.0 - 10.255.255.255
                        126        if ($a == 10) {
                        127            return true;
                        128        }
                        129        
                        130        // B类私有: 172.16.0.0 - 172.31.255.255
                        131        if ($a == 172 && $b >= 16 && $b <= 31) {
                        132            return true;
                        133        }
                        134        
                        135        // C类私有: 192.168.0.0 - 192.168.255.255
                        136        if ($a == 192 && $b == 168) {
                        137            return true;
                        138        }
                        139        
                        140        // 链路本地: 169.254.0.0 - 169.254.255.255
                        141        if ($a == 169 && $b == 254) {
                        142            return true;
                        143        }
                        144        
                        145        // 回环地址: 127.0.0.0 - 127.255.255.255
                        146        if ($a == 127) {
                        147            return true;
                        148        }
                        149        
                        150        return false;
                        151    }
                        152    
                        153    /**
                        154     * 分析网络
                        155     * @param string $ip IP地址
                        156     * @param string $mask 子网掩码
                        157     * @return array 分析结果
                        158     * @throws Exception 如果输入无效
                        159     */
                        160    public function analyzeNetwork($ip, $mask) {
                        161        if (!$this->validateIP($ip)) {
                        162            throw new Exception('无效的IP地址格式');
                        163        }
                        164        
                        165        if (!$this->validateSubnetMask($mask)) {
                        166            throw new Exception('无效的子网掩码格式');
                        167        }
                        168        
                        169        // 解析IP和掩码
                        170        $ipParts = explode('.', $ip);
                        171        $maskParts = explode('.', $mask);
                        172        
                        173        $ipNums = array_map('intval', $ipParts);
                        174        $maskNums = array_map('intval', $maskParts);
                        175        
                        176        // 计算网络地址
                        177        $networkNums = [];
                        178        for ($i = 0; $i < 4; $i++) {
                        179            $networkNums[$i] = $ipNums[$i] & $maskNums[$i];
                        180        }
                        181        $networkAddress = implode('.', $networkNums);
                        182        
                        183        // 计算广播地址
                        184        $broadcastNums = [];
                        185        for ($i = 0; $i < 4; $i++) {
                        186            $broadcastNums[$i] = $ipNums[$i] | (255 - $maskNums[$i]);
                        187        }
                        188        $broadcastAddress = implode('.', $broadcastNums);
                        189        
                        190        // 计算CIDR
                        191        $cidr = $this->subnetMaskToCidr($mask);
                        192        
                        193        // 计算可用主机数
                        194        $totalHosts = pow(2, 32 - $cidr);
                        195        $usableHosts = $totalHosts - 2;
                        196        
                        197        // 计算第一个和最后一个可用IP
                        198        $firstUsableNums = $networkNums;
                        199        $firstUsableNums[3]++;
                        200        $firstUsableIP = implode('.', $firstUsableNums);
                        201        
                        202        $lastUsableNums = $broadcastNums;
                        203        $lastUsableNums[3]--;
                        204        $lastUsableIP = implode('.', $lastUsableNums);
                        205        
                        206        // 计算网关IP (通常是第一个可用IP)
                        207        $gatewayIP = $firstUsableIP;
                        208        
                        209        // 计算DNS IP (通常是第二个可用IP)
                        210        $dnsNums = $firstUsableNums;
                        211        $dnsNums[3]++;
                        212        $dnsIP = implode('.', $dnsNums);
                        213        
                        214        // 判断IP类型
                        215        $ipClass = $this->getIPClass($ipNums[0]);
                        216        $isPrivate = $this->isPrivateIP($ipNums);
                        217        
                        218        // 二进制表示
                        219        $ipBinary = implode('.', array_map(function($num) {
                        220            return str_pad(decbin($num), 8, '0', STR_PAD_LEFT);
                        221        }, $ipNums));
                        222        
                        223        $subnetBinary = implode('.', array_map(function($num) {
                        224            return str_pad(decbin($num), 8, '0', STR_PAD_LEFT);
                        225        }, $maskNums));
                        226        
                        227        $networkBinary = implode('.', array_map(function($num) {
                        228            return str_pad(decbin($num), 8, '0', STR_PAD_LEFT);
                        229        }, $networkNums));
                        230        
                        231        return [
                        232            'ipAddress' => $ip,
                        233            'subnetMask' => $mask,
                        234            'cidr' => '/' . $cidr,
                        235            'networkAddress' => $networkAddress,
                        236            'broadcastAddress' => $broadcastAddress,
                        237            'usableHosts' => $usableHosts,
                        238            'totalHosts' => $totalHosts,
                        239            'firstUsableIP' => $firstUsableIP,
                        240            'lastUsableIP' => $lastUsableIP,
                        241            'gatewayIP' => $gatewayIP,
                        242            'dnsIP' => $dnsIP,
                        243            'ipClass' => $ipClass,
                        244            'isPrivate' => $isPrivate,
                        245            'ipBinary' => $ipBinary,
                        246            'subnetBinary' => $subnetBinary,
                        247            'networkBinary' => $networkBinary
                        248        ];
                        249    }
                        250}
                        251
                        252// 使用示例
                        253$analyzer = new IPAnalyzer();
                        254
                        255// 示例1: 分析192.168.1.100/24网络
                        256try {
                        257    $result = $analyzer->analyzeNetwork('192.168.1.100', '255.255.255.0');
                        258    echo "网络分析结果:\n";
                        259    foreach ($result as $key => $value) {
                        260        echo "  $key: " . (is_bool($value) ? ($value ? 'true' : 'false') : $value) . "\n";
                        261    }
                        262} catch (Exception $e) {
                        263    echo "分析失败: " . $e->getMessage() . "\n";
                        264}
                        265
                        266echo "\n";
                        267
                        268// 示例2: 验证IP地址
                        269echo "IP地址验证: " . ($analyzer->validateIP('192.168.1.100') ? 'true' : 'false') . "\n"; // true
                        270echo "IP地址验证: " . ($analyzer->validateIP('256.1.2.3') ? 'true' : 'false') . "\n";     // false
                        271
                        272// 示例3: 验证子网掩码
                        273echo "子网掩码验证: " . ($analyzer->validateSubnetMask('255.255.255.0') ? 'true' : 'false') . "\n"; // true
                        274echo "子网掩码验证: " . ($analyzer->validateSubnetMask('255.255.255.1') ? 'true' : 'false') . "\n"; // false
                        275
                        276// 示例4: CIDR转换
                        277echo "CIDR转掩码: " . $analyzer->cidrToSubnetMask(24) . "\n"; // 255.255.255.0
                        278echo "掩码转CIDR: " . $analyzer->subnetMaskToCidr('255.255.255.0') . "\n"; // 24
                        279?>
                        
  • ip_analyzer (PY)
    ip_analyzer.py
      1#!/usr/bin/env python3
                          2# -*- coding: utf-8 -*-
                          3"""
                          4IP地址分析工具 - Python版本
                          5支持IP地址验证、子网计算、网络信息分析
                          6"""
                          7
                          8import re
                          9import ipaddress
                         10from typing import Dict, List, Tuple, Optional
                         11
                         12
                         13class IPAnalyzer:
                         14    """IP地址分析工具类"""
                         15    
                         16    def __init__(self):
                         17        self.ip_address = ""
                         18        self.subnet_mask = ""
                         19    
                         20    def validate_ip(self, ip: str) -> bool:
                         21        """
                         22        验证IP地址格式
                         23        
                         24        Args:
                         25            ip: IP地址字符串
                         26            
                         27        Returns:
                         28            bool: 是否有效
                         29        """
                         30        try:
                         31            ipaddress.ip_address(ip)
                         32            return True
                         33        except ValueError:
                         34            return False
                         35    
                         36    def validate_subnet_mask(self, mask: str) -> bool:
                         37        """
                         38        验证子网掩码格式
                         39        
                         40        Args:
                         41            mask: 子网掩码字符串
                         42            
                         43        Returns:
                         44            bool: 是否有效
                         45        """
                         46        try:
                         47            # 检查格式
                         48            if not re.match(r'^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$', mask):
                         49                return False
                         50            
                         51            # 检查是否为有效的子网掩码
                         52            parts = [int(x) for x in mask.split('.')]
                         53            binary = ''.join([format(part, '08b') for part in parts])
                         54            return re.match(r'^1*0*$', binary) is not None
                         55        except:
                         56            return False
                         57    
                         58    def cidr_to_subnet_mask(self, cidr: int) -> str:
                         59        """
                         60        CIDR转子网掩码
                         61        
                         62        Args:
                         63            cidr: CIDR值
                         64            
                         65        Returns:
                         66            str: 子网掩码
                         67        """
                         68        if not 0 <= cidr <= 32:
                         69            raise ValueError("CIDR值必须在0-32之间")
                         70        
                         71        mask = (0xFFFFFFFF << (32 - cidr)) & 0xFFFFFFFF
                         72        return '.'.join([str((mask >> (24 - i * 8)) & 255) for i in range(4)])
                         73    
                         74    def subnet_mask_to_cidr(self, mask: str) -> int:
                         75        """
                         76        子网掩码转CIDR
                         77        
                         78        Args:
                         79            mask: 子网掩码
                         80            
                         81        Returns:
                         82            int: CIDR值
                         83        """
                         84        if not self.validate_subnet_mask(mask):
                         85            raise ValueError("无效的子网掩码")
                         86        
                         87        parts = [int(x) for x in mask.split('.')]
                         88        binary = ''.join([format(part, '08b') for part in parts])
                         89        return binary.count('1')
                         90    
                         91    def get_ip_class(self, first_octet: int) -> str:
                         92        """
                         93        获取IP类型
                         94        
                         95        Args:
                         96            first_octet: 第一个八位字节
                         97            
                         98        Returns:
                         99            str: IP类型
                        100        """
                        101        if 1 <= first_octet <= 126:
                        102            return "A类"
                        103        elif 128 <= first_octet <= 191:
                        104            return "B类"
                        105        elif 192 <= first_octet <= 223:
                        106            return "C类"
                        107        elif 224 <= first_octet <= 239:
                        108            return "D类 (多播)"
                        109        elif 240 <= first_octet <= 255:
                        110            return "E类 (保留)"
                        111        else:
                        112            return "未知"
                        113    
                        114    def is_private_ip(self, ip_parts: List[int]) -> bool:
                        115        """
                        116        判断是否为私有IP
                        117        
                        118        Args:
                        119            ip_parts: IP地址的四个部分
                        120            
                        121        Returns:
                        122            bool: 是否为私有IP
                        123        """
                        124        a, b, c, d = ip_parts
                        125        
                        126        # A类私有: 10.0.0.0 - 10.255.255.255
                        127        if a == 10:
                        128            return True
                        129        
                        130        # B类私有: 172.16.0.0 - 172.31.255.255
                        131        if a == 172 and 16 <= b <= 31:
                        132            return True
                        133        
                        134        # C类私有: 192.168.0.0 - 192.168.255.255
                        135        if a == 192 and b == 168:
                        136            return True
                        137        
                        138        # 链路本地: 169.254.0.0 - 169.254.255.255
                        139        if a == 169 and b == 254:
                        140            return True
                        141        
                        142        # 回环地址: 127.0.0.0 - 127.255.255.255
                        143        if a == 127:
                        144            return True
                        145        
                        146        return False
                        147    
                        148    def analyze_network(self, ip: str, mask: str) -> Dict:
                        149        """
                        150        分析网络
                        151        
                        152        Args:
                        153            ip: IP地址
                        154            mask: 子网掩码
                        155            
                        156        Returns:
                        157            Dict: 分析结果
                        158        """
                        159        if not self.validate_ip(ip):
                        160            raise ValueError("无效的IP地址格式")
                        161        
                        162        if not self.validate_subnet_mask(mask):
                        163            raise ValueError("无效的子网掩码格式")
                        164        
                        165        # 使用ipaddress模块进行网络计算
                        166        network = ipaddress.IPv4Network(f"{ip}/{mask}", strict=False)
                        167        
                        168        ip_parts = [int(x) for x in ip.split('.')]
                        169        mask_parts = [int(x) for x in mask.split('.')]
                        170        
                        171        # 计算网络地址
                        172        network_parts = [ip_parts[i] & mask_parts[i] for i in range(4)]
                        173        network_address = '.'.join(map(str, network_parts))
                        174        
                        175        # 计算广播地址
                        176        broadcast_parts = [ip_parts[i] | (255 - mask_parts[i]) for i in range(4)]
                        177        broadcast_address = '.'.join(map(str, broadcast_parts))
                        178        
                        179        # 计算CIDR
                        180        cidr = self.subnet_mask_to_cidr(mask)
                        181        
                        182        # 计算可用主机数
                        183        total_hosts = 2 ** (32 - cidr)
                        184        usable_hosts = total_hosts - 2
                        185        
                        186        # 计算第一个和最后一个可用IP
                        187        first_usable_parts = network_parts.copy()
                        188        first_usable_parts[3] += 1
                        189        first_usable_ip = '.'.join(map(str, first_usable_parts))
                        190        
                        191        last_usable_parts = broadcast_parts.copy()
                        192        last_usable_parts[3] -= 1
                        193        last_usable_ip = '.'.join(map(str, last_usable_parts))
                        194        
                        195        # 计算网关IP (通常是第一个可用IP)
                        196        gateway_ip = first_usable_ip
                        197        
                        198        # 计算DNS IP (通常是第二个可用IP)
                        199        dns_parts = first_usable_parts.copy()
                        200        dns_parts[3] += 1
                        201        dns_ip = '.'.join(map(str, dns_parts))
                        202        
                        203        # 判断IP类型
                        204        ip_class = self.get_ip_class(ip_parts[0])
                        205        is_private = self.is_private_ip(ip_parts)
                        206        
                        207        # 二进制表示
                        208        ip_binary = '.'.join([format(part, '08b') for part in ip_parts])
                        209        subnet_binary = '.'.join([format(part, '08b') for part in mask_parts])
                        210        network_binary = '.'.join([format(part, '08b') for part in network_parts])
                        211        
                        212        return {
                        213            'ipAddress': ip,
                        214            'subnetMask': mask,
                        215            'cidr': f'/{cidr}',
                        216            'networkAddress': network_address,
                        217            'broadcastAddress': broadcast_address,
                        218            'usableHosts': usable_hosts,
                        219            'totalHosts': total_hosts,
                        220            'firstUsableIP': first_usable_ip,
                        221            'lastUsableIP': last_usable_ip,
                        222            'gatewayIP': gateway_ip,
                        223            'dnsIP': dns_ip,
                        224            'ipClass': ip_class,
                        225            'isPrivate': is_private,
                        226            'ipBinary': ip_binary,
                        227            'subnetBinary': subnet_binary,
                        228            'networkBinary': network_binary
                        229        }
                        230
                        231
                        232def main():
                        233    """主函数 - 使用示例"""
                        234    analyzer = IPAnalyzer()
                        235    
                        236    # 示例1: 分析192.168.1.100/24网络
                        237    try:
                        238        result = analyzer.analyze_network('192.168.1.100', '255.255.255.0')
                        239        print("网络分析结果:")
                        240        for key, value in result.items():
                        241            print(f"  {key}: {value}")
                        242    except ValueError as e:
                        243        print(f"分析失败: {e}")
                        244    
                        245    print()
                        246    
                        247    # 示例2: 验证IP地址
                        248    print(f"IP地址验证: {analyzer.validate_ip('192.168.1.100')}")  # True
                        249    print(f"IP地址验证: {analyzer.validate_ip('256.1.2.3')}")      # False
                        250    
                        251    # 示例3: 验证子网掩码
                        252    print(f"子网掩码验证: {analyzer.validate_subnet_mask('255.255.255.0')}")  # True
                        253    print(f"子网掩码验证: {analyzer.validate_subnet_mask('255.255.255.1')}")  # False
                        254    
                        255    # 示例4: CIDR转换
                        256    print(f"CIDR转掩码: {analyzer.cidr_to_subnet_mask(24)}")  # 255.255.255.0
                        257    print(f"掩码转CIDR: {analyzer.subnet_mask_to_cidr('255.255.255.0')}")  # 24
                        258
                        259
                        260if __name__ == "__main__":
                        261    main()
                        
网络知识
IP地址分类

A类: 1.0.0.0 - 126.255.255.255 (默认掩码: 255.0.0.0)

B类: 128.0.0.0 - 191.255.255.255 (默认掩码: 255.255.0.0)

C类: 192.0.0.0 - 223.255.255.255 (默认掩码: 255.255.255.0)

D类: 224.0.0.0 - 239.255.255.255 (多播地址)

E类: 240.0.0.0 - 255.255.255.255 (保留地址)

私有IP地址范围

A类私有: 10.0.0.0 - 10.255.255.255

B类私有: 172.16.0.0 - 172.31.255.255

C类私有: 192.168.0.0 - 192.168.255.255

链路本地: 169.254.0.0 - 169.254.255.255

回环地址: 127.0.0.0 - 127.255.255.255