---
# System prepended metadata

title: 验证IP地址
tags: [LeeCode]

---

# 验证IP地址

```javascript=
编写一个函数来验证输入的字符串是否是有效的 IPv4 或 IPv6 地址。

IPv4 地址由十进制数和点来表示，每个地址包含4个十进制数，其范围为 0 - 255， 用(".")分割。

比如，172.16.254.1；

同时，IPv4 地址内的数不会以 0 开头。比如，地址 172.16.254.01 是不合法的。

IPv6 地址由8组16进制的数字来表示，每组表示 16 比特。这些组数字通过 (":")分割。

比如,  2001:0db8:85a3:0000:0000:8a2e:0370:7334 是一个有效的地址。

而且，我们可以加入一些以 0 开头的数字，字母可以使用大写，也可以是小写。

所以，2001:db8:85a3:0:0:8A2E:0370:7334也是一个有效的IPv6address地址 (即忽略0开头, 忽略大小写)。

然而，我们不能因为某个组的值为 0，而使用一个空的组，以至于出现 (::) 的情况。 

比如， 2001:0db8:85a3::8A2E:0370:7334 是无效的 IPv6 地址。

同时，在 IPv6 地址中，多余的 0 也是不被允许的。

比如， 02001:0db8:85a3:0000:0000:8a2e:0370:7334 是无效的。

说明: 你可以认为给定的字符串里没有空格或者其他特殊字符。

示例 1:

输入: "172.16.254.1"

输出: "IPv4"

解释: 这是一个有效的 IPv4 地址, 所以返回 "IPv4"。


示例 2:

输入: "2001:0db8:85a3:0:0:8A2E:0370:7334"

输出: "IPv6"

解释: 这是一个有效的 IPv6 地址, 所以返回 "IPv6"。


示例 3:

输入: "256.256.256.256"

输出: "Neither"

解释: 这个地址既不是 IPv4 也不是 IPv6 地址。
```

:::success
```go=

// IP的类型
const (
	IPV4 = "IPv4"
	IPV6 = "IPv6"
	Neither = "Neither"
)

 // IPv4的规则
const (
	LenMinIPv4 = 1
	LenMaxIPv4 = 3
	LenGroupIPv4 = 4
	MaxIP = 255 // 最大的数值不能超过255
)

// IPv6的规则
const (
	LenMinIPv6 = 1
	LenMaxIPv6 = 4
	LenGroupIPv6 = 8
)

/*
IPv4的规则：0.0.0.0 - 255.255.255.255

1. 以'.'分隔每组数据
2. 共有4组十进制数字
3. 每组数据的长度不能为0,长度在1-3位之间
4. 每组数据不能有前置0，但是可以只有一个0（个位数时允许是0）
5. 每组数据组成的元素必须在0-9之间
6. 每组数字必须在0到255之间
7. 数字前面不能有符号

IPv6的规则：
1. ':'分隔每组数据
2. 共有8组十六进制数字
3. 每组长度不能等于0且不能超过4
4. 因为是十六进制，所以每组中的字符只能是 0-9,a-f,A-F构成
 */

// type IP []byte

// 1. net.IP包
func validIPAddress(IP string) string {
	ip := net.ParseIP(IP)
	if ip != nil { // 解析出来的不是IP类型
		if ip.To4() != nil && ip.String() == IP { // To4将IPv4地址ip转换为4字节表示，如果ip不是IPv4地址，To4返回nil。
			return IPV4
		}
		if ip.To4() != nil && ip.String() != IP {
			return Neither
		}
		if ip.To4() == nil { // 到了这里代表不是IPv4地址
			temp := strings.Split(IP, ":")
			for i := range temp {
				if len(temp[i]) > 4 || len(temp[i]) == 0 {
					return Neither
				}
			}
			return IPV6
		}
	}
	return Neither
}

// 2. 根据IP地址的规则输出代码

func validIPAddress(IP string) string {
	if strings.Contains(IP, ".") {
		return validIPv4(IP)
	}
	if strings.Contains(IP, ":") {
		return validIPv6(IP)
	}
	return "Neither"
}

func validIPv4(str string) string {
	result := strings.Split(str, ".") // 以'.'分隔每组数据
	if len(result) != LenGroupIPv4 { // 共有4组十进制数字
		return Neither
	}

	for _, value := range result {
		// 每组数据的长度不能为0,长度在1-3位之间
		if len(value) < LenMinIPv4 || len(value) > LenMaxIPv4 {
			return Neither
		}

		// 每组数据不能有前置0，但是可以只有一个0（个位数时允许是0）
		if len(value) > LenMinIPv4 && value[0] == '0' {
			return Neither
		}

		// 每组数据组成的元素必须在0-9之间
		for _, val := range value {
			if !(val >= '0' && val <= '9') {
				return Neither
			}
		}

		// 每组数字必须在0到255之间
		result, err := strconv.Atoi(value)
		if err != nil || result > MaxIP {
			return Neither
		}
	}

	return IPV4
}

func validIPv6(str string) string {
	result := strings.Split(str, ":") // 以':'分隔每组数据
	if len(result) != LenGroupIPv6 { // 共有8组十六进制数字
		return Neither
	}

	for _, value := range result {
		// 每组长度不能等于0且不能超过4
		if len(value) < LenMinIPv6 || len(value) > LenMaxIPv6 {
			return Neither
		}

		// 因为是十六进制，所以每组中的字符只能是 0-9,a-f,A-F构成
		for _, val := range value {
			if !(val >= '0' && val <= '9' || val >= 'a' && val <= 'f' || val >= 'A' && val <= 'F') {
				return Neither
			}
		}
	}

	return IPV6
}
:::
```

###### tags: `LeeCode`