Struct core::net::Ipv6Addr

pub struct Ipv6Addr { /* private fields */ }

IPv6 地址。

IPv6 地址在 IETF RFC 4291 中定义为 128 位整数。 它们通常表示为八个 16 位段。

嵌入 IPv4 地址

有关同时包含 IPv4 和 IPv6 地址的类型，请参见 IpAddr。

为了帮助从 IPv4 过渡到 IPv6，定义了两种类型的 IPv6 地址，它们嵌入了 IPv4 地址： IPv4 兼容地址和 IPv4 映射地址。其中这些与 IPv4 兼容的地址已被正式弃用。

除了相关标准规定的内容外，此实现并未为这两种类型的地址分配任何特殊含义。 这意味着像 ::ffff:127.0.0.1 这样的地址，虽然代表 IPv4 回环地址，但它本身并不是 IPv6 回环地址； 只有 ::1 是。 要处理这些所谓的 “IPv4-in-IPv6” 地址，必须首先将它们转换为规范的 IPv4 地址。

兼容 IPv4 的 IPv6 地址

IPv4 兼容的 IPv6 地址在 IETF RFC 4291 第 2.5.5.1 节 中定义，并已被正式弃用。 RFC 描述了 “IPv4 兼容 IPv6 地址” 的格式如下：

|                80 bits               | 16 |      32 bits        |
+--------------------------------------+--------------------------+
|0000..............................0000|0000|    IPv4 address     |
+--------------------------------------+----+---------------------+

因此 ::a.b.c.d 将是表示 IPv4 地址 a.b.c.d 的 IPv4 兼容 IPv6 地址。

要将 IPv4 地址转换为与 IPv4 兼容的 IPv6 地址，请使用 Ipv4Addr::to_ipv6_compatible。 使用 Ipv6Addr::to_ipv4 将兼容 IPv4 的 IPv6 地址转换为规范的 IPv4 地址。

IPv4 映射的 IPv6 地址

IPv4 映射的 IPv6 地址在 IETF RFC 4291 第 2.5.5.2 节 中定义。 RFC 描述了 “IPv4-Mapped IPv6 address” 的格式如下：

|                80 bits               | 16 |      32 bits        |
+--------------------------------------+--------------------------+
|0000..............................0000|FFFF|    IPv4 address     |
+--------------------------------------+----+---------------------+

因此 ::ffff:a.b.c.d 将是表示 IPv4 地址 a.b.c.d 的 IPv4 映射 IPv6 地址。

要将 IPv4 地址转换为 IPv4 映射的 IPv6 地址，请使用 Ipv4Addr::to_ipv6_mapped。 使用 Ipv6Addr::to_ipv4 将 IPv4 映射的 IPv6 地址转换为规范的 IPv4 地址。 请注意，这也会将 IPv6 回环地址 ::1 转换为 0.0.0.1。使用 Ipv6Addr::to_ipv4_mapped 可以避免这种情况。

文字表达

Ipv6Addr 提供了一个 FromStr 的实现。 有多种方法可以用文本表示 IPv6 地址，但通常，每个段都以十六进制表示法，并且段之间用 : 分隔。

有关更多信息，请参见 IETF RFC 5952。

Examples

use std::net::Ipv6Addr;

let localhost = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);
assert_eq!("::1".parse(), Ok(localhost));
assert_eq!(localhost.is_loopback(), true);

Implementations

impl Ipv6Addr

pub const fn new( a: u16, b: u16, c: u16, d: u16, e: u16, f: u16, g: u16, h: u16 ) -> Ipv6Addr

从八个 16 位段创建一个新的 IPv6 地址。

结果将代表 IP 地址 a:b:c:d:e:f:g:h。

Examples

use std::net::Ipv6Addr;

let addr = Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff);

pub const LOCALHOST: Self = _

代表本地主机的 IPv6 地址: ::1。

这对应其他语言的常量 IN6ADDR_LOOPBACK_INIT 或 in6addr_loopback。

Examples

use std::net::Ipv6Addr;

let addr = Ipv6Addr::LOCALHOST;
assert_eq!(addr, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));

pub const UNSPECIFIED: Self = _

代表未指定地址的 IPv6 地址: ::

这对应其他语言的常量 IN6ADDR_ANY_INIT 或 in6addr_any。

Examples

use std::net::Ipv6Addr;

let addr = Ipv6Addr::UNSPECIFIED;
assert_eq!(addr, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0));

pub const fn segments(&self) -> [u16; 8]

返回组成该地址的八个 16 位段。

Examples

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).segments(),
           [0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff]);

pub const fn is_unspecified(&self) -> bool

