Lines

The value Char represents a single character: it is just a 32-bit primitive type with a special literal representation and corresponding arithmetic behaviors, which can be converted to a numeric value representing https://en.wikipedia.org/wiki/Code_point [Unicode character code]. (Julia packages can define other subtypes of AbstractChar', for example, to optimize operations for others https://en.wikipedia.org/wiki/Character_encoding [text encodings].) This is how `Char values are entered and displayed (note that character literals are separated by single quotes, not double quotes):

The value of Char can be easily converted to its integer value, i.e. the character code.

In 32-bit architectures, the function typeof(c) will have the type Int32. An integer value can be easily converted back to the Char type.

Not all integer values are valid Unicode character codes, but to improve performance, the Char type conversion does not check the validity of each character value. To verify that each converted value is a valid character code, use the function isvalid.

At the time of writing, the valid Unicode character codes are U+0000--U+D7FF and U+E000--`U+10FFFF'. Not all of them have clear meanings yet, and they are not necessarily interpreted by applications, but all of these values are considered valid Unicode characters.

You can enter any Unicode character in single quotes using the character \u followed by up to four hexadecimal digits, or the character \U followed by up to eight hexadecimal digits (the longest allowed value requires only six digits).

Julia uses your system’s locale and language settings to determine which characters can be output as-is and which should be output using the common, escaped input forms \u or `\U'. In addition to these forms of Unicode escaping, you can also use all https://en.wikipedia.org/wiki/C_syntax#Backslash_escapes [traditional escaped C input forms].

You can perform comparisons and a limited number of arithmetic operations with Char values.

String literals are separated by double quotes or triple double quotes (not single quotes).

Long lines in strings can be split by prefixing a new line with a backslash (\).

If you want to extract a character from a string, you need to index it.

Many Julia objects, including strings, can be indexed using integers. The index of the first element (the first character of the string) is returned by the function firstindex(str), and the index of the last element(character) is a function lastindex(str). The keywords begin and end' can be used inside an indexing operation as an abbreviation for the first and last indexes, respectively, in a given dimension. String indexing, like most indexing in Julia, starts with 1. The `firstindex' function always returns `1 for any AbstractString object. However, as we will see below, the lastindex(str) function is usually not the same as the length(str) function for a string, since some Unicode characters can take up several code units.

With a keyword end you can perform arithmetic and other operations as with a regular value.

Using an index less than the keyword begin (1) or more than the keyword end results in an error.

You can also extract a substring using range indexing.

Note that the expressions str[k] and str[k:k] do not give the same result.

The first is a single-character value of type Char, and the second is a string value that contains only one character. These are completely different things in Julia.

When indexing a range, a copy of the selected part of the source string is created. Alternatively, you can create a representation for a string using the type SubString. Simply put, when using a macro @views in the code block, all line fragments are converted to substrings. For example:

Some standard functions such as chop, chomp or strip, returns the type SubString.

Julia fully supports Unicode characters and strings. How discussed above, in character literals, Unicode character codes can be represented using the Unicode escape sequences \u and \U, as well as all standard escape sequences in C. They can also be used to write string literals.

The display of these Unicode characters as escape characters or special characters depends on the terminal’s language standard settings and its Unicode support. String literals are encoded using UTF-8 encoding. UTF-8 is an encoding with a variable number of bytes, meaning not all characters are encoded into the same number of bytes (code units). In UTF-8, ASCII characters, i.e. those with character codes less than 0x80 (128) are encoded, as in ASCII, using a single byte, while character codes 0x80 and higher are encoded using several bytes — up to four per character.

Julia string indexes refer to code units (or bytes for UTF-8), standard fixed-width blocks that are used to encode arbitrary characters (character codes). This means that not every string index (String) is necessarily a valid index for a character. If you index a string using such an invalid byte index, an error will be returned.

In this case, the character ∀ is a three-byte character, so indexes 2 and 3 are invalid, and the index of the next character is 4. This next valid index can be calculated using the function nextind(s,1), followed by using the function nextind(s,4) and so on.

Since 'end` is always the last valid index in the collection, end-1 indicates an invalid byte index if the penultimate character is multibyte.

