Go netip.AddrFrom4 怎样构造 IPv4 地址值

如果手里已经有 IPv4 的四个字节，直接使用 netip.AddrFrom4([4]byte) 就可以得到一个原生 IPv4 地址值。它不需要返回错误，因为数组的长度在类型层面已经固定为 4；真正需要判断的是输入来源，以及后续是否把这个地址当成 IPv4、IPv4-mapped IPv6 或零值。

官方参考：https://pkg.go.dev/net/netip#AddrFrom4

AddrFrom4 的最小用法是先准备 [4]byte，再调用构造函数；构造出的 netip.Addr 可以用 String() 展示、用 Is4() 判断类型、用 As4() 取回四字节表示。

把四个字节交给 AddrFrom4

AddrFrom4 的参数类型是 [4]byte，不是长度不确定的 []byte。这一区别很有用：调用点已经表达了“这里必须是四个字节”，不需要为长度不足或超长返回错误。

package main

import (
    "fmt"
    "net/netip"
)

func main() {
    // 固定四个字节，按 IPv4 的四个八位组排列。
    octets := [4]byte{192, 0, 2, 42}

    // 构造出的 Addr 是值类型，表示原生 IPv4 地址。
    ip := netip.AddrFrom4(octets)

    // String 适合展示或写入日志；Is4 用来确认地址类型。
    fmt.Println(ip.String())
    fmt.Println(ip.Is4(), ip.IsValid(), ip.BitLen())

    // 已知 ip 是 IPv4 后，可以安全取回四字节表示。
    restored := ip.As4()
    fmt.Println(restored[0], restored[1], restored[2], restored[3])
}

这段代码中的 192.0.2.42 只是文档示例地址。AddrFrom4 做的是字节到地址值的转换，不会发起网络请求，也不会检查这个地址是否能在当前网络中连通。

String、Is4 和 As4 分别解决什么问题

构造出 netip.Addr 后，三个常用方法对应三类不同需求，不要把它们当成同一种“转字符串”操作。

netip.Addr 是不可变、可比较的值类型，因此可以直接比较，也可以作为 map 的键。若只是要把构造结果写入日志，调用 String() 就够了；若要再次处理每个八位组，才需要 As4()。

来自 []byte 时先确定输入契约

网络报文、文件或数据库字段通常给出的是切片。切片不能直接传给 AddrFrom4，因为 []byte 的长度运行时才知道。只接受 IPv4 四字节输入时，可以先检查长度，再拷贝到数组：

package main

import (
    "fmt"
    "net/netip"
)

func addrFromIPv4Bytes(raw []byte) (netip.Addr, error) {
    // 长度不等于 4 时，不能把它当作 IPv4 四字节输入。
    if len(raw) != 4 {
        return netip.Addr{}, fmt.Errorf("IPv4 需要 4 个字节，收到 %d 个", len(raw))
    }

    var octets [4]byte
    // 拷贝后由数组类型保证后续调用始终拿到 4 个字节。
    copy(octets[:], raw)
    return netip.AddrFrom4(octets), nil
}

如果同一个入口既可能收到 4 字节 IPv4，也可能收到 16 字节 IPv6，就不必手写两条长度分支，可以考虑 netip.AddrFromSlice：

func parseBinaryIP(raw []byte) (netip.Addr, error) {
    // AddrFromSlice 根据 4 或 16 字节长度选择 IPv4 或 IPv6。
    ip, ok := netip.AddrFromSlice(raw)
    if !ok {
        return netip.Addr{}, fmt.Errorf("IP 字节长度只能是 4 或 16，收到 %d", len(raw))
    }
    return ip, nil
}

两种写法的边界不同：只接收 IPv4 时用 AddrFrom4 可以让函数契约更窄、更明确；输入格式由调用方决定且要兼容 IPv6 时，AddrFromSlice 更合适。

文本输入和 16 字节输入不要混用

如果输入本来就是文本，例如配置文件中的 192.0.2.42，应使用 netip.ParseAddr。如果输入是 16 字节数组并且语义是 IPv6，则应使用 AddrFrom16。这三条路径都能得到 netip.Addr，但地址类型可能不同。

