Phobos: std.string

To copy or not to copy?

class StringException

Thrown on errors in string functions.

const char[] hexdigits;

"0123456789ABCDEF"

const char[] digits;

"0123456789"

const char[] octdigits;

"01234567"

const char[] lowercase;

"abcdefghijklmnopqrstuvwxyz"

const char[] uppercase;

"ABCDEFGHIJKLMNOPQRSTUVWXYZ"

const char[] letters;

"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"

const char[] whitespace;

" \t\v\r\n\f"

long atoi(char[] s)

Convert string to integer.

real atof(char[] s)

Convert string to real.

int cmp(char[] s1, char[] s2)

Compare two strings. Returns:

<0 for (s1 < s2)

=0 for (s1 == s2)

>0 for (s1 > s2)

int icmp(char[] s1, char[] s2)

Same as cmp() but case insensitive.

char* toStringz(char[] s)

Converts a D array of chars to a C-style 0 terminated string.

int find(char[] s, dchar c)

Find first occurrance of c in string s. Return index in s where it is found. Return -1 if not found.

int rfind(char[] s, dchar c)

Find last occurrance of c in string s. Return index in s where it is found. Return -1 if not found.

int find(char[] s, char[] sub)

Find first occurrance of sub in string s. Return index in s[] where it is found. Return -1 if not found.

int rfind(char[] s, char[] sub)

Find last occurrance of sub in string s. Return index in s where it is found. Return -1 if not found.

int ifind(char[] s, dchar c)

int irfind(char[] s, dchar c)

int ifind(char[] s, char[] sub)

int irfind(char[] s, char[] sub)

Case insensitive versions.

char[] tolower(char[] s)

Convert string to lower case.

char[] toupper(char[] s)

Convert string to upper case.

char[] capitalize(char[] s)

Capitalize first character of string.

char[] capwords(char[] s)

Capitalize all words in string. Remove leading and trailing whitespace. Replace all sequences of whitespace with a single space.

char[] join(char[][] words, char[] sep)

Concatenate all the strings together into one string; use sep[] as the separator.

char[][] split(char[] s)

Split s[] into an array of words, using whitespace as the delimiter.

char[][] split(char[] s, char[] delim)

Split s[] into an array of words, using delim[] as the delimiter.

char[][] splitlines(char[] s)

Split s[] into an array of lines, using CR, LF, or CR-LF as the delimiter.

char[] stripl(char[] s)

char[] stripr(char[] s)

char[] strip(char[] s)

Strips leading or trailing whitespace, or both.

char[] chomp(char[] s, char[] delimiter = null)

Returns s sans trailing delimiter, if any. If delimiter is null, any trailing CR, LF, or CRLF is removed.

char[] chop(char[] s)

Returns s sans trailing character, if there is one. If last two characters are CR-LF, then both are removed.

char[] ljustify(char[] s, int width)

char[] rjustify(char[] s, int width)

char[] center(char[] s, int width)

Left justify, right justify, or center string s in field width chars wide.

char[] zfill(char[] s, int width)

Same as rjustify(), but fill with '0's.

char[] replace(char[] s, char[] from, char[] to)

Replace occurrences of from with to in s.

char[] replaceSlice(char[] s, char[] slice, char[] replacement)

Given a string s with a slice into it, replace slice[] with replacement.

char[] insert(char[] s, int index, char[] sub)

Insert sub into s at location index.

int count(char[] s, char[] sub)

Count up all instances of sub in s.

char[] expandtabs(char[] s, int tabsize)

Replace tabs with the appropriate number of spaces. tabsize is the distance between tab stops.

char[] maketrans(char[] from, char[] to)

Construct translation table for translate().

char[] translate(char[] s, char[] transtab, char[] delchars)

Translate characters in s using table created by maketrans(). Delete chars in delchars. Note: This only works if s is ASCII. Use tr for full UCS character support.

char[] toString(bit arg)

char[] toString(char arg)

char[] toString(byte arg)

char[] toString(ubyte arg)

char[] toString(short arg)

char[] toString(ushort arg)

char[] toString(int arg)

char[] toString(uint arg)

char[] toString(long arg)

char[] toString(ulong arg)

char[] toString(float arg)

char[] toString(double arg)

char[] toString(real arg)

char[] toString(ifloat arg)

char[] toString(idouble arg)

char[] toString(ireal arg)

char[] toString(cfloat arg)

char[] toString(cdouble arg)

char[] toString(creal arg)

Convert arg to string.

char[] toString(long arg, uint radix)

Convert arg to string in radix radix. radix must be a value from 2 to 36. arg is treated as a signed value only if radix is 10. The characters A through Z are used to represent values 10 through 36.

char[] toString(ulong arg, uint radix)

Convert arg to string in radix radix. radix must be a value from 2 to 36. The characters A through Z are used to represent values 10 through 36.

char[] toString(char* s)

Convert C-style 0 terminated string s to char[] string.

char[] format(...)

Format arguments into a string.

char[] sformat(char[] s, ...)

Format arguments into string s which must be large enough to hold the result. Throws ArrayBoundsError if it is not. Returns s.

char[] succ(char[] s)

Return string that is the 'successor' to s. If the rightmost character is a-zA-Z0-9, it is incremented within its case or digits. If it generates a carry, the process is repeated with the one to its immediate left.

	succ(null);	// returns null	
	succ("!@#$%");	// returns "!@#$%"
	succ("1");	// returns "2"
	succ("9");	// returns "10"
	succ("999");	// returns "1000"
	succ("zz99");	// returns "aaa00"

char[] tr(char[] str, char[] from, char[] to, char[] modifiers = null)

Replaces characters in str that are in from with corresponding characters in to and returns the resulting string.

modifiers is a string of modifier characters:

Modifier	Description
c	Complement the list of characters in from
d	Removes matching characters with no corresponding replacement in to
s	Removes adjacent duplicates in the replaced characters

If modifier d is present, then the number of characters in to may be only 0 or 1.

If modifier d is not present and to is null, then to is taken to be the same as from.

If modifier d is not present and to is shorter than from, then to is extended by replicating the last character in to.

Both from and to may contain ranges using the - character, for example a-d is synonymous with abcd. Neither accept a leading ^ as meaning the complement of the string (use the c modifier for that).

Patterns

Note: In the future, the pattern syntax may be improved to be more like regular expression character classes.

int inPattern(dchar c, char[] pattern)

Returns 1 if c is in pattern, 0 if not.

int inPatterns(dchar c, char[][] patterns)

Returns 1 if c is in each of the patterns in patterns, 0 if not.

size_t countchars(char[] s, char[] pattern)

Returns number of characters in s that match pattern.

char[] removechars(char[] s, char[] pattern)

Return a string consisting of s with all the characters that match pattern removed.

char[] squeeze(char[] s, char[] pattern = null)

Return a string consisting of s with all the multiple sequences of characters that match pattern are removed. If pattern is null, it defaults to all characters.

	squeeze("hello goodbye")	// returns "helo godbye"
	squeeze("hello goodbye", "le")	// returns "helo goodbye"