The first case works because the last character y and the space are single-byte characters, whereas end-2 indexes the middle of the multibyte representation ∃'. The correct way here is to use the function `prevent(s, lastindex(s), 2) or, if you use this value for indexing in s, you can write s[prevent(s, end, 2)], and end expands to the function lastindex(s).

Substring extraction using indexing also assumes that there are valid byte indexes, otherwise an error will be returned.

Due to variable-length encodings, the number of characters in a string (set using the method length(s)) does not always match the last index. If you iterate through the indexes from the first to the last (lastindex(s)) and index s, the sequence of characters returned in the absence of errors will be the sequence of characters that make up the string s. Thus, length(s) <= lastindex(s), since each character in the string must have its own index. The following is an inefficient and overloaded way to iterate the characters of the string s.

There are actually spaces in the empty lines. Fortunately, the above inconvenient option is not necessary for iterating characters in a string, since you can simply use the string as an iterable object that does not require exception handling.

If you need to get valid indexes for a row, you can use the functions nextind and prevent to increase or decrease the value to the next or previous valid index, as mentioned above. You can also use the function eachindex for iterating over valid character indexes.

To access the raw code units (bytes for UTF-8) encoding, you can use the function codeunit(s,i), where the index i is executed sequentially from 1 to ncodeunits(s). Function codeunits(s) returns shell AbstractVector{UInt8}, which allows you to access these raw code units (bytes) as an array.

Strings in Julia may contain invalid UTF-8 code sequences. This convention allows you to treat any sequence of bytes as a string (String). In such situations, the following rule applies: when analyzing a sequence of code units from left to right, characters are formed by the longest sequence of 8-bit code units, which coincides with the beginning of one of the following bit patterns (each x can have the value 0 or 1).

In particular, this means that sequences of code units that are too long and sequences of too high an order and their prefixes are considered as one invalid character, rather than as several invalid characters. This rule is best explained by an example.

We can see that the first two code units in the string s form a space character encoding that is too long. It is invalid, but it is accepted as a single character in the string. The following two code units form the valid beginning of a three-byte UTF-8 sequence. However, the fifth unit of the code, \xe2, is not a valid continuation of it. Therefore, code units 3 and 4 are also interpreted as incorrectly formed characters in this string. Similarly, the unit of code 5 forms an incorrect character, since | is not its valid continuation. As a result, the string s2 contains one character code of too high an order.

Julia uses UTF-8 encoding by default, and support for new encodings can be added using packages. For example, the package https://github.com/JuliaStrings/LegacyStrings.jl [LegacyStrings.jl] implements the UTF16String and UTF32String types. Additional discussion of other encodings and how to implement their support is still beyond the scope of this document. For more information about UTF-8 encoding, see the section below on byte array literals. Function transcode is designed to convert data between different UTF-xx encodings, mainly for working with external data and libraries.

One of the most common and useful string operations is concatenation.

It is important to keep in mind potentially dangerous situations, such as concatenation of invalid UTF-8 strings. The resulting string may contain characters other than the characters in the input strings, and the number of characters in it may be less than the sum of the number of characters in the concatenated strings, for example:

This can only happen for invalid UTF-8 strings. For valid UTF-8 strings, concatenation preserves all characters in strings and the additivity of string lengths.

There is also a method available for concatenating strings in Julia *.

For users of languages that use the + method for string concatenation, it may seem that the choice of the * method is unexpected, but the use of * has a precedent in mathematics, especially in abstract algebra.

In mathematics, + usually denotes a commutative operation, where the order of the operands does not matter. An example is matrix addition, where A + B == B + A for any matrices A and B having the same shape. On the contrary, * It usually denotes a non-commutative operation, where the order of the operands has a value. An example is matrix multiplication, where in the general case A * B != B * A. As in the case of matrix multiplication, string concatenation is non-commutative: hello * who != whom * greet. Thus, the * method is a more natural choice for the infix operator of string concatenation, which corresponds to the generally accepted mathematical usage.

