Report a bug If you spot a problem with this page, click here to create a Bugzilla issue. Improve this page Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using local clone.

std.string

String handling functions.


Category	Functions
Searching	column inPattern indexOf indexOfAny indexOfNeither lastIndexOf lastIndexOfAny lastIndexOfNeither
Comparison	countchars isNumeric
Mutation	capitalize munch removechars squeeze
Pruning and Filling	center chomp chompPrefix chop detabber detab entab leftJustify outdent rightJustify strip stripLeft stripRight wrap
Substitution	abbrev soundex soundexer succ tr translate
Miscellaneous	assumeUTF fromStringz lineSplitter representation splitLines toStringz

Objects of types string, wstring, and dstring are value types and cannot be mutated element-by-element. For using mutation during building strings, use char[], wchar[], or dchar[]. The xxxstring types are preferable because they don't exhibit undesired aliasing, thus making code more robust.

The following functions are publicly imported:


Module	Functions
*Publicly imported functions*
std.algorithm	cmp.html#algorithm">cmp count.html#algorithm">count endsWith.html#algorithm">endsWith startsWith.html#algorithm">startsWith
std.array	join replace replaceInPlace split
std.format	format sformat
std.uni	icmp toLower toLowerInPlace toUpper toUpperInPlace

There is a rich set of functions for string handling defined in other modules. Functions related to Unicode and ASCII are found in std.uni and std.ascii, respectively. Other functions that have a wider generality than just strings can be found in std.algorithm and std.range.

See Also:

std.algorithm and std.range for generic range algorithms
std.ascii for functions that work with ASCII strings
std.uni for functions that work with unicode strings

License:

Boost License 1.0.

Authors:

Walter Bright, Andrei Alexandrescu, and Jonathan M Davis

Source: std/string.d

class StringException: object.Exception;

Exception thrown on errors in std.string functions.

pure nothrow @safe this(string msg, string file = __FILE__, size_t line = __LINE__, Throwable next = null);

Parameters:

string msg	The message for the exception.
string file	The file where the exception occurred.
size_t line	The line number where the exception occurred.
Throwable next	The previous exception in the chain of exceptions, if any.

pure nothrow @nogc @system inout(char)[] fromStringz(inout(char)* cString);

Returns a D-style array of char given a zero-terminated C-style string. The returned array will retain the same type qualifiers as the input.

Important Note: The returned array is a slice of the original buffer. The original data is not changed and not copied.

Examples:

assert(fromStringz(null) == null);
assert(fromStringz("foo") == "foo");

pure nothrow @trusted immutable(char)* toStringz(const(char)[] s); pure nothrow @trusted immutable(char)* toStringz(in string s);

Returns a C-style zero-terminated string equivalent to s. s must not contain embedded '\0''s as any C function will treat the first '\0' that it sees as the end of the string. If s.empty is true, then a string containing only '\0' is returned.

Important Note: When passing a char* to a C function, and the C function keeps it around for any reason, make sure that you keep a reference to it in your D code. Otherwise, it may go away during a garbage collection cycle and cause a nasty bug when the C code tries to use it.

alias CaseSensitive = std.typecons.Flag!"caseSensitive".Flag;

Flag indicating whether a search is case-sensitive.

ptrdiff_t indexOf(Range)(Range s, in dchar c, in CaseSensitive cs = CaseSensitive.yes) if (isInputRange!Range && isSomeChar!(ElementEncodingType!Range));

Searches for character in range.

Parameters:

Range s	string or InputRange of characters to search in correct UTF format
dchar c	character to search for
CaseSensitive cs	CaseSensitive.yes or CaseSensitive.no

Returns:

the index of the first occurrence of c in s. If c is not found, then -1 is returned. If the parameters are not valid UTF, the result will still be in the range [-1 .. s.length], but will not be reliable otherwise.

ptrdiff_t indexOf(Range)(Range s, in dchar c, in size_t startIdx, in CaseSensitive cs = CaseSensitive.yes) if (isInputRange!Range && isSomeChar!(ElementEncodingType!Range));

Searches for character in range starting at index startIdx.

Parameters:

Range s	string or InputRange of characters to search in correct UTF format
dchar c	character to search for
size_t startIdx	starting index to a well-formed code point
CaseSensitive cs	CaseSensitive.yes or CaseSensitive.no

Returns:

ptrdiff_t indexOf(Range, Char)(Range s, const(Char)[] sub, in CaseSensitive cs = CaseSensitive.yes) if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) && isSomeChar!Char);

Searches for substring in s.

Parameters:

Range s	string or ForwardRange of characters to search in correct UTF format
const(Char)[] sub	substring to search for
CaseSensitive cs	CaseSensitive.yes or CaseSensitive.no

Returns:

the index of the first occurrence of sub in s. If sub is not found, then -1 is returned. If the arguments are not valid UTF, the result will still be in the range [-1 .. s.length], but will not be reliable otherwise.

Bugs:

Does not work with case insensitive strings where the mapping of tolower and toupper is not 1:1.

@safe ptrdiff_t indexOf(Char1, Char2)(const(Char1)[] s, const(Char2)[] sub, in size_t startIdx, in CaseSensitive cs = CaseSensitive.yes) if (isSomeChar!Char1 && isSomeChar!Char2);

Returns the index of the first occurrence of sub in s with respect to the start index startIdx. If sub is not found, then -1 is returned. If sub is found the value of the returned index is at least startIdx. startIdx represents a codeunit index in s. If the sequence starting at startIdx does not represent a well formed codepoint, then a std.utf.UTFException may be thrown.