#string #inline #inlinable

no-std inlinable_string

inlinable_string 包提供 InlinableString 类型——一个所有者,可增长的 UTF-8 字符串,将小字符串内联存储并避免堆分配——以及 StringExt 特性,它抽象了 std::string::StringInlinableString(甚至是你自己的自定义字符串类型)上的字符串操作。

14 个版本

0.1.15 2022 年 1 月 4 日
0.1.14 2020 年 11 月 29 日
0.1.11 2020 年 2 月 4 日
0.1.10 2018 年 5 月 15 日
0.1.3 2015 年 12 月 2 日

60Rust 模式

Download history 55553/week @ 2024-03-14 51557/week @ 2024-03-21 48876/week @ 2024-03-28 49640/week @ 2024-04-04 51967/week @ 2024-04-11 52470/week @ 2024-04-18 50910/week @ 2024-04-25 52172/week @ 2024-05-02 51533/week @ 2024-05-09 53619/week @ 2024-05-16 47620/week @ 2024-05-23 56220/week @ 2024-05-30 57405/week @ 2024-06-06 65021/week @ 2024-06-13 60927/week @ 2024-06-20 50585/week @ 2024-06-27

244,899 每月下载量
用于 440 个包 (13 个直接使用)

Apache-2.0/MIT

77KB
1.5K SLoC

inlinable_string

Build Status

Coverage Status

inlinable_string 包提供 InlinableString 类型——一个所有者,可增长的 UTF-8 字符串,将小字符串内联存储并避免堆分配——以及 StringExt 特性,它抽象了 std::string::StringInlinableString(甚至是你自己的自定义字符串类型)。

StringExt 的 API 与 std::string::String 大多数相同;不包括不稳定和已弃用的方法。为 std::string::StringInlinableString 提供了 StringExt 的实现。这使得 InlinableString 可以作为 std::string::String 的通用替代品,并且 &StringExt 可以与两种类型的引用一起工作。

但这实际上比使用 std::string::String 快吗?

以下是当前的一些(微)基准测试结果。我鼓励你自己运行 cargo bench --feature nightly 并使用 nightly Rust 验证它们!我也非常欢迎添加更多现实和具有代表性的基准测试!和我分享一些想法吧!

从大字符串 &str 构建出来

test benches::bench_inlinable_string_from_large                ... bench:          32 ns/iter (+/- 6)
test benches::bench_std_string_from_large                      ... bench:          31 ns/iter (+/- 10)

从小的 &str 开始构建

test benches::bench_inlinable_string_from_small                ... bench:           1 ns/iter (+/- 0)
test benches::bench_std_string_from_small                      ... bench:          26 ns/iter (+/- 14)

将大的 &str 压入空字符串

test benches::bench_inlinable_string_push_str_large_onto_empty ... bench:          37 ns/iter (+/- 12)
test benches::bench_std_string_push_str_large_onto_empty       ... bench:          30 ns/iter (+/- 9)

将小的 &str 压入空字符串

test benches::bench_inlinable_string_push_str_small_onto_empty ... bench:          11 ns/iter (+/- 4)
test benches::bench_std_string_push_str_small_onto_empty       ... bench:          23 ns/iter (+/- 10)

将大的 &str 压入大字符串

test benches::bench_inlinable_string_push_str_large_onto_large ... bench:          80 ns/iter (+/- 24)
test benches::bench_std_string_push_str_large_onto_large       ... bench:          78 ns/iter (+/- 23)

将小的 &str 压入小字符串

test benches::bench_inlinable_string_push_str_small_onto_small ... bench:          17 ns/iter (+/- 6)
test benches::bench_std_string_push_str_small_onto_small       ... bench:          60 ns/iter (+/- 15)

TLDR:如果你的字符串大小倾向于保持在 INLINE_STRING_CAPACITY 以内,那么 InlinableString 会更快。超过这个阈值并强制从内联存储提升到堆分配将会比 std::string::String 慢得多,在这种情况下你可以看到预期的下降,但这通常是一次性成本。一旦字符串已经大于 INLINE_STRING_CAPACITY,那么性能差异是可以忽略不计的。然而,这一切都要谨慎对待!这些是非常微小的基准测试,你的(标签)实际世界的工作负载可能会有很大不同!

安装

或者

$ cargo add inlinable_string

或者将其添加到你的 Cargo.toml

[dependencies]
inlinable_string = "0.1.0"

文档

文档

依赖项

~175KB