More precisely, the set of all strings of finite length S, together with the string concatenation operator *, forms https://en.wikipedia.org/wiki/Free_monoid [free monoid] (S, *). The neutral element of this set is the empty string "". When a free monoid is noncommutative, the operation is usually represented as \cdot, * or a similar character, rather than a `+', which, as already mentioned, usually implies commutativity.

Building strings using concatenation can become a rather burdensome process. To reduce the need for detailed function calls string or repetitive multiplication operations, Julia allows you to perform interpolation into string literals using the literal $, as in Perl.

This is a more readable and expedient feature, equivalent to the string concatenation described above, — the system rewrites this seemingly single string literal into the call string(greet, ",", who, ".\n").

The shortest complete expression after the $ is accepted as the expression whose value should be interpolated into the string. So you can interpolate any expression into a string using parentheses.

Both concatenation and string interpolation call the function string for converting objects to string form. However, the string function actually just returns the output of the function print, so new types should add methods to the function print or method show instead of the string function.

Most objects that do not have an AbstractString type are converted to strings that exactly match the type in which they are entered as literal expressions.

Function string is an identifier for the values AbstractString and AbstractChar, so they are interpolated into strings as themselves, without quotes and escaping.

To include the literal $ in a string literal, escape it with a backslash.

When strings are created using triple quotes ("""..."""), They have a special behavior that can be useful for creating long blocks of text.

First, lines enclosed in triple quotes are also aligned at the line level with the smallest indentation. This is useful for defining indented lines in code. For example:

In this case, the last (empty) line before the closing """ sets the indentation level.

The alignment level is defined as the longest common initial sequence of spaces or tab characters in all lines, excluding the line following the opening triple quotes (""“) and lines containing only spaces or tab characters (the line containing the closing triple quotes (”"“) is always included). Then, for all lines, excluding the text following the opening triple quotes (”""), the general initial sequence is deleted (including lines containing only spaces and tabs if they begin with this sequence), for example:

Further, if the opening triple quotes (""") are followed by a newline, it is deleted from the resulting string.

equivalent to

but

it will contain a literal newline at the beginning.

Newline exclusion is performed after alignment. For example:

If a new line is deleted using a backslash, alignment will also be taken into account.

The final space remains unchanged.

String literals enclosed in triple quotes can contain the characters " without escaping.

Note that line breaks in literal lines enclosed in single or triple quotes result in the newline character (LF) \n in the line, even if your editor uses carriage return \r (CR) or a combination of CRLF to end the lines. To include CR in a string, use the explicit escape character \r. For example, you can enter the literal string "a CRLF line ending\r\n".

You can compare strings lexicographically using standard comparison operators.

You can search for the index of a specific character using the functions findfirst and findlast:

You can start searching for a character from a given offset using the functions findnext and findprev.

You can use the function occursin to check if a substring is found in the string.

The last example shows that the function occursin can also search for a character literal.

There are two more convenient string functions. — repeat and join.

Some other useful features are listed below.

There are situations when you need to build a string or use string semantics, but the standard string construction is not exactly what you need. Julia has non-standard string literals for such cases. A non-standard string literal looks like a regular string literal enclosed in double quotes, but it has an identifier prefix. Its behavior may differ from that of a regular string literal.

Examples of string literals are regular expressions, byte array literals and version number literals, which will be described below. Users and packages can also define new non-standard string literals. Additional documentation is provided in the section Metaprogramming.

Sometimes you are not looking for an exact string, but for a specific pattern. For example, let’s say you’re trying to get a single date from a large text file. You don’t know what this date is (that’s why you’re looking for it), but you know it will look something like this: `YYYY-MM-DD'. Regular expressions allow you to set these patterns and search for them.

Perl-compatible regular expressions (regex) versions 2 provided by the library are available in Julia. https://www.pcre.org /[PCRE] (a description of the PCRE2 syntax can be found https://www.pcre.org/current/doc/html/pcre2syntax.html [here]). Regular expressions are related to strings in two ways: the obvious connection is that regular expressions are used to find regular patterns in strings; the other connection is that regular expressions themselves are entered as strings that are parsed into a finite automaton that can be used to efficiently search for patterns in strings. In Julia, regular expressions are introduced using non-standard string literals prefixed with various identifiers starting with r'. The simplest regular expression literal without enabled features simply uses `+r"…​"+.