为特殊的 ‘unspecified’ 地址 (::) 返回 true。

此属性在 IETF RFC 4291 中定义。

Examples

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_unspecified(), false);
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0).is_unspecified(), true);

pub const fn is_loopback(&self) -> bool

如果这是 环回地址 (::1)，如 IETF RFC 4291 第 2.5.3 节 中所定义，则返回 true。

与 IPv4 相反，IPv6 只有一个回环地址。

Examples

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_loopback(), false);
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0x1).is_loopback(), true);

pub fn is_global(&self) -> bool

🔬This is a nightly-only experimental API. (ip #27709)

如果地址看起来是由 IANA IPv6 Special-Purpose Address Registry 指定的全局可访问的，则返回 true。 一个地址是否实际可访问将取决于您的网络配置。

大多数 IPv6 地址都是全局可达的; 除非它们被明确定义为 not 全局可达。

全球无法访问的显着地址的非详尽列表:

• unspecified address (is_unspecified)
• loopback address (is_loopback)
• IPv4 映射地址
• 为基准测试保留的地址
• 为文档 (is_documentation) 保留的地址
• 唯一的本地地址 (is_unique_local)
• 具有链路本地作用域 (is_unicast_link_local) 的单播地址

有关哪些地址可全局访问的完整概览，请参见 IANA IPv6 Special-Purpose Address Registry 中的表格。

请注意，地址具有以下作用: 存在与全局可访问相同的地址，并且这两个概念之间没有直接关系是全球可访问的，没有具有非域范围的多播地址 (多播地址)。

Examples

#![feature(ip)]

use std::net::Ipv6Addr;

// 大多数 IPv6 地址都是全局可达的:
assert_eq!(Ipv6Addr::new(0x26, 0, 0x1c9, 0, 0, 0xafc8, 0x10, 0x1).is_global(), true);

// 但是，某些地址已被赋予特殊含义，使它们无法全局访问。
// 一些例子是:

// 未指定的地址 (`::`)
assert_eq!(Ipv6Addr::UNSPECIFIED.is_global(), false);

// 回环地址 (`::1`)
assert_eq!(Ipv6Addr::LOCALHOST.is_global(), false);

// IPv4 映射地址 (`::ffff:0:0/96`)
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_global(), false);

// 为 (`2001:2::/48`) 基准测试保留的地址
assert_eq!(Ipv6Addr::new(0x2001, 2, 0, 0, 0, 0, 0, 1,).is_global(), false);

// 为文档 (`2001:db8::/32`) 保留的地址
assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1).is_global(), false);

// 唯一的本地地址 (`fc00::/7`)
assert_eq!(Ipv6Addr::new(0xfc02, 0, 0, 0, 0, 0, 0, 1).is_global(), false);

// 具有链路本地作用域 (`fe80::/10`) 的单播地址
assert_eq!(Ipv6Addr::new(0xfe81, 0, 0, 0, 0, 0, 0, 1).is_global(), false);

// 有关完整概述，请参见 IANA IPv6 专用地址注册表。

pub fn is_unique_local(&self) -> bool

🔬This is a nightly-only experimental API. (ip #27709)

如果这是唯一的本地地址 (fc00::/7)，则返回 true。

此属性在 IETF RFC 4193 中定义。

Examples

#![feature(ip)]

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_unique_local(), false);
assert_eq!(Ipv6Addr::new(0xfc02, 0, 0, 0, 0, 0, 0, 0).is_unique_local(), true);

pub fn is_unicast(&self) -> bool

🔬This is a nightly-only experimental API. (ip #27709)

如果这是 IETF RFC 4291 定义的单播地址，则返回 true。 任何不是 多播地址 (ff00::/8) 的地址都是单播的。

Examples

#![feature(ip)]

use std::net::Ipv6Addr;

// 未指定地址和回环地址是单播的。
assert_eq!(Ipv6Addr::UNSPECIFIED.is_unicast(), true);
assert_eq!(Ipv6Addr::LOCALHOST.is_unicast(), true);

// 任何不是多播地址 (`ff00::/8`) 的地址都是单播的。
assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0).is_unicast(), true);
assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).is_unicast(), false);

pub fn is_unicast_link_local(&self) -> bool

