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
a local clone.
std.string
String handling functions.
| Category | Functions |
|---|---|
| Searching | column indexOf indexOfAny indexOfNeither lastIndexOf lastIndexOfAny lastIndexOfNeither |
| Comparison | isNumeric |
| Mutation | capitalize |
| Pruning and Filling | center chomp chompPrefix chop detabber detab entab entabber leftJustify outdent rightJustify strip stripLeft stripRight wrap |
| Substitution | abbrev soundex soundexer succ tr translate |
| Miscellaneous | assumeUTF fromStringz lineSplitter representation splitLines toStringz |
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 count endsWith startsWith |
| std.array | join replace replaceInPlace split empty |
| std.format | format sformat |
| std.uni | icmp toLower toLowerInPlace toUpper toUpperInPlace |
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:
Authors:
Source std/string.d
- class
StringException: object.Exception; - Exception thrown on errors in std.string functions.Examples:
import std.exception : assertThrown; auto bad = " a\n\tb\n c"; assertThrown!StringException(bad.outdent);
- pure nothrow @nogc @system Char[]
fromStringz(Char)(Char*cString)
if (isSomeChar!Char); - Parameters:
Char* cStringA null-terminated c-style string. Returns:A D-style array of char, wchar or dchar referencing the same 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:writeln(fromStringz("foo\0"c.ptr)); // "foo"c writeln(fromStringz("foo\0"w.ptr)); // "foo"w writeln(fromStringz("foo\0"d.ptr)); // "foo"d writeln(fromStringz("福\0"c.ptr)); // "福"c writeln(fromStringz("福\0"w.ptr)); // "福"w writeln(fromStringz("福\0"d.ptr)); // "福"d
- pure nothrow @trusted immutable(char)*
toStringz(scope const(char)[]s);
pure nothrow @trusted immutable(char)*toStringz(return scope strings); - Parameters:
const(char)[] sA D-style string. Returns:A C-style null-terminated string equivalent tos.smust not contain embedded '\0''s as any C function will treat the first '\0' that it sees as the end of the string. Ifs.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 become invalid during a garbage collection cycle and cause a nasty bug when the C code tries to use it.Examples:import core.stdc.string : strlen; import std.conv : to; auto p = toStringz("foo"); writeln(strlen(p)); // 3 const(char)[] foo = "abbzxyzzy"; p = toStringz(foo[3 .. 5]); writeln(strlen(p)); // 2 string test = ""; p = toStringz(test); writeln(*p); // 0 test = "\0"; p = toStringz(test); writeln(*p); // 0 test = "foo\0"; p = toStringz(test); assert(p[0] == 'f' && p[1] == 'o' && p[2] == 'o' && p[3] == 0); const string test2 = ""; p = toStringz(test2); writeln(*p); // 0
- alias
CaseSensitive= std.typecons.Flag!"caseSensitive".Flag; - Flag indicating whether a search is case-sensitive.
- ptrdiff_t
indexOf(Range)(Ranges, dcharc, CaseSensitivecs= Yes.caseSensitive)
if (isInputRange!Range && isSomeChar!(ElementType!Range) && !isSomeString!Range);
ptrdiff_tindexOf(C)(C[]s, dcharc, CaseSensitivecs= Yes.caseSensitive)
if (isSomeChar!C);
ptrdiff_tindexOf(Range)(Ranges, dcharc, size_tstartIdx, CaseSensitivecs= Yes.caseSensitive)
if (isInputRange!Range && isSomeChar!(ElementType!Range) && !isSomeString!Range);
ptrdiff_tindexOf(C)(C[]s, dcharc, size_tstartIdx, CaseSensitivecs= Yes.caseSensitive)
if (isSomeChar!C); - Searches for character in range.Parameters:
Range sstring or InputRange of characters to search in correct UTF format dchar ccharacter to search for size_t startIdxstarting index to a well-formed code point CaseSensitive csYes.caseSensitive or No.caseSensitive Returns:the index of the first occurrence ofcinswith respect to the start indexstartIdx. Ifcis not found, then -1 is returned. Ifcis found the value of the returned index is at leaststartIdx. If the parameters are not valid UTF, the result will still be in the range [-1 .. s.length], but will not be reliable otherwise.Throws:If the sequence starting atstartIdxdoes not represent a well formed codepoint, then a std.utf.UTFException may be thrown.See Also:Examples:import std.typecons : No; string s = "Hello World"; writeln(indexOf(s, 'W')); // 6 writeln(indexOf(s, 'Z')); // -1 writeln(indexOf(s, 'w', No.caseSensitive)); // 6
Examples:import std.typecons : No; string s = "Hello World"; writeln(indexOf(s, 'W', 4)); // 6 writeln(indexOf(s, 'Z', 100)); // -1 writeln(indexOf(s, 'w', 3, No.caseSensitive)); // 6
- ptrdiff_t
indexOf(Range, Char)(Ranges, const(Char)[]sub, in CaseSensitivecs= Yes.caseSensitive)
if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) && isSomeChar!Char);
@safe ptrdiff_tindexOf(Char1, Char2)(const(Char1)[]s, const(Char2)[]sub, in size_tstartIdx, in CaseSensitivecs= Yes.caseSensitive)
if (isSomeChar!Char1 && isSomeChar!Char2); - Searches for substring in
s.Parameters:Range sstring or ForwardRange of characters to search in correct UTF format const(Char)[] subsubstring to search for size_t startIdxthe index into s to start searching from CaseSensitive csYes.caseSensitive or No.caseSensitive Returns:the index of the first occurrence ofsubinswith respect to the start indexstartIdx. Ifsubis 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. Ifsubis found the value of the returned index is at leaststartIdx.Throws:If the sequence starting atstartIdxdoes not represent a well formed codepoint, then a std.utf.UTFException may be thrown.Bugs:Does not work with case insensitive strings where the mapping of tolower and toupper is not 1:1.Examples:import std.typecons : No; string s = "Hello World"; writeln(indexOf(s, "Wo", 4)); // 6 writeln(indexOf(s, "Zo", 100)); // -1 writeln(indexOf(s, "wo", 3, No.caseSensitive)); // 6
Examples:import std.typecons : No; string s = "Hello World"; writeln(indexOf(s, "Wo")); // 6 writeln(indexOf(s, "Zo")); // -1 writeln(indexOf(s, "wO", No.caseSensitive)); // 6
- pure @safe ptrdiff_t
lastIndexOf(Char)(const(Char)[]s, in dcharc, in CaseSensitivecs= Yes.caseSensitive)
if (isSomeChar!Char);
pure @safe ptrdiff_tlastIndexOf(Char)(const(Char)[]s, in dcharc, in size_tstartIdx, in CaseSensitivecs= Yes.caseSensitive)
if (isSomeChar!Char); - Parameters:
const(Char)[] sstring to search dchar ccharacter to search for size_t startIdxthe index into s to start searching from CaseSensitive csYes.caseSensitive or No.caseSensitive Returns:The index of the last occurrence ofcins. Ifcis not found, then -1 is returned. ThestartIdxslicessin the following way s[0 .. startIdx].startIdxrepresents a codeunit index ins.Throws:If the sequence ending atstartIdxdoes not represent a well formed codepoint, then a std.utf.UTFException may be thrown.csindicates whether the comparisons are case sensitive.Examples:import std.typecons : No; string s = "Hello World"; writeln(lastIndexOf(s, 'l')); // 9 writeln(lastIndexOf(s, 'Z')); // -1 writeln(lastIndexOf(s, 'L', No.caseSensitive)); // 9
Examples:import std.typecons : No; string s = "Hello World"; writeln(lastIndexOf(s, 'l', 4)); // 3 writeln(lastIndexOf(s, 'Z', 1337)); // -1 writeln(lastIndexOf(s, 'L', 7, No.caseSensitive)); // 3
- pure @safe ptrdiff_t
lastIndexOf(Char1, Char2)(const(Char1)[]s, const(Char2)[]sub, in CaseSensitivecs= Yes.caseSensitive)
if (isSomeChar!Char1 && isSomeChar!Char2);
pure @safe ptrdiff_tlastIndexOf(Char1, Char2)(const(Char1)[]s, const(Char2)[]sub, in size_tstartIdx, in CaseSensitivecs= Yes.caseSensitive)
if (isSomeChar!Char1 && isSomeChar!Char2); - Parameters:
const(Char1)[] sstring to search const(Char2)[] subsubstring to search for size_t startIdxthe index into s to start searching from CaseSensitive csYes.caseSensitive or No.caseSensitive Returns:the index of the last occurrence ofsubins. Ifsubis not found, then -1 is returned. ThestartIdxslicessin the following way s[0 .. startIdx].startIdxrepresents a codeunit index ins.Throws:If the sequence ending atstartIdxdoes not represent a well formed codepoint, then a std.utf.UTFException may be thrown.csindicates whether the comparisons are case sensitive.Examples:import std.typecons : No; string s = "Hello World"; writeln(lastIndexOf(s, "ll")); // 2 writeln(lastIndexOf(s, "Zo")); // -1 writeln(lastIndexOf(s, "lL", No.caseSensitive)); // 2
Examples:import std.typecons : No; string s = "Hello World"; writeln(lastIndexOf(s, "ll", 4)); // 2 writeln(lastIndexOf(s, "Zo", 128)); // -1 writeln(lastIndexOf(s, "lL", 3, No.caseSensitive)); // -1
- pure @safe ptrdiff_t
indexOfAny(Char, Char2)(const(Char)[]haystack, const(Char2)[]needles, in CaseSensitivecs= Yes.caseSensitive)
if (isSomeChar!Char && isSomeChar!Char2);
pure @safe ptrdiff_tindexOfAny(Char, Char2)(const(Char)[]haystack, const(Char2)[]needles, in size_tstartIdx, in CaseSensitivecs= Yes.caseSensitive)
if (isSomeChar!Char && isSomeChar!Char2); - Returns the index of the first occurrence of any of the elements in needles in
haystack. If no element ofneedlesis found, then -1 is returned. ThestartIdxsliceshaystackin the following way haystack[startIdx .. $].startIdxrepresents a codeunit index inhaystack. If the sequence ending atstartIdxdoes not represent a well formed codepoint, then a std.utf.UTFException may be thrown.Parameters:const(Char)[] haystackString to search for needles in. const(Char2)[] needlesStrings to search for in haystack. size_t startIdxslices haystack like this haystack[startIdx .. $]. If the startIdx is greater equal the length of haystack the functions returns -1. CaseSensitive csIndicates whether the comparisons are case sensitive. Examples:import std.conv : to; ptrdiff_t i = "helloWorld".indexOfAny("Wr"); writeln(i); // 5 i = "öällo world".indexOfAny("lo "); writeln(i); // 4
Examples:import std.conv : to; ptrdiff_t i = "helloWorld".indexOfAny("Wr", 4); writeln(i); // 5 i = "Foo öällo world".indexOfAny("lh", 3); writeln(i); // 8
- pure @safe ptrdiff_t
lastIndexOfAny(Char, Char2)(const(Char)[]haystack, const(Char2)[]needles, in CaseSensitivecs= Yes.caseSensitive)
if (isSomeChar!Char && isSomeChar!Char2);
pure @safe ptrdiff_tlastIndexOfAny(Char, Char2)(const(Char)[]haystack, const(Char2)[]needles, in size_tstopIdx, in CaseSensitivecs= Yes.caseSensitive)
if (isSomeChar!Char && isSomeChar!Char2); - Returns the index of the last occurrence of any of the elements in needles in
haystack. If no element ofneedlesis found, then -1 is returned. ThestopIdxsliceshaystackin the following way s[0 .. stopIdx].stopIdxrepresents a codeunit index inhaystack. If the sequence ending at startIdx does not represent a well formed codepoint, then a std.utf.UTFException may be thrown.Parameters:const(Char)[] haystackString to search for needles in. const(Char2)[] needlesStrings to search for in haystack. size_t stopIdxslices haystack like this haystack[0 .. stopIdx]. If the stopIdx is greater equal the length of haystack the functions returns -1. CaseSensitive csIndicates whether the comparisons are case sensitive. Examples:ptrdiff_t i = "helloWorld".lastIndexOfAny("Wlo"); writeln(i); // 8 i = "Foo öäöllo world".lastIndexOfAny("öF"); writeln(i); // 8
Examples:import std.conv : to; ptrdiff_t i = "helloWorld".lastIndexOfAny("Wlo", 4); writeln(i); // 3 i = "Foo öäöllo world".lastIndexOfAny("öF", 3); writeln(i); // 0
- pure @safe ptrdiff_t
indexOfNeither(Char, Char2)(const(Char)[]haystack, const(Char2)[]needles, in CaseSensitivecs= Yes.caseSensitive)
if (isSomeChar!Char && isSomeChar!Char2);
pure @safe ptrdiff_tindexOfNeither(Char, Char2)(const(Char)[]haystack, const(Char2)[]needles, in size_tstartIdx, in CaseSensitivecs= Yes.caseSensitive)
if (isSomeChar!Char && isSomeChar!Char2); - Returns the index of the first occurrence of any character not an elements in
needlesinhaystack. If all element ofhaystackare element ofneedles-1 is returned.Parameters:const(Char)[] haystackString to search for needles in. const(Char2)[] needlesStrings to search for in haystack. size_t startIdxslices haystack like this haystack[startIdx .. $]. If the startIdx is greater equal the length of haystack the functions returns -1. CaseSensitive csIndicates whether the comparisons are case sensitive. Examples:writeln(indexOfNeither("abba", "a", 2)); // 2 writeln(indexOfNeither("def", "de", 1)); // 2 writeln(indexOfNeither("dfefffg", "dfe", 4)); // 6
Examples:writeln(indexOfNeither("def", "a")); // 0 writeln(indexOfNeither("def", "de")); // 2 writeln(indexOfNeither("dfefffg", "dfe")); // 6
- pure @safe ptrdiff_t
lastIndexOfNeither(Char, Char2)(const(Char)[]haystack, const(Char2)[]needles, in CaseSensitivecs= Yes.caseSensitive)
if (isSomeChar!Char && isSomeChar!Char2);
pure @safe ptrdiff_tlastIndexOfNeither(Char, Char2)(const(Char)[]haystack, const(Char2)[]needles, in size_tstopIdx, in CaseSensitivecs= Yes.caseSensitive)
if (isSomeChar!Char && isSomeChar!Char2); - Returns the last index of the first occurence of any character that is not an elements in
needlesinhaystack. If all element ofhaystackare element ofneedles-1 is returned.Parameters:const(Char)[] haystackString to search for needles in. const(Char2)[] needlesStrings to search for in haystack. size_t stopIdxslices haystack like this haystack[0 .. stopIdx] If the stopIdx is greater equal the length of haystack the functions returns -1. CaseSensitive csIndicates whether the comparisons are case sensitive. Examples:writeln(lastIndexOfNeither("abba", "a")); // 2 writeln(lastIndexOfNeither("def", "f")); // 1
Examples:writeln(lastIndexOfNeither("def", "rsa", 3)); // -1 writeln(lastIndexOfNeither("abba", "a", 2)); // 1
- pure nothrow @nogc @safe auto
representation(Char)(Char[]s)
if (isSomeChar!Char); - Returns the representation of a string, which has the same type as the string except the character type is replaced by ubyte, ushort, or uint depending on the character width.Parameters:
Char[] sThe string to return the representation of. Returns:The representation of the passed string.Examples:string s = "hello"; static assert(is(typeof(representation(s)) == immutable(ubyte)[])); assert(representation(s) is cast(immutable(ubyte)[]) s); writeln(representation(s)); // [0x68, 0x65, 0x6c, 0x6c, 0x6f]
- pure @trusted S
capitalize(S)(Sinput)
if (isSomeString!S); - Capitalize the first character of s and convert the rest of s to lowercase.Parameters:
S inputThe string to capitalize. Returns:The capitalized string.See Also:std.uni.asCapitalized for a lazy range version that doesn't allocate memoryExamples:writeln(capitalize("hello")); // "Hello" writeln(capitalize("World")); // "World"
- alias
KeepTerminator= std.typecons.Flag!"keepTerminator".Flag;
pure @safe C[][]splitLines(C)(C[]s, KeepTerminatorkeepTerm= No.keepTerminator)
if (isSomeChar!C); - Split
sinto an array of lines according to the unicode standard using '\r', '\n', "\r\n", std.uni.lineSep, std.uni.paraSep, U+0085 (NEL), '\v' and '\f' as delimiters. IfkeepTermis set toKeepTerminator.yes, then the delimiter is included in the strings returned.Does not throw on invalid UTF; such is simply passed unchanged to the output. Allocates memory; use lineSplitter for an alternative that does not. Adheres to Unicode 7.0.Parameters:C[] sa string of chars, wchars, or dchars, or any custom type that casts to a string type KeepTerminatorkeepTermwhether delimiter is included or not in the results Returns:array of strings, each element is a line that is a slice ofsExamples:string s = "Hello\nmy\rname\nis"; writeln(splitLines(s)); // ["Hello", "my", "name", "is"]
- auto
lineSplitter(KeepTerminator keepTerm = No.keepTerminator, Range)(Ranger)
if (hasSlicing!Range && hasLength!Range && isSomeChar!(ElementType!Range) && !isSomeString!Range);
autolineSplitter(KeepTerminator keepTerm = No.keepTerminator, C)(C[]r)
if (isSomeChar!C); - Split an array or slicable range of characters into a range of lines using '\
r', '\n', '\v', '\f', "\r\n", std.uni.lineSep, std.uni.paraSep and '\u0085' (NEL) as delimiters. If keepTerm is set to Yes.keepTerminator, then the delimiter is included in the slices returned.Does not throw on invalid UTF; such is simply passed unchanged to the output. Adheres to Unicode 7.0. Does not allocate memory.Parameters:Range rarray of chars, wchars, or dchars or a slicable range keepTerm whether delimiter is included or not in the results Returns:range of slices of the input rangerExamples:import std.array : array; string s = "Hello\nmy\rname\nis"; /* notice the call to 'array' to turn the lazy range created by lineSplitter comparable to the string[] created by splitLines. */ writeln(lineSplitter(s).array); // splitLines(s)
Examples:auto s = "\rpeter\n\rpaul\r\njerry\u2028ice\u2029cream\n\nsunday\nmon\u2030day\n"; auto lines = s.lineSplitter(); static immutable witness = ["", "peter", "", "paul", "jerry", "ice", "cream", "", "sunday", "mon\u2030day"]; uint i; foreach (line; lines) { writeln(line); // witness[i++] } writeln(i); // witness.length
- auto
stripLeft(Range)(Rangeinput)
if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) && !isInfinite!Range && !isConvertibleToString!Range);
autostripLeft(Range, Char)(Rangeinput, const(Char)[]chars)
if ((isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) || isConvertibleToString!Range) && isSomeChar!Char); - Strips leading whitespace (as defined by std.uni.isWhite) or as specified in the second argument.Parameters:
Range inputstring or forward range of characters const(Char)[] charsstring of characters to be stripped Returns:inputstripped of leading whitespace or characters specified in the second argument.Postconditions
inputand the returned value will share the same tail (see std.array.sameTail).See Also:Generic stripping on ranges: std.algorithm.mutation.stripLeftExamples:import std.uni : lineSep, paraSep; assert(stripLeft(" hello world ") == "hello world "); assert(stripLeft("\n\t\v\rhello world\n\t\v\r") == "hello world\n\t\v\r"); assert(stripLeft("hello world") == "hello world"); assert(stripLeft([lineSep] ~ "hello world" ~ lineSep) == "hello world" ~ [lineSep]); assert(stripLeft([paraSep] ~ "hello world" ~ paraSep) == "hello world" ~ [paraSep]); import std.array : array; import std.utf : byChar; assert(stripLeft(" hello world "w.byChar).array == "hello world ");
Examples:assert(stripLeft(" hello world ", " ") == "hello world "); assert(stripLeft("xxxxxhello world ", "x") == "hello world "); assert(stripLeft("xxxyy hello world ", "xy ") == "hello world ");
Examples:import std.array : array; import std.utf : byChar, byWchar, byDchar; assert(stripLeft(" xxxyy hello world "w.byChar, "xy ").array == "hello world "); assert(stripLeft("\u2028\u2020hello world\u2028"w.byWchar, "\u2028").array == "\u2020hello world\u2028"); assert(stripLeft("\U00010001hello world"w.byWchar, " ").array == "\U00010001hello world"w); assert(stripLeft("\U00010001 xyhello world"d.byDchar, "\U00010001 xy").array == "hello world"d); writeln(stripLeft("\u2020hello"w, "\u2020"w)); // "hello"w writeln(stripLeft("\U00010001hello"d, "\U00010001"d)); // "hello"d writeln(stripLeft(" hello ", "")); // " hello "
- auto
stripRight(Range)(Rangestr)
if (isSomeString!Range || isRandomAccessRange!Range && hasLength!Range && hasSlicing!Range && !isConvertibleToString!Range && isSomeChar!(ElementEncodingType!Range));
autostripRight(Range, Char)(Rangestr, const(Char)[]chars)
if ((isBidirectionalRange!Range && isSomeChar!(ElementEncodingType!Range) || isConvertibleToString!Range) && isSomeChar!Char); - Strips trailing whitespace (as defined by std.uni.isWhite) or as specified in the second argument.Parameters:
Range strstring or random access range of characters const(Char)[] charsstring of characters to be stripped Returns:slice ofstrstripped of trailing whitespace or characters specified in the second argument.See Also:Generic stripping on ranges: std.algorithm.mutation.stripRightExamples:import std.uni : lineSep, paraSep; assert(stripRight(" hello world ") == " hello world"); assert(stripRight("\n\t\v\rhello world\n\t\v\r") == "\n\t\v\rhello world"); assert(stripRight("hello world") == "hello world"); assert(stripRight([lineSep] ~ "hello world" ~ lineSep) == [lineSep] ~ "hello world"); assert(stripRight([paraSep] ~ "hello world" ~ paraSep) == [paraSep] ~ "hello world");
Examples:assert(stripRight(" hello world ", "x") == " hello world "); assert(stripRight(" hello world ", " ") == " hello world"); assert(stripRight(" hello worldxy ", "xy ") == " hello world");
- auto
strip(Range)(Rangestr)
if (isSomeString!Range || isRandomAccessRange!Range && hasLength!Range && hasSlicing!Range && !isConvertibleToString!Range && isSomeChar!(ElementEncodingType!Range));
autostrip(Range, Char)(Rangestr, const(Char)[]chars)
if ((isBidirectionalRange!Range && isSomeChar!(ElementEncodingType!Range) || isConvertibleToString!Range) && isSomeChar!Char);
autostrip(Range, Char)(Rangestr, const(Char)[]leftChars, const(Char)[]rightChars)
if ((isBidirectionalRange!Range && isSomeChar!(ElementEncodingType!Range) || isConvertibleToString!Range) && isSomeChar!Char); - Strips both leading and trailing whitespace (as defined by std.uni.isWhite) or as specified in the second argument.Parameters:
Range strstring or random access range of characters const(Char)[] charsstring of characters to be stripped const(Char)[] leftCharsstring of leading characters to be stripped const(Char)[] rightCharsstring of trailing characters to be stripped Returns:slice ofstrstripped of leading and trailing whitespace or characters as specified in the second argument.See Also:Generic stripping on ranges: std.algorithm.mutation.stripExamples:import std.uni : lineSep, paraSep; assert(strip(" hello world ") == "hello world"); assert(strip("\n\t\v\rhello world\n\t\v\r") == "hello world"); assert(strip("hello world") == "hello world"); assert(strip([lineSep] ~ "hello world" ~ [lineSep]) == "hello world"); assert(strip([paraSep] ~ "hello world" ~ [paraSep]) == "hello world");
Examples:assert(strip(" hello world ", "x") == " hello world "); assert(strip(" hello world ", " ") == "hello world"); assert(strip(" xyxyhello worldxyxy ", "xy ") == "hello world"); writeln(strip("\u2020hello\u2020"w, "\u2020"w)); // "hello"w writeln(strip("\U00010001hello\U00010001"d, "\U00010001"d)); // "hello"d writeln(strip(" hello ", "")); // " hello "
Examples:writeln(strip("xxhelloyy", "x", "y")); // "hello" assert(strip(" xyxyhello worldxyxyzz ", "xy ", "xyz ") == "hello world"); writeln(strip("\u2020hello\u2028"w, "\u2020"w, "\u2028"w)); // "hello"w assert(strip("\U00010001hello\U00010002"d, "\U00010001"d, "\U00010002"d) == "hello"d); writeln(strip(" hello ", "", "")); // " hello "
- Range
chomp(Range)(Rangestr)
if ((isRandomAccessRange!Range && isSomeChar!(ElementEncodingType!Range) || isNarrowString!Range) && !isConvertibleToString!Range);
Rangechomp(Range, C2)(Rangestr, const(C2)[]delimiter)
if ((isBidirectionalRange!Range && isSomeChar!(ElementEncodingType!Range) || isNarrowString!Range) && !isConvertibleToString!Range && isSomeChar!C2); - If
strends withdelimiter, thenstris returned withoutdelimiteron its end. If itstrdoes not end withdelimiter, then it is returned unchanged.If nodelimiteris given, then one trailing '\r', '\n', "\r\n", '\f', '\v', std.uni.lineSep, std.uni.paraSep, or std.uni.nelSep is removed from the end ofstr. Ifstrdoes not end with any of those characters, then it is returned unchanged.Parameters:Range strstring or indexable range of characters const(C2)[] delimiterstring of characters to be sliced off end of str[] Returns:slice of strExamples:import std.uni : lineSep, paraSep, nelSep; import std.utf : decode; writeln(chomp(" hello world \n\r")); // " hello world \n" writeln(chomp(" hello world \r\n")); // " hello world " writeln(chomp(" hello world \f")); // " hello world " writeln(chomp(" hello world \v")); // " hello world " writeln(chomp(" hello world \n\n")); // " hello world \n" writeln(chomp(" hello world \n\n ")); // " hello world \n\n " writeln(chomp(" hello world \n\n" ~ [lineSep])); // " hello world \n\n" writeln(chomp(" hello world \n\n" ~ [paraSep])); // " hello world \n\n" writeln(chomp(" hello world \n\n" ~ [nelSep])); // " hello world \n\n" writeln(chomp(" hello world")); // " hello world" writeln(chomp("")); // "" writeln(chomp(" hello world", "orld")); // " hello w" writeln(chomp(" hello world", " he")); // " hello world" writeln(chomp("", "hello")); // "" // Don't decode pointlessly writeln(chomp("hello\xFE", "\r")); // "hello\xFE"
- Range
chompPrefix(Range, C2)(Rangestr, const(C2)[]delimiter)
if ((isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) || isNarrowString!Range) && !isConvertibleToString!Range && isSomeChar!C2); - If
strstarts withdelimiter, then the part ofstrfollowingdelimiteris returned. Ifstrdoes not start withdelimiter, then it is returned unchanged.Parameters:Range strstring or forward range of characters const(C2)[] delimiterstring of characters to be sliced off front of str[] Returns:slice of strExamples:writeln(chompPrefix("hello world", "he")); // "llo world" writeln(chompPrefix("hello world", "hello w")); // "orld" writeln(chompPrefix("hello world", " world")); // "hello world" writeln(chompPrefix("", "hello")); // ""
- Range
chop(Range)(Rangestr)
if ((isBidirectionalRange!Range && isSomeChar!(ElementEncodingType!Range) || isNarrowString!Range) && !isConvertibleToString!Range); - Returns
strwithout its last character, if there is one. Ifstrends with "\r\n", then both are removed. Ifstris empty, then it is returned unchanged.Parameters:Range strstring (must be valid UTF) Returns:slice of strExamples:writeln(chop("hello world")); // "hello worl" writeln(chop("hello world\n")); // "hello world" writeln(chop("hello world\r")); // "hello world" writeln(chop("hello world\n\r")); // "hello world\n" writeln(chop("hello world\r\n")); // "hello world" writeln(chop("Walter Bright")); // "Walter Brigh" writeln(chop("")); // ""
- S
leftJustify(S)(Ss, size_twidth, dcharfillChar= ' ')
if (isSomeString!S); - Left justify
sin a fieldwidthcharacters wide.fillCharis the character that will be used to fill up the space in the field thatsdoesn't fill.Parameters:S sstring size_t widthminimum field width dchar fillCharused to pad end up to widthcharactersReturns:GC allocated stringSee Also:leftJustifier, which does not allocateExamples:writeln(leftJustify("hello", 7, 'X')); // "helloXX" writeln(leftJustify("hello", 2, 'X')); // "hello" writeln(leftJustify("hello", 9, 'X')); // "helloXXXX"
- auto
leftJustifier(Range)(Ranger, size_twidth, dcharfillChar= ' ')
if (isInputRange!Range && isSomeChar!(ElementEncodingType!Range) && !isConvertibleToString!Range); - Left justify s in a field
widthcharacters wide.fillCharis the character that will be used to fill up the space in the field that s doesn't fill.Parameters:Range rstring or range of characters size_t widthminimum field width dchar fillCharused to pad end up to widthcharactersReturns:a lazy range of the left justified resultSee Also:Examples:import std.algorithm.comparison : equal; import std.utf : byChar; assert(leftJustifier("hello", 2).equal("hello".byChar)); assert(leftJustifier("hello", 7).equal("hello ".byChar)); assert(leftJustifier("hello", 7, 'x').equal("helloxx".byChar));
- S
rightJustify(S)(Ss, size_twidth, dcharfillChar= ' ')
if (isSomeString!S); - Right justify
sin a fieldwidthcharacters wide.fillCharis the character that will be used to fill up the space in the field thatsdoesn't fill.Parameters:S sstring size_t widthminimum field width dchar fillCharused to pad end up to widthcharactersReturns:GC allocated stringSee Also:rightJustifier, which does not allocateExamples:writeln(rightJustify("hello", 7, 'X')); // "XXhello" writeln(rightJustify("hello", 2, 'X')); // "hello" writeln(rightJustify("hello", 9, 'X')); // "XXXXhello"
- auto
rightJustifier(Range)(Ranger, size_twidth, dcharfillChar= ' ')
if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) && !isConvertibleToString!Range); - Right justify s in a field
widthcharacters wide.fillCharis the character that will be used to fill up the space in the field that s doesn't fill.Parameters:Range rstring or forward range of characters size_t widthminimum field width dchar fillCharused to pad end up to widthcharactersReturns:a lazy range of the right justified resultSee Also:Examples:import std.algorithm.comparison : equal; import std.utf : byChar; assert(rightJustifier("hello", 2).equal("hello".byChar)); assert(rightJustifier("hello", 7).equal(" hello".byChar)); assert(rightJustifier("hello", 7, 'x').equal("xxhello".byChar));
- S
center(S)(Ss, size_twidth, dcharfillChar= ' ')
if (isSomeString!S); - Center
sin a fieldwidthcharacters wide.fillCharis the character that will be used to fill up the space in the field thatsdoesn't fill.Parameters:S sThe string to center size_t widthWidth of the field to center sindchar fillCharThe character to use for filling excess space in the field Returns:The resulting center-justified string. The returned string is GC-allocated. To avoid GC allocation, use centerJustifier instead.Examples:writeln(center("hello", 7, 'X')); // "XhelloX" writeln(center("hello", 2, 'X')); // "hello" writeln(center("hello", 9, 'X')); // "XXhelloXX"
- auto
centerJustifier(Range)(Ranger, size_twidth, dcharfillChar= ' ')
if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) && !isConvertibleToString!Range); - Center justify
rin a fieldwidthcharacters wide.fillCharis the character that will be used to fill up the space in the field thatrdoesn't fill.Parameters:Range rstring or forward range of characters size_t widthminimum field width dchar fillCharused to pad end up to widthcharactersReturns:a lazy range of the center justified resultSee Also:Examples:import std.algorithm.comparison : equal; import std.utf : byChar; assert(centerJustifier("hello", 2).equal("hello".byChar)); assert(centerJustifier("hello", 8).equal(" hello ".byChar)); assert(centerJustifier("hello", 7, 'x').equal("xhellox".byChar));
- pure auto
detab(Range)(auto ref Ranges, size_ttabSize= 8)
if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) || __traits(compiles, StringTypeOf!Range)); - Replace each tab character in
swith the number of spaces necessary to align the following character at the next tab stop.Parameters:Range sstring size_t tabSizedistance between tab stops Returns:GC allocated string with tabs replaced with spacesExamples:writeln(detab(" \n\tx", 9)); // " \n x"
- auto
detabber(Range)(Ranger, size_ttabSize= 8)
if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) && !isConvertibleToString!Range); - Replace each tab character in
rwith the number of spaces necessary to align the following character at the next tab stop.Parameters:Range rstring or forward range size_t tabSizedistance between tab stops Returns:lazy forward range with tabs replaced with spacesExamples:import std.array : array; writeln(detabber(" \n\tx", 9).array); // " \n x"
- auto
entab(Range)(Ranges, size_ttabSize= 8)
if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range)); - Replaces spaces in
swith the optimal number of tabs. All spaces and tabs at the end of a line are removed.Parameters:Range sString to convert. size_t tabSizeTab columns are tabSizespaces apart.Returns:GC allocated string with spaces replaced with tabs; use entabber to not allocate.See Also:Examples:writeln(entab(" x \n")); // "\tx\n"
- auto
entabber(Range)(Ranger, size_ttabSize= 8)
if (isForwardRange!Range && !isConvertibleToString!Range); - Replaces spaces in range
rwith the optimal number of tabs. All spaces and tabs at the end of a line are removed.Parameters:Range rstring or forward range size_t tabSizedistance between tab stops Returns:lazy forward range with spaces replaced with tabsSee Also:Examples:import std.array : array; writeln(entabber(" x \n").array); // "\tx\n"
- pure @safe C1[]
translate(C1, C2 = immutable(char))(C1[]str, in dchar[dchar]transTable, const(C2)[]toRemove= null)
if (isSomeChar!C1 && isSomeChar!C2);
pure @safe C1[]translate(C1, S, C2 = immutable(char))(C1[]str, in S[dchar]transTable, const(C2)[]toRemove= null)
if (isSomeChar!C1 && isSomeString!S && isSomeChar!C2); - Replaces the characters in
strwhich are keys intransTablewith their corresponding values intransTable.transTableis an AA where its keys are dchar and its values are either dchar or some type of string. Also, iftoRemoveis given, the characters in it are removed fromstrprior to translation.stritself is unaltered. A copy with the changes is returned.See Also:Parameters:C1[] strThe original string. dchar[dchar] transTableThe AA indicating which characters to replace and what to replace them with. const(C2)[] toRemoveThe characters to remove from the string. Examples:dchar[dchar] transTable1 = ['e' : '5', 'o' : '7', '5': 'q']; writeln(translate("hello world", transTable1)); // "h5ll7 w7rld" writeln(translate("hello world", transTable1, "low")); // "h5 rd" string[dchar] transTable2 = ['e' : "5", 'o' : "orange"]; writeln(translate("hello world", transTable2)); // "h5llorange worangerld"
- void
translate(C1, C2 = immutable(char), Buffer)(C1[]str, in dchar[dchar]transTable, const(C2)[]toRemove, Bufferbuffer)
if (isSomeChar!C1 && isSomeChar!C2 && isOutputRange!(Buffer, C1));
voidtranslate(C1, S, C2 = immutable(char), Buffer)(C1[]str, in S[dchar]transTable, const(C2)[]toRemove, Bufferbuffer)
if (isSomeChar!C1 && isSomeString!S && isSomeChar!C2 && isOutputRange!(Buffer, S)); - This is an overload of
translatewhich takes an existing buffer to write the contents to.Parameters:C1[] strThe original string. dchar[dchar] transTableThe AA indicating which characters to replace and what to replace them with. const(C2)[] toRemoveThe characters to remove from the string. Buffer bufferAn output range to write the contents to. Examples:import std.array : appender; dchar[dchar] transTable1 = ['e' : '5', 'o' : '7', '5': 'q']; auto buffer = appender!(dchar[])(); translate("hello world", transTable1, null, buffer); writeln(buffer.data); // "h5ll7 w7rld" buffer.clear(); translate("hello world", transTable1, "low", buffer); writeln(buffer.data); // "h5 rd" buffer.clear(); string[dchar] transTable2 = ['e' : "5", 'o' : "orange"]; translate("hello world", transTable2, null, buffer); writeln(buffer.data); // "h5llorange worangerld"
- pure nothrow @trusted C[]
translate(C = immutable(char))(scope const(char)[]str, scope const(char)[]transTable, scope const(char)[]toRemove= null)
if (is(Unqual!C == char)); - This is an ASCII-only overload of translate. It will not work with Unicode. It exists as an optimization for the cases where Unicode processing is not necessary.Unlike the other overloads of translate, this one does not take an AA. Rather, it takes a string generated by makeTransTable. The array generated by makeTransTable is 256 elements long such that the index is equal to the ASCII character being replaced and the value is equal to the character that it's being replaced with. Note that translate does not decode any of the characters, so you can actually pass it Extended ASCII characters if you want to (ASCII only actually uses 128 characters), but be warned that Extended ASCII characters are not valid Unicode and therefore will result in a UTFException being thrown from most other Phobos functions. Also, because no decoding occurs, it is possible to use this overload to translate ASCII characters within a proper UTF-8 string without altering the other, non-ASCII characters. It's replacing any code unit greater than 127 with another code unit or replacing any code unit with another code unit greater than 127 which will cause UTF validation issues.See Also:Parameters:
const(char)[] strThe original string. const(char)[] transTableThe string indicating which characters to replace and what to replace them with. It is generated by makeTransTable. const(char)[] toRemoveThe characters to remove from the string. Examples:auto transTable1 = makeTrans("eo5", "57q"); writeln(translate("hello world", transTable1)); // "h5ll7 w7rld" writeln(translate("hello world", transTable1, "low")); // "h5 rd"
- pure nothrow @trusted string
makeTrans(scope const(char)[]from, scope const(char)[]to); - Do same thing as makeTransTable but allocate the translation table on the GC heap.Use makeTransTable instead.Examples:
auto transTable1 = makeTrans("eo5", "57q"); writeln(translate("hello world", transTable1)); // "h5ll7 w7rld" writeln(translate("hello world", transTable1, "low")); // "h5 rd"
- pure nothrow @nogc @safe char[256]
makeTransTable(scope const(char)[]from, scope const(char)[]to); - Construct 256 character translation table, where characters in from[] are replaced by corresponding characters in to[].Parameters:
const(char)[] fromarray of chars, less than or equal to 256 in length const(char)[] tocorresponding array of chars to translate to Returns:translation arrayExamples:writeln(translate("hello world", makeTransTable("hl", "q5"))); // "qe55o wor5d" writeln(translate("hello world", makeTransTable("12345", "67890"))); // "hello world"
- pure @trusted void
translate(C = immutable(char), Buffer)(scope const(char)[]str, scope const(char)[]transTable, scope const(char)[]toRemove, Bufferbuffer)
if (is(Unqual!C == char) && isOutputRange!(Buffer, char)); - This is an ASCII-only overload of
translatewhich takes an existing buffer to write the contents to.Parameters:const(char)[] strThe original string. const(char)[] transTableThe string indicating which characters to replace and what to replace them with. It is generated by makeTransTable. const(char)[] toRemoveThe characters to remove from the string. Buffer bufferAn output range to write the contents to. Examples:import std.array : appender; auto buffer = appender!(char[])(); auto transTable1 = makeTransTable("eo5", "57q"); translate("hello world", transTable1, null, buffer); writeln(buffer.data); // "h5ll7 w7rld" buffer.clear(); translate("hello world", transTable1, "low", buffer); writeln(buffer.data); // "h5 rd"
- pure @safe S
succ(S)(Ss)
if (isSomeString!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.Examples:
writeln(succ("1")); // "2" writeln(succ("9")); // "10" writeln(succ("999")); // "1000" writeln(succ("zz99")); // "aaa00"
- C1[]
tr(C1, C2, C3, C4 = immutable(char))(C1[]str, const(C2)[]from, const(C3)[]to, const(C4)[]modifiers= null); - Replaces the characters in
strwhich are infromwith the the corresponding characters intoand returns the resulting string.tris based on Posix's tr, though it doesn't do everything that the Posix utility does.Parameters:C1[] strThe original string. const(C2)[] fromThe characters to replace. const(C3)[] toThe characters to replace with. const(C4)[] modifiersString containing modifiers. Modifiers
If the modifier 'd' is present, then the number of characters inModifier 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 tomay be only 0 or 1. If the modifier 'd' is not present, andtois empty, thentois taken to be the same asfrom. If the modifier 'd' is not present, andtois shorter thanfrom, thentois extended by replicating the last character into. Bothfromandtomay contain ranges using the '-' character (e.g. "a-d" is synonymous with "abcd".) Neither accept a leading '^' as meaning the complement of the string (use the 'c' modifier for that).Examples:writeln(tr("abcdef", "cd", "CD")); // "abCDef" writeln(tr("1st March, 2018", "March", "MAR", "s")); // "1st MAR, 2018" writeln(tr("abcdef", "ef", "", "d")); // "abcd" writeln(tr("14-Jul-87", "a-zA-Z", " ", "cs")); // " Jul "
- bool
isNumeric(S)(Ss, boolbAllowSep= false)
if (isSomeString!S || isRandomAccessRange!S && hasSlicing!S && isSomeChar!(ElementType!S) && !isInfinite!S); - Takes a string
sand determines if it represents a number. This function also takes an optional parameter,bAllowSep, which will accept the separator characters ',' and '__' within the string. But these characters should be stripped from the string before using any of the conversion functions like to!int(), to!float(), and etc else an error will occur.Also please note, that no spaces are allowed within the string anywhere whether it's a leading, trailing, or embedded space(s), thus they too must be stripped from the string before using this function, or any of the conversion functions.Parameters:S sthe string or random access range to check bool bAllowSepaccept separator characters or not Returns:boolExamples:Integer Whole Number: (byte, ubyte, short, ushort, int, uint, long, and ulong) ['+'|'-']digit(s)[U|L|UL]assert(isNumeric("123")); assert(isNumeric("123UL")); assert(isNumeric("123L")); assert(isNumeric("+123U")); assert(isNumeric("-123L"));
Examples:Floating-Point Number: (float, double, real, ifloat, idouble, and ireal) ['+'|'-']digit(s)[.][digit(s)][[e-|e+]digit(s)][i|f|L|Li|fi]] or [nan|nani|inf|-inf]assert(isNumeric("+123")); assert(isNumeric("-123.01")); assert(isNumeric("123.3e-10f")); assert(isNumeric("123.3e-10fi")); assert(isNumeric("123.3e-10L")); assert(isNumeric("nan")); assert(isNumeric("nani")); assert(isNumeric("-inf"));
Examples:Floating-Point Number: (cfloat, cdouble, and creal) ['+'|'-']digit(s)[.][digit(s)][[e-|e+]digit(s)][+] [digit(s)[.][digit(s)][[e-|e+]digit(s)][i|f|L|Li|fi]] or [nan|nani|nan+nani|inf|-inf]assert(isNumeric("-123e-1+456.9e-10Li")); assert(isNumeric("+123e+10+456i")); assert(isNumeric("123+456"));
Examples:isNumeric works with CTFEenum a = isNumeric("123.00E-5+1234.45E-12Li"); enum b = isNumeric("12345xxxx890"); static assert( a); static assert(!b);
- char[4]
soundexer(Range)(Rangestr)
if (isInputRange!Range && isSomeChar!(ElementEncodingType!Range) && !isConvertibleToString!Range);
char[4]soundexer(Range)(auto ref Rangestr)
if (isConvertibleToString!Range); - Soundex algorithm.The Soundex algorithm converts a word into 4 characters based on how the word sounds phonetically. The idea is that two spellings that sound alike will have the same Soundex value, which means that Soundex can be used for fuzzy matching of names.Parameters:
Range strString or InputRange to convert to Soundex representation. Returns:The four character array with the Soundex result in it. The array has zero's in it if there is no Soundex representation for the string.See Also:Note Only works well with English names.
Examples:writeln(soundexer("Gauss")); // "G200" writeln(soundexer("Ghosh")); // "G200" writeln(soundexer("Robert")); // "R163" writeln(soundexer("Rupert")); // "R163" writeln(soundexer("0123^&^^**&^")); // ['\0', '\0', '\0', '\0']
- pure nothrow @safe char[]
soundex(scope const(char)[]str, char[]buffer= null); - Like soundexer, but with different parameters and return value.Parameters:
const(char)[] strString to convert to Soundex representation. char[] bufferOptional 4 char array to put the resulting Soundex characters into. If null, the return value buffer will be allocated on the heap. Returns:The four character array with the Soundex result in it. Returns null if there is no Soundex representation for the string.See Also:Examples:writeln(soundex("Gauss")); // "G200" writeln(soundex("Ghosh")); // "G200" writeln(soundex("Robert")); // "R163" writeln(soundex("Rupert")); // "R163" writeln(soundex("0123^&^^**&^")); // null
- pure @safe string[string]
abbrev(string[]values); - Construct an associative array consisting of all abbreviations that uniquely map to the strings in values.This is useful in cases where the user is expected to type in one of a known set of strings, and the program will helpfully auto-complete the string once sufficient characters have been entered that uniquely identify it.Examples:
import std.string; static string[] list = [ "food", "foxy" ]; auto abbrevs = abbrev(list); assert(abbrevs == ["fox": "foxy", "food": "food", "foxy": "foxy", "foo": "food"]);
- size_t
column(Range)(Rangestr, in size_ttabsize= 8)
if ((isInputRange!Range && isSomeChar!(Unqual!(ElementEncodingType!Range)) || isNarrowString!Range) && !isConvertibleToString!Range); - Compute column number at the end of the printed form of the string, assuming the string starts in the leftmost column, which is numbered starting from 0.Tab characters are expanded into enough spaces to bring the column number to the next multiple of tabsize. If there are multiple lines in the string, the column number of the last line is returned.Parameters:
Range strstring or InputRange to be analyzed size_t tabsizenumber of columns a tab character represents Returns:column numberExamples:import std.utf : byChar, byWchar, byDchar; writeln(column("1234 ")); // 5 writeln(column("1234 "w)); // 5 writeln(column("1234 "d)); // 5 writeln(column("1234 ".byChar())); // 5 writeln(column("1234 "w.byWchar())); // 5 writeln(column("1234 "d.byDchar())); // 5 // Tab stops are set at 8 spaces by default; tab characters insert enough // spaces to bring the column position to the next multiple of 8. writeln(column("\t")); // 8 writeln(column("1\t")); // 8 writeln(column("\t1")); // 9 writeln(column("123\t")); // 8 // Other tab widths are possible by specifying it explicitly: writeln(column("\t", 4)); // 4 writeln(column("1\t", 4)); // 4 writeln(column("\t1", 4)); // 5 writeln(column("123\t", 4)); // 4 // New lines reset the column number. writeln(column("abc\n")); // 0 writeln(column("abc\n1")); // 1 writeln(column("abcdefg\r1234")); // 4 writeln(column("abc\u20281")); // 1 writeln(column("abc\u20291")); // 1 writeln(column("abc\u00851")); // 1 writeln(column("abc\u00861")); // 5
- S
wrap(S)(Ss, in size_tcolumns= 80, Sfirstindent= null, Sindent= null, in size_ttabsize= 8)
if (isSomeString!S); - Wrap text into a paragraph.The input text string s is formed into a paragraph by breaking it up into a sequence of lines, delineated by \n, such that the number of columns is not exceeded on each line. The last line is terminated with a \n.Parameters:
S stext string to be wrapped size_t columnsmaximum number of columns in the paragraph S firstindentstring used to indent first line of the paragraph S indentstring to use to indent following lines of the paragraph size_t tabsizecolumn spacing of tabs in firstindent[] and indent[] Returns:resulting paragraph as an allocated stringExamples:writeln(wrap("a short string", 7)); // "a short\nstring\n" // wrap will not break inside of a word, but at the next space writeln(wrap("a short string", 4)); // "a\nshort\nstring\n" writeln(wrap("a short string", 7, "\t")); // "\ta\nshort\nstring\n" writeln(wrap("a short string", 7, "\t", " ")); // "\ta\n short\n string\n"
- pure @safe S
outdent(S)(Sstr)
if (isSomeString!S); - Removes one level of indentation from a multi-line string.This uniformly outdents the text as much as possible. Whitespace-only lines are always converted to blank lines. Does not allocate memory if it does not throw.Parameters:
S strmulti-line string Returns:outdented stringThrows:StringException if indentation is done with different sequences of whitespace characters.Examples:enum pretty = q{ import std.stdio; void main() { writeln("Hello"); } }.outdent(); enum ugly = q{ import std.stdio; void main() { writeln("Hello"); } }; writeln(pretty); // ugly
- pure @safe S[]
outdent(S)(S[]lines)
if (isSomeString!S); - Removes one level of indentation from an array of single-line strings.This uniformly outdents the text as much as possible. Whitespace-only lines are always converted to blank lines.Parameters:
S[] linesarray of single-line strings Returns:lines[] is rewritten in place with outdented linesThrows:StringException if indentation is done with different sequences of whitespace characters.Examples:auto str1 = [ " void main()\n", " {\n", " test();\n", " }\n" ]; auto str1Expected = [ "void main()\n", "{\n", " test();\n", "}\n" ]; writeln(str1.outdent); // str1Expected auto str2 = [ "void main()\n", " {\n", " test();\n", " }\n" ]; writeln(str2.outdent); // str2
- pure auto
assumeUTF(T)(T[]arr)
if (staticIndexOf!(Unqual!T, ubyte, ushort, uint) != -1); - Assume the given array of integers
arris a well-formed UTF string and return it typed as a UTF string.ubyte becomes char, ushort becomes wchar and uint becomes dchar. Type qualifiers are preserved. When compiled with debug mode, this function performs an extra check to make sure the return value is a valid Unicode string.Parameters:T[] arrarray of bytes, ubytes, shorts, ushorts, ints, or uints Returns:arr retyped as an array of chars, wchars, or dcharsSee Also:Examples:string a = "Hölo World"; immutable(ubyte)[] b = a.representation; string c = b.assumeUTF; writeln(a); // c
Copyright © 1999-2018 by the D Language Foundation | Page generated by
Ddoc on Thu Nov 1 12:28:48 2018