String Operators
This section lists operators that take strings as arguments. Moreover, operators that generate strings from other values are treated as well.
Elementary String Operations
String concatenation <string1> + <string2>
:
Description: The
+
operator can also be used to append one string to another. The result of such an operation is again a string. If in an addition operation at least one of the arguments is a string, then the other argument will be automatically converted to a string representation of its value.
Examples:
expression | evaluates to
|
"Cindy"+"Script" | "CindyScript"
|
"Four plus three is "+(4+3) | "Four plus three is 7"
|
""+(4+3) | "7" .
|
See also: The
+
operator is also used for the addition of usual numerical values. For this see
Arithmetic Operators.
Conversion to string text(<expr>)
:
Description: The operator
text(<expr>)
evaluates the expression
<expr>
and converts the result to a string representation.
Length of a string length(<string>)
:
Description: This operator returns the number of characters in a string.
Example: length("CindyScript")
evaluates to the integer
11
.
See Also: Lists
Extracting a substring substring(<string>,<int1>,<int2>)
:
Description: This operator returns the substring of
<string>
that begin after the character indexed by the integer
<int1>
and ends with the character indexed by
<int2>
.
Example: substring("abcdefg",3,6)
evaluates to the string
"def"
.
Searching for occurrence indexof(<string1>,<string2>)
:
Description: This operator searches for the first occurrence of
<string2>
in
<string1>
. The index of this first occurrence is returned. If
<string2>
is not a substring of
<string1>
, then the value
0
is returned.
expression | evaluates to
|
indexof("CindyScript","i") | 2
|
indexof("CindyScript","y") | 5
|
indexof("CindyScript","z") | 0
|
Searching for occurrence indexof(<string1>,<string2>,<int>)
:
Description: This operator searches for the first occurrence of
<string2>
in
<string1>
after the index i
. The index of this first such occurrence is returned. If
<string2>
does not occur in
<string1>
after index
i
., then the value
0
is returned.
expression | evaluates to
|
indexof("CindyScript","i",1) | 2
|
indexof("CindyScript","i",3) | 9
|
indexof("CindyScript","i",10) | 0
|
Advanced String Operations
Dissecting a string tokenize(<string>,<expr>)
:
Description: This operator is very useful for parsing input. It creates a list of substrings of
<string>
. The second argument
<expr>
must be either a string or a list of strings. If
<expr>
is a string, then the operator searches for occurrences of this string in
<string>
. These occurrences serve as markers for breaking up <string> into a list of pieces.
If <expr> is a list of strings, then a hierarchical list is generated that represents the subdivision of
<string>
recursively by the tokens in the list.
Examples:
expression | evaluates to
|
tokenize("one:two--three:four",":") | ["one", "two--three", "four"]
|
tokenize("one:two--three:four","-") | ["one:two", "", "three:four"]
|
tokenize("one:two--three:four","--") | ["one:two", "three:four"]
|
tokenize("one:two--three:four",["-",":"]) | [["one", "two"], [], ["three", "four"]]
|
tokenize("one:two--three:four",["--",":"]) | [["one", "two"], ["three", "four"]]
|
Replacing in strings replace(<string1>,<string2>,<string3>)
:
Description: This operator replaces all (!) occurrences of <string2> in <string1> by <string3>.
Examples:
expression | evaluates to
|
replace("one:two--three:four","o","XXX") | "XXXne:twXXX--three:fXXXur"
|
replace("F","F","F+F") | "F+F"
|
replace("F+F","F","F+F") | "F+F+F+F"
|
Replacing in strings replace(<string>,<list>)
:
Description: This operator is very similar to the previous one.
<list>
contains a list of replacement pairs, and all such replacements are applied simultaneously to
<string>
.
Examples:
expression | evaluates to
|
replace("XYX",[["X","one"],["Y","two"]]) | "onetwoone"
|
Parsing a string parse(<string>)
:
Description: This operator parses a string to an expression and evaluates this expression. This operator is particularly useful in processing user input that comes from text fields in a construction.
Examples:
expression | evaluates to
|
parse("3+7") | 10
|
The code fragment
text="sin(x)+cos(x)";
f(x):=parse(text);
defines the function
f(x)
to be
sin(x)+cos(x)
.
Parsing a string guess(<number>)
:
Description: This very powerful operator is described in detail in the section
Special Operators. It takes a numerical expression in floating-point representation and attempts to convert it to a mathematical expression that generates that floating-point number with high precision. This expression is then represented as a string.
Examples:
expression | evaluates to
|
guess(8.125) | "65/8"
|
guess(0.774596669241483) | "sqrt(3/5)"
|
See also: Calculus
Formating a number to a specified precision format(<number>,<int>)
:
Description: This operator takes a number as first arguments and an integer specifying the number of digits after the decimal point. A string is generated that corresponds to the number up to the specified precision. Up to 14 digits are possible.
Examples:
expression | evaluates to
|
format(sqrt(2),4) | "1.4142"
|
format(pi,14) | "3.14159265358979"
|
String Comparison and Sorting
Like real numbers, strings admit a total ordering. Thus they can be compared using the operators
>,
<,
>=,
<=,
==, and
!=. Please refer to
Boolean Operators for the use of these relations.
The order that is used for strings is lexicographic (dictionary) order. Thus, for example,
"a"<"abd"<"abe"<"b"<"blue"<"blunt"<"xxx"
Sorting of lists sort(<list>)
:
Sorting of lists sort(<list>,<expr>)
:
Sorting of lists sort(<list>,<var>,<expr>)
:
Description: The various versions of the
sort
-operator can be used to sort lists that contain string values. The sorting order is usually taken to be the lexicographic order of the words. Alternatively, one can specify a user-defined sorting function such as the lengths of the strings.
Examples:
expression | evaluates to
|
sort(["one","two","three","four","five"]) | ["five","four","one","three","two"]
|
sort(["one","two","three","four","five"],length(#)) | ["one","two","four","five","three"]
|
See also: Lists
Accessing and Replacing Characters
Index operator <string>_<int>
:
Description: The infix operator
_
, which accesses the fields of a list, can be also used to access a character at a specific position in a string. Characters can be returned and set with this operator.
Examples:
expression | evaluates to
|
"CindyScript"_5 | "y"
|
"CindyScript"_12 | _?_
|
After evaluating the code fragement
a="CindyScript";
a_5="erella";
the variable
a
contains the string
"CinderellaScript"
.