🔬This is a nightly-only experimental API. (ip #27709)

如果地址是具有链接本地作用域的单播地址，则返回 true，如 RFC 4291 中所定义。

如果单播地址具有前缀 fe80::/10，则它具有链路本地作用域，如 RFC 4291 section 2.4。 请注意，这包含比 RFC 4291 第 2.5.6 节 中定义的地址更多的地址，[RFC 4291 第 2.5.6 节] 将 “链路本地 IPv6 单播地址” 描述为具有以下更严格的格式：

| 10 bits  |         54 bits         |          64 bits           |
+----------+-------------------------+----------------------------+
|1111111010|           0             |       interface ID         |
+----------+-------------------------+----------------------------+

因此，虽然目前应用程序将遇到的唯一具有本地链接作用域的地址都在 fe80::/64 中，但随着新标准的发布，这可能会在 future 中发生变化。 fe80::/10 中可以分配更多的地址，这些地址将具有本地链接作用域。

另请注意，虽然 RFC 4291 第 2.5.3 章 提到 “它被视为具有 Link-Local 作用域” 的 环回地址 (::1)，但这并不意味着回环地址实际上具有链接本地作用域，并且此方法将在其上返回 false。

Examples

#![feature(ip)]

use std::net::Ipv6Addr;

// 回环地址 (`::1`) 实际上并没有链接本地作用域。
assert_eq!(Ipv6Addr::LOCALHOST.is_unicast_link_local(), false);

// 只有 `fe80::/10` 中的地址具有本地链接作用域。
assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0).is_unicast_link_local(), false);
assert_eq!(Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0).is_unicast_link_local(), true);

// 更严格的 `fe80::/64` 之外的地址也具有链接本地作用域。
assert_eq!(Ipv6Addr::new(0xfe80, 0, 0, 1, 0, 0, 0, 0).is_unicast_link_local(), true);
assert_eq!(Ipv6Addr::new(0xfe81, 0, 0, 0, 0, 0, 0, 0).is_unicast_link_local(), true);

pub fn is_documentation(&self) -> bool

🔬This is a nightly-only experimental API. (ip #27709)

如果这是为文档 (2001:db8::/32) 保留的地址，则返回 true。

此属性在 IETF RFC 3849 中定义。

Examples

#![feature(ip)]

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_documentation(), false);
assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0).is_documentation(), true);

pub const fn is_benchmarking(&self) -> bool

🔬This is a nightly-only experimental API. (ip #27709)

如果这是为基准测试 (2001:2::/48) 保留的地址，则返回 true。

此属性在 IETF RFC 5180 中定义，其中错误地将其指定为覆盖范围 2001:0200::/48。 这在 IETF RFC Errata 1752 到 2001:0002::/48 中得到纠正。

#![feature(ip)]

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc613, 0x0).is_benchmarking(), false);
assert_eq!(Ipv6Addr::new(0x2001, 0x2, 0, 0, 0, 0, 0, 0).is_benchmarking(), true);

pub fn is_unicast_global(&self) -> bool

🔬This is a nightly-only experimental API. (ip #27709)

如果该地址是全局可路由的单播地址，则返回 true。

以下返回 false：

• 回环地址
• 链接本地地址
• 唯一的本地地址
• 未指定地址
• 保留用于文档的地址范围

此方法根据 RFC 4291 第 2.5.7 节 返回 true 作为站点本地地址

The special behavior of [the site-local unicast] prefix defined in [RFC3513] must no longer
be supported in new implementations (i.e., new implementations must treat this prefix as
Global Unicast).

Examples

#![feature(ip)]

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0).is_unicast_global(), false);
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_unicast_global(), true);

pub fn multicast_scope(&self) -> Option<Ipv6MulticastScope>

🔬This is a nightly-only experimental API. (ip #27709)

如果该地址是多播的，则返回该地址的多播作用域。

Examples

#![feature(ip)]

use std::net::{Ipv6Addr, Ipv6MulticastScope};

assert_eq!(
    Ipv6Addr::new(0xff0e, 0, 0, 0, 0, 0, 0, 0).multicast_scope(),
    Some(Ipv6MulticastScope::Global)
);
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).multicast_scope(), None);

pub const fn is_multicast(&self) -> bool

如果这是多播地址 (ff00::/8)，则返回 true。

此属性由 IETF RFC 4291 定义。

Examples

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).is_multicast(), true);
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_multicast(), false);

pub fn to_ipv4_mapped(&self) -> Option<Ipv4Addr>

如果它是 IPv4 映射 地址 (如 IETF RFC 4291 第 2.5.5.2 节 中所定义)，则将此地址转换为 IPv4 address，否则返回 None。

::ffff:a.b.c.d 变成 a.b.c.d。 所有非以 ::ffff 开头的地址都将返回 None。

Examples

use std::net::{Ipv4Addr, Ipv6Addr};

assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).to_ipv4_mapped(), None);
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).to_ipv4_mapped(),
           Some(Ipv4Addr::new(192, 10, 2, 255)));
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).to_ipv4_mapped(), None);

