String is a growable, heap-allocated string type. It wraps a Vec<char> and ensures null-termination for C compatibility.
import "std/string.zc"
fn main() {
let s = String::from("Hello");
// Append requires a pointer to another String
let part = String::from(" World");
s.append(&part);
// Iteration (UTF-8 aware)
for c in s {
println "{c}";
}
// Use c_str() to print
println "{s.c_str()}"; // Prints "Hello World"
if (s.starts_with("Hello")) {
// ...
}
} // s is freed automatically here
struct String {
vec: Vec<char>;
}
| Method |
Signature |
Description |
| new |
String::new(s: char*) -> String |
Creates a new String from a C string primitive. |
| from |
String::from(s: char*) -> String |
Alias for new. |
| from_rune |
String::from_rune(r: rune) -> String |
Creates a new String from a single rune. |
| from_runes |
String::from_runes(runes: rune*, count: usize) -> String |
Creates a new String from an array of runes. |
| from_runes_vec |
String::from_runes_vec(runes: Vec<rune>) -> String |
Creates a new String from a vector of rune objects. |
| Method |
Signature |
Description |
| append |
append(self, other: String*) |
Appends another string to this one. |
| append_c |
append_c(self, s: char*) |
Appends a C string literal. |
| push_rune |
push_rune(self, r: rune) |
Appends a single Unicode code point (rune) to the string. |
| insert_rune |
insert_rune(self, idx: usize, r: rune) |
Inserts a rune at the specified character index. |
| remove_rune_at |
remove_rune_at(self, idx: usize) -> rune |
Removes and returns the rune at the specified character index. |
| reserve |
reserve(self, cap: usize) |
Ensures the string has at least cap characters of capacity. |
| clear |
clear(self) |
Clears the string. |
| Method |
Signature |
Description |
| c_str |
c_str(self) -> char* |
Returns the underlying C string pointer. |
| length |
length(self) -> usize |
Returns the length of the string (excluding null terminator). |
| is_empty |
is_empty(self) -> bool |
Returns true if length is 0. |
| to_string |
to_string(self) -> char* |
Maps to c_str(). Used for {var} interpolation. |
| starts_with |
starts_with(self, prefix: char*) -> bool |
Checks if the string starts with the given prefix. |
| ends_with |
ends_with(self, suffix: char*) -> bool |
Checks if the string ends with the given suffix. |
| contains |
contains(self, target: char) -> bool |
Checks if the string contains the given character. |
| contains_str |
contains_str(self, target: char*) -> bool |
Checks if the string contains the given substring. |
| find |
find(self, target: char) -> Option<usize> |
Returns the index of the first occurrence of byte target. |
| find_str |
find_str(self, target: char*) -> Option<usize> |
Returns the index of the first occurrence of substring target. |
| find_all_str |
find_all_str(self, target: char*) -> Vec<usize> |
Returns a vector containing all indices where target occurs. |
| substring |
substring(self, start: usize, len: usize) -> String |
Returns a new String containing the specified substring. |
| Method |
Signature |
Description |
| utf8_len |
utf8_len(self) -> usize |
Returns the number of Unicode code points (characters). |
| utf8_at |
utf8_at(self, idx: usize) -> String |
Returns the character at the specified index as a new String. |
| utf8_get |
utf8_get(self, idx: usize) -> rune |
Returns the character at the specified index as a rune. |
| utf8_substr |
utf8_substr(self, start_idx: usize, num_chars: usize) -> String |
Returns a substring based on character indices. |
| runes |
runes(self) -> Vec<rune> |
Returns a vector containing all Unicode code points. |
| chars |
chars(self) -> StringCharsIter |
Returns a manual iterator yielding Option<rune>. |
| Method |
Signature |
Description |
| to_lowercase |
to_lowercase(self) -> String |
Returns a new string converted into lowercase. |
| to_uppercase |
to_uppercase(self) -> String |
Returns a new string converted into uppercase. |
| split |
split(self, delim: char) -> Vec<String> |
Splits the string into a vector of substrings. |
| trim |
trim(self) -> String |
Returns a new string with leading/trailing whitespace removed. |
| replace |
replace(self, target: char*, replacement: char*) -> String |
Returns a new string with replacements. |
| pad_left |
pad_left(self, target_len: usize, pad_char: char) -> String |
Returns a new string padded on the left. |
| pad_right |
pad_right(self, target_len: usize, pad_char: char) -> String |
Returns a new string padded on the right. |
| Method |
Signature |
Description |
| eq |
eq(self, other: String*) -> bool |
Structural equality check. |
| neq |
neq(self, other: String*) -> bool |
Structural inequality check. |
| compare |
compare(self, other: String*) -> int |
Lexical comparison. |
| compare_ignore_case |
compare_ignore_case(self, other: String*) -> int |
Case-insensitive lexical comparison. |
| eq_ignore_case |
eq_ignore_case(self, other: String*) -> bool |
Case-insensitive equality check. |
| Operator |
Method |
Description |
+ |
add |
s1 + &s2. Concatenates strings into a new String. |
+= |
add_assign |
s1 += &s2. Appends s2 to s1 in place. |
== |
eq |
s1 == &s2. structural equality check. |
!= |
neq |
s1 != &s2. structural inequality check. |
< |
lt |
s1 < &s2. Lexical comparison. |
> |
gt |
s1 > &s2. Lexical comparison. |
<= |
le |
s1 <= &s2. Lexical comparison. |
>= |
ge |
s1 >= &s2. Lexical comparison. |
{} |
to_string |
Used for string interpolation in printf/println. |
| Method |
Signature |
Description |
| iterator |
iterator(self) -> StringCharsIter |
Returns an iterator yielding rune. Used by for c in s. |
| Method |
Signature |
Description |
| free |
free(self) |
Manually frees the string memory. |
| destroy |
destroy(self) |
Alias for free. |
| forget |
forget(self) |
Prevents automatic freeing (transfer ownership). |
| Trait |
impl Drop for String |
Automatically calls free() when out of scope. |