9.77 String

The type String provides character strings. Character strings provide all the operations for a one-dimensional array of characters, plus additional operations for manipulating text. For more information on related topics, see CharacterXmpPage and CharacterClassXmpPage . You can also issue the system command )show String to display the full list of operations defined by String.

String values can be created using double quotes.

hello := "Hello AXIOM!"

\[\]

“HelloAXIOM!”

_{Type: String}

Note, however, that double quotes and underscores must be preceded by an extra underscore.

said := "Jane said, _"Look!_""

\[\]

“Janesaid,”Look!”“

_{Type: String}

saw := "She saw exactly one underscore: __."

\[\]

_{Type: String}

It is also possible to use newnewString to create a string of any size filled with a given character. Since there are many new functions it is necessary to indicate the desired type.

gasp: String := new(32, char "x")

\[\]

“xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx”

_{Type: String}

The length of a string is given by #.

#gasp

\[\]

32

_{Type: PositiveInteger}

Indexing operations allow characters to be extracted or replaced in strings. For any string s, indices lie in the range 1.. #s.

hello.2

\[\]

e

_{Type: Character}

Indexing is really just the application of a string to a subscript, so any application syntax works.

hello 2

\[\]

e

_{Type: Character}

hello(2)

\[\]

e

_{Type: Character}

If it is important not to modify a given string, it should be copied before any updating operations are used.

hullo := copy hello

\[\]

“Hello,I’mAXIOM!”

_{Type: String}

hullo.2 := char "u"; [hello, hullo]

\[\]

[“Hello,I’mAXIOM!”,”Hullo,I’mAXIOM!”]

_{Type: List String}

Operations are provided to split and join strings. The concatconcatString operation allows several strings to be joined together.

saidsaw := concat ["alpha","---","omega"]

\[\]

“alpha—omega”

_{Type: String}

There is a version of concatconcatString that works with two strings.

concat("hello ","goodbye")

\[\]

“hellogoodbye”

_{Type: String}

Juxtaposition can also be used to concatenate strings.

"This " "is " "several " "strings " "concatenated."

\[\]

“Thisisseveralstringsconcatenated.”

_{Type: String}

Substrings are obtained by giving an index range.

hello(1..5)

\[\]

“Hello”

_{Type: String}

hello(8..)

\[\]

“I’mAXIOM!”

_{Type: String}

A string can be split into several substrings by giving a separation character or character class.

split(hello, char " ")

\[\]

[“Hello,”,”I’m”,”AXIOM!”]

_{Type: List String}

other := complement alphanumeric();

_{Type: CharacterClass}

split(saidsaw, other)

\[\]

[“alpha”,”omega”]

_{Type: List String}

Unwanted characters can be trimmed from the beginning or end of a string using the operations trimtrimString, leftTrimleftTrimString and rightTrimrightTrimString.

trim(" # # ++ relax ++ # #", char " #")

\[\]

“++relax++”

_{Type: String}

Each of these functions takes a string and a second argument to specify the characters to be discarded.

trim(" # # ++ relax ++ # #", other)

\[\]

“relax”

_{Type: String}

The second argument can be given either as a single character or as a character class.

leftTrim (" # # ++ relax ++ # #", other)

\[\]

“relax++ # #”

_{Type: String}

rightTrim(" # # ++ relax ++ # #", other)

\[\]

” # #++relax”

_{Type: String}

Strings can be changed to upper case or lower case using the operations upperCaseupperCaseString, upperCase!upperCase!String, lowerCaselowerCaseString and lowerCase!lowerCase!String.

upperCase hello

\[\]

“HELLO,I’MAXIOM!”

_{Type: String}

The versions with the exclamation mark change the original string, while the others produce a copy.

lowerCase hello

\[\]

“hello,i’maxiom!”

_{Type: String}

Some basic string matching is provided. The function prefix?prefix?String tests whether one string is an initial prefix of another.

prefix?("He", "Hello")

\[\]

true

_{Type: Boolean}

prefix?("Her", "Hello")

\[\]

false

_{Type: Boolean}

A similar function, suffix?suffix?String, tests for suffixes.

suffix?("", "Hello")

\[\]

true

_{Type: Boolean}

suffix?("LO", "Hello")

\[\]

false

_{Type: Boolean}

The function substring?substring?String tests for a substring given a starting position.

substring?("ll", "Hello", 3)

\[\]

true

_{Type: Boolean}

substring?("ll", "Hello", 4)

\[\]

false

_{Type: Boolean}

A number of positionpositionString functions locate things in strings. If the first argument to position is a string, then position(s,t,i) finds the location of s as a substring of t starting the search at position i.

n := position("nd", "underground", 1)

\[\]

2

_{Type: PositiveInteger}

n := position("nd", "underground", n+1)

\[\]

10

_{Type: PositiveInteger}

If s is not found, then 0 is returned (minIndex(s)-1 in IndexedString).

n := position("nd", "underground", n+1)

\[\]

0

_{Type: NonNegativeInteger}

To search for a specific character or a member of a character class, a different first argument is used.

position(char "d", "underground", 1)

\[\]

3

_{Type: PositiveInteger}

position(hexDigit(), "underground", 1)

\[\]

3

_{Type: PositiveInteger}