To check if a regular expression matches a string, use the function occursin.

As you can see, the function occursin simply returns true or false values, indicating whether the string matches the specified regular expression. However, it is necessary to know not only whether the string matches, but also how it matches. To record this match information, the function is used match.

If the regular expression does not match the specified string, the function match returns `nothing' is a special value that is not printed in the output in any way. Except that it is not output, it is a completely normal value, and you can check it programmatically.

If the regular expression matches, the value returned by the function is match, is an object RegexMatch. These objects register the match of the expression, including the substring that matches the template, and all found substrings, if any. In this example, only the part of the substring that matches is written, but you may need to write any non-empty text after the comment character. You can do the following.

When calling a function match you can specify the index from which the search should start. For example:

The following information can be extracted from the `RegexMatch' object.

In the case where the record does not match, instead of a substring, the record (m.captures) contains nothing (nothing) in this position, and the offset (m.offsets) is zero (recall that indexes in Julia are based on 1, so a zero offset in a row is unacceptable). Here are a couple of fictional examples.

It is convenient when records are returned as an array, so you can use the destructuring syntax to bind them to local variables. The 'RegexMatch` object implements iterator methods that are passed to the captures field, so you can destructure the matching object directly.

Records can also be accessed by indexing the RegexMatch object using the record group number or name.

The record can be referenced in the substitution string when using the function replace by using \n to refer to the nth record group and adding s as a prefix for the substitution string. Record group 0 refers to the entire matching object. Named record groups can be referenced in substitution using \g<groupname>. For example:

Numbered record groups can also be designated as \g<n> for separation, for example:

You can change the behavior of regular expressions by using a specific combination of the flags i, m, s and x after the closing double quotation mark. These flags have the same meaning as in Perl, as explained in this excerpt from https://perldoc.perl.org/perlre#Modifiers [Perl regular Expression manual pages].

For example, in the following regular expression, all three flags are enabled.