pub const fn to_ipv4(&self) -> Option<Ipv4Addr>

如果此地址是 IETF RFC 4291 第 2.5.5.1 节 中定义的 IPv4 兼容 地址或 IETF RFC 4291 第 2.5.5.2 节 中定义的 IPv4 映射 地址，则将此地址转换为 IPv4 地址，否则返回 None。

请注意，这将为 IPv6 回环地址 ::1 返回一个 IPv4 address。使用 Ipv6Addr::to_ipv4_mapped 可以避免这种情况。

::a.b.c.d 和 ::ffff:a.b.c.d 变成了 a.b.c.d。::1 变成了 0.0.0.1。 所有不以全零或 ::ffff 开头的地址都将返回 None。

Examples

use std::net::{Ipv4Addr, Ipv6Addr};

assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).to_ipv4(), None);
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).to_ipv4(),
           Some(Ipv4Addr::new(192, 10, 2, 255)));
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).to_ipv4(),
           Some(Ipv4Addr::new(0, 0, 0, 1)));

pub fn to_canonical(&self) -> IpAddr

🔬This is a nightly-only experimental API. (ip #27709)

如果此地址是 IPv4 映射地址，则将此地址转换为 IpAddr::V4，否则返回自包装在 IpAddr::V6 中。

Examples

#![feature(ip)]
use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0x7f00, 0x1).is_loopback(), false);
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0x7f00, 0x1).to_canonical().is_loopback(), true);

pub const fn octets(&self) -> [u8; 16]

返回 IPv6 地址组成的 16 个八位整数。

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).octets(),
           [255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);

impl Ipv6Addr

pub fn parse_ascii(b: &[u8]) -> Result<Self, AddrParseError>

🔬This is a nightly-only experimental API. (addr_parse_ascii #101035)

从字节片中解析 IPv6 地址。

#![feature(addr_parse_ascii)]

use std::net::Ipv6Addr;

let localhost = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);

assert_eq!(Ipv6Addr::parse_ascii(b"::1"), Ok(localhost));

Trait Implementations

impl Clone for Ipv6Addr

fn clone(&self) -> Ipv6Addr

返回值的副本。

fn clone_from(&mut self, source: &Self)

从 source 执行复制分配。

impl Debug for Ipv6Addr

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

使用给定的格式化程序格式化该值。

impl Display for Ipv6Addr

编写一个符合 RFC 5952 描述的规范样式的 Ivv6Addr。

fn fmt(&self, f: &mut Formatter<'_>) -> Result

使用给定的格式化程序格式化该值。

impl From<[u16; 8]> for Ipv6Addr

fn from(segments: [u16; 8]) -> Ipv6Addr

从 8 个元素的 16 位数组创建 Ipv6Addr。

Examples

use std::net::Ipv6Addr;

let addr = Ipv6Addr::from([
    525u16, 524u16, 523u16, 522u16,
    521u16, 520u16, 519u16, 518u16,
]);
assert_eq!(
    Ipv6Addr::new(
        0x20d, 0x20c,
        0x20b, 0x20a,
        0x209, 0x208,
        0x207, 0x206
    ),
    addr
);

impl From<[u8; 16]> for Ipv6Addr

fn from(octets: [u8; 16]) -> Ipv6Addr

从 16 个元素的字节数组创建 Ipv6Addr。

Examples

use std::net::Ipv6Addr;

let addr = Ipv6Addr::from([
    25u8, 24u8, 23u8, 22u8, 21u8, 20u8, 19u8, 18u8,
    17u8, 16u8, 15u8, 14u8, 13u8, 12u8, 11u8, 10u8,
]);
assert_eq!(
    Ipv6Addr::new(
        0x1918, 0x1716,
        0x1514, 0x1312,
        0x1110, 0x0f0e,
        0x0d0c, 0x0b0a
    ),
    addr
);

impl From<Ipv6Addr> for IpAddr

fn from(ipv6: Ipv6Addr) -> IpAddr

将此地址复制到新的 IpAddr::V6。

Examples

use std::net::{IpAddr, Ipv6Addr};

let addr = Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff);

assert_eq!(
    IpAddr::V6(addr),
    IpAddr::from(addr)
);

impl From<Ipv6Addr> for u128

fn from(ip: Ipv6Addr) -> u128

将 Ipv6Addr 转换为主机字节顺序 u128。

Examples

use std::net::Ipv6Addr;

let addr = Ipv6Addr::new(
    0x1020, 0x3040, 0x5060, 0x7080,
    0x90A0, 0xB0C0, 0xD0E0, 0xF00D,
);
assert_eq!(0x102030405060708090A0B0C0D0E0F00D_u128, u128::from(addr));

