README
¶
netipzh
Lightweight Go package that provides IP address and network operations with Chinese function names, plus enhanced context when handling issues
CHINESE README
Main Features
🎯 Chinese Function Names: Intuitive Chinese-named wrappers around Go's standard net/netip package
🔒 Enhanced Context on Exceptions: Stack traces with rich context using github.com/pkg/errors
🎨 Type-Safe Operations: Returns pointers enabling nil values on errors in idiomatic Go
📊 Comprehensive Coverage: IP addresses (IPv4/IPv6), ports, and CIDR prefixes
🌐 Clean Exception Returns: Standard handling with enhanced context on exceptions
Installation
go get github.com/go-zwbc/netipzh
Quick Start
IP Address Parsing
Parse IPv4 and IPv6 addresses using P解析地址.
package main
import (
"fmt"
"github.com/go-zwbc/netipzh"
"github.com/yyle88/rese"
)
func main() {
// Parse IPv4 address
ipv4 := rese.P1(netipzh.P解析地址("192.168.1.100"))
fmt.Printf("IPv4 Address: %s\n", ipv4.String())
fmt.Printf("Is IPv4: %v\n", ipv4.Is4())
fmt.Printf("Is Private: %v\n", ipv4.IsPrivate())
fmt.Println()
// Parse IPv6 address
ipv6 := rese.P1(netipzh.P解析地址("2001:db8::1"))
fmt.Printf("IPv6 Address: %s\n", ipv6.String())
fmt.Printf("Is IPv6: %v\n", ipv6.Is6())
fmt.Printf("Is Loopback: %v\n", ipv6.IsLoopback())
}
⬆️ Source: Source
Address and Port Operations
Parse and construct address:port combinations using P解析地址端口 and G构建地址端口.
package main
import (
"fmt"
"github.com/go-zwbc/netipzh"
"github.com/yyle88/rese"
)
func main() {
// Parse address with port
addrPort := rese.P1(netipzh.P解析地址端口("192.168.1.100:8080"))
fmt.Printf("Address:Port: %s\n", addrPort.String())
fmt.Printf("Address: %s\n", addrPort.Addr().String())
fmt.Printf("Port: %d\n", addrPort.Port())
fmt.Println()
// Construct address with port
addr := rese.P1(netipzh.P解析地址("10.0.0.1"))
newAddrPort := netipzh.G构建地址端口(*addr, 443)
fmt.Printf("Constructed: %s\n", newAddrPort.String())
fmt.Printf("Port: %d\n", newAddrPort.Port())
}
⬆️ Source: Source
Network Prefix Operations
Parse and construct CIDR network prefixes using P解析前缀 and G构建前缀.
package main
import (
"fmt"
"github.com/go-zwbc/netipzh"
"github.com/yyle88/rese"
)
func main() {
// Parse CIDR prefix
prefix := rese.P1(netipzh.P解析前缀("192.168.1.0/24"))
fmt.Printf("Prefix: %s\n", prefix.String())
fmt.Printf("Network Address: %s\n", prefix.Addr().String())
fmt.Printf("Prefix Bits: %d\n", prefix.Bits())
fmt.Printf("Is Valid: %v\n", prefix.IsValid())
fmt.Println()
// Construct prefix from address
addr := rese.P1(netipzh.P解析地址("10.0.0.0"))
newPrefix := rese.P1(netipzh.G构建前缀(*addr, 16))
fmt.Printf("Constructed Prefix: %s\n", newPrefix.String())
fmt.Printf("Prefix Bits: %d\n", newPrefix.Bits())
// Check if an address is in the prefix
testAddr := rese.P1(netipzh.P解析地址("10.0.5.100"))
fmt.Printf("Is %s in %s? %v\n", testAddr.String(), newPrefix.String(), newPrefix.Contains(*testAddr))
}
⬆️ Source: Source
API Reference
Main Package Functions
Parse Functions
P解析地址(s string) (*netip.Addr, error)- Parse string to IP address (IPv4 or IPv6)P解析地址端口(s string) (*netip.AddrPort, error)- Parse string to address:port combinationP解析前缀(s string) (*netip.Prefix, error)- Parse string to CIDR network prefix
Build Functions
G构建地址端口(addr netip.Addr, port uint16) *netip.AddrPort- Construct AddrPort from address and portG构建前缀(addr netip.Addr, bits int) (*netip.Prefix, error)- Construct Prefix from address and bit length
Exception Context
Exceptions from this package include enhanced context:
addr, err := netipzh.P解析地址("invalid.ip.address")
if err != nil {
// Includes context: "解析地址错误: <the source message>"
// With stack trace from github.com/pkg/errors
fmt.Printf("%+v\n", err) // Prints with stack trace
}
Function Name Meanings
P解析地址- Parse Address (解析地址 = parse address)P解析地址端口- Parse Address Port (解析地址端口 = parse address port)P解析前缀- Parse Prefix (解析前缀 = parse prefix)G构建地址端口- Generate Address Port (构建地址端口 = build address port)G构建前缀- Generate Prefix (构建前缀 = build prefix)
Safe Type Operations
Functions that return pointers enable idiomatic nil checks when issues happen:
addr, err := netipzh.P解析地址("192.168.1.1")
if err != nil {
// Handle the issue
return
}
// addr is *netip.Addr, guaranteed non-nil at this point
fmt.Println(addr.String())
Safe Design
This package uses Go's standard net/netip package, which provides safe and efficient IP address operations. The netip package is designed to be allocation-free and safe from common IP address parsing vulnerabilities.
📄 License
MIT License. See LICENSE.
🤝 Contributing
Contributions are welcome! Report bugs, suggest features, and contribute code:
- 🐛 Found a mistake? Open an issue on GitHub with reproduction steps
- 💡 Have a feature idea? Create an issue to discuss the suggestion
- 📖 Documentation confusing? Report it so we can improve
- 🚀 Need new features? Share the use cases to help us understand requirements
- ⚡ Performance issue? Help us optimize through reporting slow operations
- 🔧 Configuration problem? Ask questions about complex setups
- 📢 Follow project progress? Watch the repo to get new releases and features
- 🌟 Success stories? Share how this package improved the workflow
- 💬 Feedback? We welcome suggestions and comments
🔧 Development
New code contributions, follow this process:
- Fork: Fork the repo on GitHub (using the webpage UI).
- Clone: Clone the forked project (
git clone https://github.com/yourname/repo-name.git). - Navigate: Navigate to the cloned project (
cd repo-name) - Branch: Create a feature branch (
git checkout -b feature/xxx). - Code: Implement the changes with comprehensive tests
- Testing: (Golang project) Ensure tests pass (
go test ./...) and follow Go code style conventions - Documentation: Update documentation to support client-facing changes and use significant commit messages
- Stage: Stage changes (
git add .) - Commit: Commit changes (
git commit -m "Add feature xxx") ensuring backward compatible code - Push: Push to the branch (
git push origin feature/xxx). - PR: Open a merge request on GitHub (on the GitHub webpage) with detailed description.
Please ensure tests pass and include relevant documentation updates.
🌟 Support
Welcome to contribute to this project via submitting merge requests and reporting issues.
Project Support:
- ⭐ Give GitHub stars if this project helps you
- 🤝 Share with teammates and (golang) programming friends
- 📝 Write tech blogs about development tools and workflows - we provide content writing support
- 🌟 Join the ecosystem - committed to supporting open source and the (golang) development scene
Have Fun Coding with this package! 🎉🎉🎉
GitHub Stars
Documentation
¶
Overview ¶
Package netipzh provides IP address and port operations with Chinese function names. Wraps Go's standard net/netip package, adding enhanced context on exceptions. Features type-safe operations when parsing and constructing IP addresses, ports, and network prefixes.
netipzh 提供使用中文函数名的 IP 地址和端口操作功能。 封装 Go 标准 net/netip 包，增强异常时的上下文信息。 支持类型安全的 IP 地址、端口和网络前缀的解析和构建操作。
Index ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func G构建前缀 ¶
G构建前缀 constructs a Prefix from an IP address with a specific bit length. addr: IP address (IPv4 and IPv6) bits: prefix length (0-32 when IPv4, 0-128 when IPv6) Returns Prefix with stack trace when bits is out of range
G构建前缀 从 IP 地址和位长度构建 Prefix addr: IP 地址（IPv4 或 IPv6） bits: 前缀长度（IPv4 为 0-32，IPv6 为 0-128） 返回 Prefix 指针，bits 超出范围时返回带堆栈跟踪的错误
func G构建地址端口 ¶
G构建地址端口 constructs an AddrPort from an IP address with a specific port addr: IP address (IPv4 and IPv6) port: specific port (0-65535) Returns AddrPort combining the address with the port
G构建地址端口 从 IP 地址和端口号构建 AddrPort addr: IP 地址（IPv4 或 IPv6） port: 端口号（0-65535） 返回组合地址和端口的 AddrPort 指针
func P解析前缀 ¶
P解析前缀 parses a string into an IP network prefix in CIDR notation. s: CIDR string like "192.168.1.0/24" and "2001:db8::/32" Returns Prefix with stack trace when parsing fails
P解析前缀 将字符串解析为 CIDR 表示法的 IP 网络前缀 s: CIDR 字符串，如 "192.168.1.0/24" 或 "2001:db8::/32" 返回 Prefix 指针，解析失败时返回带堆栈跟踪的错误
func P解析地址 ¶
P解析地址 parses a string into an IP address (IPv4 and IPv6). s: IP address string like "192.168.1.1" and "::1" Returns Addr with stack trace when parsing fails
P解析地址 将字符串解析为 IP 地址（IPv4 或 IPv6） s: IP 地址字符串，如 "192.168.1.1" 或 "::1" 返回 Addr 指针，解析失败时返回带堆栈跟踪的错误
func P解析地址端口 ¶
P解析地址端口 parses a string into an IP address with port combination. s: address:port string like "192.168.1.1:8080" and "[::1]:8080" Returns AddrPort with stack trace when parsing fails
P解析地址端口 将字符串解析为 IP 地址和端口组合 s: 地址:端口字符串，如 "192.168.1.1:8080" 或 "[::1]:8080" 返回 AddrPort 指针，解析失败时返回带堆栈跟踪的错误
Types ¶
This section is empty.
Source Files
Directories