The literal r"..." is constructed without interpolation and escaping (with the exception of the quotation marks ", which must still be escaped). Here is an example showing the difference from standard string literals.

Regular expression strings with triple quotes in the form r"""...""" are also supported (and may be useful for regular expressions containing quotation marks or newlines).

To programmatically create a valid regular expression string, you can use the Regex() constructor.. In this case, you can use the contents of string variables and other string operations when constructing a regular expression string. Any of the above regular expression codes can be used in a single string argument for the Regex() constructor. Here are some examples:

Note the use of the escape sequence \Q...\E. All characters between \Q and \E are interpreted as literal characters. This is useful for matching characters that would otherwise be regular expression metacharacters. However, you should be careful when using this function together with string interpolation, since the interpolated string may itself contain the sequence \E, which will unexpectedly stop matching literals. The data entered by the user must be sanitized before being included in the regular expression.

Another useful non-standard string literal is the byte array string literal: b"...". This form allows you to use string notation to express literal arrays of read-only bytes, i.e. arrays of values. UInt8. These objects are of type CodeUnits{UInt8, String}. The following rules apply to literals of byte arrays.

These rules partially duplicate each other, since the behavior of \x and octal escape sequences less than 0x80(128) falls under both of the first two rules, but here these rules are consistent. The combination of these rules makes it easy to use ASCII characters, arbitrary byte values, and UTF-8 sequences to create byte arrays. Here is an example of using all three rules.

The ASCII DATA string corresponds to bytes 68, 65, 84, 65. \ xff outputs one byte 255. The Unicode escape sequence \u2200 is encoded in UTF-8 as bytes 226, 136, 128. Note that the resulting byte array does not match a valid UTF-8 string.

As already mentioned, the type is CodeUnits{UInt8, String}`behaves like a read-only array `UInt8 and if you need a standard vector, you can convert it using Vector{UInt8}.

Also note the significant difference between \xff and \uff: the first sequence encodes _ bytes of 255_, while the second sequence represents the code of the character 255, which in UTF-8 is encoded as two bytes.

Character literals act the same way.

For character codes smaller than \u80, it turns out that the UTF-8 encoding of each character code is just one byte, created by the corresponding escape character \x, so this difference can be safely ignored. However, there is a significant difference between the escape characters \x80--\xff and \u80--\uff: the former encode single bytes that (unless followed by very specific continuation bytes) do not form valid UTF-8 data, whereas the latter represent Unicode character codes. with two-byte encodings.

If all this is completely unclear, try to read the document. The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets (The absolute minimum that every software developer should know about Unicode and character sets). This is a great introductory article about Unicode and UTF-8 that can help you figure this out.

Version numbers can be easily expressed using non-standard string literals of the form v"...". Version number literals create objects VersionNumber that follow the specifications https://semver.org /[semantic version control], and therefore consist of numeric values of the primary version number, the secondary version number, and the patch number, followed by alphanumeric pre-release and build designations. For example, 'v"0.2.1-rc1+win64"` is split into the primary version number 0, the secondary version number 2, the patch version number 1, the pre-release value rc1 and the build value win64'. When entering a version literal, everything except the main version number is optional, so, for example, `v"0.2" is equivalent to v"0.2.0" (with empty pre-release and build designations), v"2" is equivalent to v"2.0.0" and so on.

The VersionNumber objects are mainly used for simple and correct comparison of two (or more) versions. For example, the constant VERSION stores the Julia version number as a VersionNumber object, and therefore you can define some version-specific behavior using the following simple operators.

Please note that the above example uses a non-standard version number v'0.3-" with the ending character -: This notation is a Julia extension to the standard and is used to indicate a version number that is lower than any release number 0.3, including all its pre-releases. Thus, in the above example, the code will only work with stable versions of 0.2 and exclude versions such as v"0.3.0-rc1". To also allow unstable (i.e. pre-release versions) versions of 0.2, the lower bound check should be changed as follows: v"0.2-" <= VERSION.

Another non-standard extension of the version specification allows the use of the ending character + to express the upper limit of assembly versions. For example, VERSION > v"0.2-rc1+" can be used to refer to any version higher than 0.2-rc1 and any of its builds.: this will return the value false for version v"0.2-rc1+win64" and the value true for v"0.2-rc2".

It is recommended to use such special versions in comparisons (in particular, the ending character - should always be used at the upper bounds unless there is a good reason not to do so), but they should not be used as the actual version number of something, as they are unacceptable in the semantic version control scheme.

Besides being used for a constant VERSION, VersionNumber objects are widely used in the Pkg module to specify package versions and their dependencies.

Raw strings without interpolation or escaping can be expressed using non-standard string literals of the form raw"...". Raw string literals create ordinary String objects that contain nested content exactly as it was entered, without interpolation or escaping. This is well suited for strings containing code or markup in other languages that use $ or \ as special characters.

The exception is that quotation marks still have to be escaped. For example, raw"\"" is equivalent to "\"". To express all strings, backslashes must also be escaped, but only when they appear immediately before the quotation mark character.

Note that the first two backslashes are displayed in the output exactly, as they do not precede the quotation mark character. However, the next backslash character escapes the backslash following it, and the last backslash escapes the quotation mark, since these backslashes come before the quotation mark.

Sometimes it is useful to be able to store metadata related to areas of a string. AnnotatedString' wraps another string and allows you to annotate its areas with labeled values (+:label ⇒ value+). All universal string operations are applied to the base string. However, when possible, the style information is saved. This means that you can work with `AnnotatedString — take substrings, complement them, combine them with other strings — and metadata annotations will be attached.

This string type is the main one for StyledStrings stdlib, which uses annotations marked :face, for storing information about the style.

When concatenating AnnotatedString try to use annotatedstring instead of string, if you want to save string annotations.

Access to annotations AnnotatedString and their modification is carried out using the functions annotations and annotate!.