func compareInputForms() error {
    // 文本解析会返回错误，适合处理外部输入。
    fromText, err := netip.ParseAddr("192.0.2.42")
    if err != nil {
        return err
    }

    // 固定数组构造不返回错误，长度由类型保证。
    fromBytes := netip.AddrFrom4([4]byte{192, 0, 2, 42})
    fmt.Println(fromText == fromBytes) // true

    // 该字面量是 IPv4-mapped IPv6，不是原生 IPv4。
    mapped := netip.MustParseAddr("::ffff:192.0.2.42")
    fmt.Println(mapped.Is4(), mapped.Is4In6()) // false true
    fmt.Println(mapped.Unmap() == fromBytes)  // true
    return nil
}

AddrFrom16 的 16 字节输入若表示 ::ffff:192.0.2.42，结果仍是 IPv4-mapped IPv6。它与 AddrFrom4 得到的原生 IPv4 在 Is4()、BitLen() 和字符串形式上都可能给出不同判断；需要统一比较时，先明确是否应该调用 Unmap()。

0.0.0.0 不是 Addr{}

这是使用 netip.Addr 时最容易忽略的零值边界。[4]byte{0, 0, 0, 0} 经过 AddrFrom4 得到的是合法的 IPv4 地址 0.0.0.0；而 netip.Addr{} 是尚未初始化的零值，两者不是同一个概念。

func showZeroBoundary() {
    // 四个零字节仍然描述一个有效的 IPv4 地址。
    unspecified := netip.AddrFrom4([4]byte{0, 0, 0, 0})

    // Addr{} 表示没有初始化地址，不等于 0.0.0.0。
    var zero netip.Addr
    fmt.Println(unspecified.String(), unspecified.IsValid()) // 0.0.0.0 true
    fmt.Println(zero.String(), zero.IsValid())               // invalid IP false
    fmt.Println(unspecified == zero)                         // false
}

因此，判断“有没有拿到地址”时通常看 IsValid()；判断“是不是 IPv4 的 0.0.0.0”时看 Is4() 和 IsUnspecified()。不要只依赖 String() 的文本。

调用 As4 前先确认类型

As4() 不是对所有 Addr 都安全。官方文档明确说明：零 Addr 或普通 IPv6 地址调用它会 panic；原生 IPv4 和 IPv4-in-IPv6 地址才有四字节表示。

func ipv4Octets(ip netip.Addr) ([4]byte, bool) {
    // 先排除零值和普通 IPv6，避免在未知地址上调用 As4。
    if !ip.Is4() && !ip.Is4In6() {
        return [4]byte{}, false
    }

    // 原生 IPv4 与 IPv4-mapped IPv6 都可取出四字节表示。
    return ip.As4(), true
}

如果业务只接受原生 IPv4，就把条件收紧为 ip.Is4()；如果业务允许把映射地址也当作 IPv4 处理，可以在取出四字节后再决定是否先调用 Unmap()。这一步要和业务协议的地址语义保持一致。

几个容易混淆的问题

可以把 []byte 直接传给 AddrFrom4 吗？

不可以。AddrFrom4 要求 [4]byte，需要先检查切片长度并拷贝到数组；如果要兼容 4 或 16 字节输入，可以使用 AddrFromSlice。

AddrFrom4 会验证 IP 是否可访问吗？

不会。它只把四个字节封装为地址值，不做 DNS、路由或连通性检查。

As4 为什么可能 panic？

因为普通 IPv6 和零 Addr 没有合法的四字节 IPv4 表示。对来源不确定的地址，先用 Is4 或 Is4In6 判断。

什么时候应使用 ParseAddr？

输入来自配置、命令行、HTTP 参数等文本时使用 ParseAddr，因为它会返回错误；输入已经是可信的固定四字节数组时，AddrFrom4 更直接。

归纳起来，AddrFrom4 适合“输入已经明确是四个字节”的场景：数组类型负责长度约束，netip.Addr 负责统一的地址值表示，Is4、As4 和 IsValid 分别负责类型、字节和零值边界。只要先分清输入形式与地址类型，后续比较和序列化就不会被 IPv4-mapped IPv6 或 Addr{} 混淆。