strings

Everything after the first appearance of a marker, or none when the marker is not there — the other half of beforeText.

print(afterText("coal: 250", ": "))

A progress bar as text, like "[####----]" — for a print or a label where the drawn paintProgress cannot go.

print(barText(50, 8))

The text a base64 token holds, or none when the token is not valid base64 — the other half of base64Encode.

print(base64Decode("aGk="))

The text as base64 — a safe single token for saving or sending text that may hold anything.

print(base64Encode("hi"))

Everything before the first appearance of a marker, or none when the marker is not there — 'name: value' reads with beforeText and afterText.

print(beforeText("coal: 250", ":"))

The text between two markers, or none when either is missing — one call for pulling a value out of a line with a known shape.

print(betweenText("lvl [42] done", "[", "]"))

The string with its first letter in upper case and the rest untouched.

print(capitalize("iron"))

The text with spaces either side until it sits in the middle of a width — for lining up a console readout. Text already wider comes back whole.

print(centerText("hi", 8))

The single character at a position as a one-letter string, or an empty string when the position is off the end.

print(charAt("hello", 0))

The one-character text for a character code — the other half of codeOf. Refuses a code outside what text can hold.

print(charOf(65))

A list of a string's characters, each as a one-letter string.

print("letters", count(chars("hello")))

The character code of the text's FIRST character — 'A' is 65. Refuses empty text, which has no first character.

print(codeOf("A"))

Which of two texts sorts first: -1 when a comes before b, 0 when they are the same, 1 when a comes after — alphabetical, case-sensitive.

print(compareText("apple", "banana"))

True when 'text' contains 'part'. Case matters - fold with lower() first to ignore it. This is how you react to a server line that is not an exact string.

on message(line, from) { if contains(lower(line), "well done") { stop } }

True when the text holds EVERY one of the given fragments — containsAny asks for one, this asks for all.

if containsAllOf("iron ore rock", split("iron,rock", ",")) { print("both") }

True when a string contains any one of a list of fragments. Case matters — fold with lower() first.

if containsAny(lower("well done"), split("nice,well done", ",")) { stop }

How many times a fragment appears in a string, without overlaps. An empty fragment counts as zero.

print("a's", countText("banana", "a"))

The text cut to a length with '...' marking the cut — for a readout column that must not grow. Text already short enough comes back whole.

print(ellipsis("a very long name", 9))

True when 'text' ends with 'suffix'. Case-sensitive.

if endsWith(line, "well done") { stop }

True when the text ends with ANY of the given endings — the other end of startsWithAny.

if endsWithAny("iron ore", split("ore,bar", ",")) { print("metal") }

The text guaranteed to end with a suffix — added when missing, left alone when already there.

print(ensureEnd("miner", ".bot"))

The text guaranteed to start with a prefix — added when missing, left alone when already there.

print(ensureStart("example.com", "https://"))

True when two strings are the same ignoring case, so "Yes" matches "yes".

if equalsIgnoreCase("Yes", "yes") { stop }

Where a fragment first sits in a string, counting from zero, or -1 when it is not there. The position to contains()'s yes or no.

if find("iron ore", "ore") >= 0 { print("found") }

Where a fragment appears at or after a position, counting from 0, or none when it does not — find(), resumed part way through.

print(findFrom("a,b,a", "a", 1))

Everywhere a fragment appears in a text, as positions counting from 0 — find(), all of them at once. Overlaps step one character at a time.

print(count(indexesOf("a,b,a", "a")))

The first character of every word, run together: "iron ore rock" reads "ior". Empty text answers empty.

print(initials("iron ore rock"))

True when a string is empty or only spaces — for guarding a line before reading it.

if isBlank(lastServerMessage()) { return 600 }

True when the text reads whole as one number — an optional minus and digits, commas allowed. Read the number itself with numberIn, which forgives the same commas this does.

if isNumberText("1,234") { print("numeric") }

Where a fragment LAST appears, counting from 0, or none when it never does — for the extension of a name, cut at lastFind, not find.

print(lastFind("a.b.c", "."))