impl From<u128> for Ipv6Addr

fn from(ip: u128) -> Ipv6Addr

将主机字节顺序 u128 转换为 Ipv6Addr。

Examples

use std::net::Ipv6Addr;

let addr = Ipv6Addr::from(0x102030405060708090A0B0C0D0E0F00D_u128);
assert_eq!(
    Ipv6Addr::new(
        0x1020, 0x3040, 0x5060, 0x7080,
        0x90A0, 0xB0C0, 0xD0E0, 0xF00D,
    ),
    addr);

impl FromStr for Ipv6Addr

type Err = AddrParseError

可以从解析中返回的相关错误。

fn from_str(s: &str) -> Result<Ipv6Addr, AddrParseError>

解析字符串 s 以返回此类型的值。

impl Hash for Ipv6Addr

fn hash<__H: Hasher>(&self, state: &mut __H)

将该值输入给定的 Hasher。

fn hash_slice<H: Hasher>(data: &[Self], state: &mut H)where Self: Sized,

将这种类型的切片送入给定的 Hasher 中。

impl Ord for Ipv6Addr

fn cmp(&self, other: &Ipv6Addr) -> Ordering

此方法返回 self 和 other 之间的 Ordering。

fn max(self, other: Self) -> Selfwhere Self: Sized,

比较并返回两个值中的最大值。

fn min(self, other: Self) -> Selfwhere Self: Sized,

比较并返回两个值中的最小值。

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd,

将值限制在某个时间间隔内。

impl PartialEq<IpAddr> for Ipv6Addr

fn eq(&self, other: &IpAddr) -> bool

此方法测试 self 和 other 值是否相等，并由 == 使用。

fn ne(&self, other: &Rhs) -> bool

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。

impl PartialEq<Ipv6Addr> for IpAddr

fn eq(&self, other: &Ipv6Addr) -> bool

此方法测试 self 和 other 值是否相等，并由 == 使用。

fn ne(&self, other: &Rhs) -> bool

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。

impl PartialEq<Ipv6Addr> for Ipv6Addr

fn eq(&self, other: &Ipv6Addr) -> bool

此方法测试 self 和 other 值是否相等，并由 == 使用。

fn ne(&self, other: &Rhs) -> bool

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。

impl PartialOrd<IpAddr> for Ipv6Addr

fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering>

如果存在，则此方法返回 self 和 other 值之间的顺序。

fn lt(&self, other: &Rhs) -> bool

此方法测试的内容少于 (对于 self 和 other)，并且由 < 操作员使用。

fn le(&self, other: &Rhs) -> bool

此方法测试小于或等于 (对于 self 和 other)，并且由 <= 运算符使用。

fn gt(&self, other: &Rhs) -> bool

此方法测试大于 (对于 self 和 other)，并且由 > 操作员使用。

fn ge(&self, other: &Rhs) -> bool

此方法测试是否大于或等于 (对于 self 和 other)，并且由 >= 运算符使用。

impl PartialOrd<Ipv6Addr> for IpAddr

fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering>

如果存在，则此方法返回 self 和 other 值之间的顺序。

fn lt(&self, other: &Rhs) -> bool

此方法测试的内容少于 (对于 self 和 other)，并且由 < 操作员使用。

fn le(&self, other: &Rhs) -> bool

此方法测试小于或等于 (对于 self 和 other)，并且由 <= 运算符使用。

fn gt(&self, other: &Rhs) -> bool

此方法测试大于 (对于 self 和 other)，并且由 > 操作员使用。

fn ge(&self, other: &Rhs) -> bool

此方法测试是否大于或等于 (对于 self 和 other)，并且由 >= 运算符使用。

impl PartialOrd<Ipv6Addr> for Ipv6Addr

fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering>

如果存在，则此方法返回 self 和 other 值之间的顺序。

fn lt(&self, other: &Rhs) -> bool

此方法测试的内容少于 (对于 self 和 other)，并且由 < 操作员使用。

fn le(&self, other: &Rhs) -> bool

此方法测试小于或等于 (对于 self 和 other)，并且由 <= 运算符使用。

fn gt(&self, other: &Rhs) -> bool

此方法测试大于 (对于 self 和 other)，并且由 > 操作员使用。

fn ge(&self, other: &Rhs) -> bool

此方法测试是否大于或等于 (对于 self 和 other)，并且由 >= 运算符使用。

impl Copy for Ipv6Addr

impl Eq for Ipv6Addr

impl StructuralEq for Ipv6Addr

impl StructuralPartialEq for Ipv6Addr