当前位置：首页 > 文章列表 > Golang > Go教程 > IP地址设置操作使用NET/NETIP

IP地址设置操作使用NET/NETIP

2025-02-01 17:52:09 0浏览收藏

在Golang实战开发的过程中，我们经常会遇到一些这样那样的问题，然后要卡好半天，等问题解决了才发现原来一些细节知识点还是没有掌握好。今天golang学习网就整理分享《IP地址设置操作使用NET/NETIP》，聊聊，希望可以帮助到正在努力赚钱的你。

IP地址设置操作使用NET/NETIP

本文承接前文，深入探讨net/netip包的高级应用——IP地址集合处理。虽然net/netip本身不直接支持集合类型，但我们可以通过巧妙的抽象来高效管理IP范围和集合。

IP集合的必要性

IP集合在以下场景中至关重要：

管理允许/拒绝IP列表
处理网络ACL（访问控制列表）
高效利用IP范围
执行集合操作（并集、交集、差集）

构建IP集合类型

我们构建一个灵活的IP集合实现：

package ipset

import (
    "fmt"
    "net/netip"
    "sort"
)

// range 表示连续的IP地址范围
type range struct {
    first netip.Addr
    last  netip.Addr
}

// ipset 使用范围表示IP地址集合
type ipset struct {
    ranges []range
}

func newipset() *ipset {
    return &ipset{}
}

// add 向集合添加单个IP地址
func (s *ipset) add(ip netip.Addr) {
    s.addrange(range{first: ip, last: ip})
}

// addrange 向集合添加IP范围
func (s *ipset) addrange(r range) {
    if r.first.Compare(r.last) > 0 {
        r.first, r.last = r.last, r.first
    }

    idx := sort.Search(len(s.ranges), func(i int) bool {
        return s.ranges[i].first.Compare(r.first) > 0
    })

    s.ranges = append(s.ranges, range{})
    copy(s.ranges[idx+1:], s.ranges[idx:])
    s.ranges[idx] = r

    s.optimize()
}

// optimize 合并重叠或相邻的范围
func (s *ipset) optimize() {
    if len(s.ranges) < 2 {
        return
    }

    merged := []range{}
    current := s.ranges[0]
    for _, next := range s.ranges[1:] {
        if current.last.Compare(next.first) >= 0 {
            // 合并重叠范围
            last := current.last
            if next.last.Compare(last) > 0 {
                last = next.last
            }
            current.last = last
        } else {
            merged = append(merged, current)
            current = next
        }
    }
    merged = append(merged, current)
    s.ranges = merged
}

// contains 检查集合中是否包含某个IP地址
func (s *ipset) contains(ip netip.Addr) bool {
    idx := sort.Search(len(s.ranges), func(i int) bool {
        return s.ranges[i].last.Compare(ip) >= 0
    })

    if idx < len(s.ranges) && s.ranges[idx].first.Compare(ip) <= 0 {
        return true
    }
    return false
}

集合操作

接下来实现基本的集合操作：

// union 返回一个新集合，包含两个集合的所有IP
func (s *ipset) union(other *ipset) *ipset {
    result := newipset()
    for _, r := range s.ranges {
        result.addrange(r)
    }
    for _, r := range other.ranges {
        result.addrange(r)
    }
    return result
}

// intersection 返回一个新集合，包含两个集合中都存在的IP
func (s *ipset) intersection(other *ipset) *ipset {
    result := newipset()
    for _, r1 := range s.ranges {
        for _, r2 := range other.ranges {
            first := r1.first
            if r2.first.Compare(first) > 0 {
                first = r2.first
            }
            last := r1.last
            if r2.last.Compare(last) < 0 {
                last = r2.last
            }
            if first.Compare(last) <= 0 {
                result.addrange(range{first: first, last: last})
            }
        }
    }
    return result
}

// difference 返回一个新集合，包含在第一个集合中但在第二个集合中不存在的IP
func (s *ipset) difference(other *ipset) *ipset {
    result := newipset()
    for _, r1 := range s.ranges {
        for _, r2 := range other.ranges {
            // 复杂的范围差集计算，略去详细代码，需要考虑多种情况
            // ...
        }
    }
    return result
}

(此处省略了 difference 函数的复杂实现，它需要处理各种范围重叠和非重叠情况)

现实世界应用示例