The first few characters of a string. Asking for more than there are gives all of them.

print(left("iron ore", 4))

The text in lower case, so a match can ignore case.

if contains(lower(line), "walk across") { onLog = true }

A number with its ordinal ending: 1 becomes 1st, 2 becomes 2nd, 21 becomes 21st.

print("you are", ordinal(21))

The string with spaces added on the right until it is at least the given width.

uiLabel("n", padEnd("hi", 6))

The string with spaces added on the left until it is at least the given width, so a column of them lines up on the right. A longer string is unchanged.

uiLabel("n", padStart("7", 4))

The part as a percentage of the whole, written with the sign: 42 of 100 is "42%". A whole of zero or less reads as "0%" rather than faulting.

print(percentText(42, 100))

The count and the right word for it: plural(1, "log", "logs") is "1 log", plural(2, ...) is "2 logs".

print(plural(2, "log", "logs"))

The string with every occurrence of a fragment taken out — replace with nothing, spelled the way you would say it.

print(remove("Iron ore certificate", " certificate"))

The text with a suffix removed when it ends with one, unchanged when it does not — the other half of removeStart.

print(removeEnd("miner.bot", ".bot"))

The text with a prefix removed when it starts with one, unchanged when it does not — safe to apply without asking first.

print(removeStart("Mr Smith", "Mr "))

A string made of a piece repeated a number of times. Refuses a negative count or a result too long to be sensible.

print(repeatText("-", 8))

The text with every occurrence of 'find' replaced. Literal and case-sensitive, like the matches above. An empty 'find' returns the text unchanged - replacing nothing is nothing.

print(replace("Iron ore certificate", " certificate", ""))

The text with only the FIRST appearance of a fragment replaced — replace() does every one.

print(replaceFirst("a,a", "a", "b"))

The string with its characters in the opposite order.

print(reverseText("abc"))

The last few characters of a string.

print(right("iron ore", 3))

The number as Roman numerals: 1994 reads MCMXCIV. Refuses numbers the numerals cannot write, which is anything outside 1 to 3999.

print(romanOf(1994))

The number the way a player reads money: 950 stays 950, 1200 is "1.2k", 3400000 is "3.4m", 5600000000 is "5.6b". One decimal, no rounding up past it.

print(shortNumber(3400000))

The text with every run of spaces collapsed to one and both ends trimmed — what to do to a line before splitting it on spaces.

print(squeeze("  a   b  "))

True when 'text' begins with 'prefix'. Case-sensitive.

if startsWith(line, "You") { print("about you") }

True when the text starts with ANY of the given beginnings — startsWith over a whole list in one ask.

if startsWithAny("You swing", split("You,The", ",")) { print("hit") }

How many characters a string holds. Empty string is zero.

print("length", strLen("hello"))

The piece of a string between two positions. Both ends are clamped to the string, so an over-long range just gives what is there rather than faulting.

print(substring("iron ore", 0, 4))

The text cut into its lines — split on line breaks, both Windows and Unix endings understood.

print(count(textLines("a")))

The string with the first letter of every word in upper case, for a heading.

print(title("iron ore"))

The string with spaces removed from both ends.

print(trim("  banked  "))

The text with the spaces taken off its END only — trim() does both ends.

print(trimEnd(" hi  "))

The text with the spaces taken off its FRONT only — trim() does both ends.

print(trimStart("  hi "))

The text in upper case.

print(upper(name))

The text a URL-encoded fragment holds, or none when it is not valid encoding — the other half of urlEncode.

print(urlDecode("a+b%26c"))

The text escaped for use inside a URL — spaces, symbols and anything else that would break one, encoded.

print(urlEncode("a b&c"))

How many words a string holds — runs of non-space split by spaces.

print("words", wordCount("one two three"))

A list of the words in a string, split on spaces, with empty pieces dropped.

print("words", count(words("one  two three")))

The text broken into lines no wider than 'width', breaking at spaces where it can — the word wrap behind a hand-drawn paragraph. Walk it with for and paintText each line.

for line in wrapText("a few words to wrap", 8) { print(line) }