Literals/String
Show literal specification of characters and strings. If supported, show how verbatim strings (quotes where escape sequences are quoted literally) and here-strings work. Also, discuss which quotes expand variables.
![Task](http://static.miraheze.org/rosettacodewiki/thumb/b/ba/Rcode-button-task-crushed.png/64px-Rcode-button-task-crushed.png)
You are encouraged to solve this task according to the task description, using any language you may know.
Ada
Single character literals require single quotes
ch : character := 'a';
String literals use double quotes
msg : string := "hello world"; empty : string := ""; -- an empty string
The length of a string in Ada is equal to the number of characters in the string. Ada does not employ a terminating null character like C. A string can have zero length, but zero length strings are not often used. Ada's string type is a fixed length string. It cannot be extended after it is created. If you need to extend the length of a string you need to use either a bounded string, which has a pre-determined maximum length, similar to C strings, or an unbounded string which can expand or shrink to match the data it contains.
ALGOL 68
In ALGOL 68 a single character (CHAR), character arrays ([]CHAR) and strings (STRING) are contained in double quotes. ALGOL 68 also has FORMAT strings which are contained between dollar ($) symbols.
CHAR charx = "z";
Strings are contained in double quotes.
[]CHAR charxyz = "xyz"; STRING stringxyz = "xyz"; FORMAT twonewlines = $ll$, threenewpages=$ppp$, fourbackspaces=$bbbb$;
Note: When only uppercase characters sets are available (eg on computers with only 6 bits per "byte") the single quote can used to denote a reserved word. eg
.PR QUOTE .PR []'CHAR' CHARXYZ = "XYZ";
The STRING type is simply a FLEX array of CHAR.
MODE STRING = FLEX[1:0]CHAR;
ALGOL 68 also has raw strings called BYTES, this type is a fixed width packed array of CHAR.
BYTES bytesabc = bytes pack("abc");
A string quote character is inserted in a string when two quotes are entered, eg:
STRING stringquote = """I'll be back."" - The Terminator";
A string can span lines, but cannot contain newlines. String literals are concatenated when compiled:
STRING linexyz := "line X;" + "line Y;" + "line Z;";
ALGOL 68 uses FORMATs for doing more advanced manipulations. For example given:
FILE linef; STRING line; associate(linef, line);
Instead of using preprocessor macros ALGOL 68 can do FORMAT variable replacement within FORMATs at run time.
FORMAT my_symbol = $"SYMBOL"$; FORMAT foo = $"prefix_"f(my_symbol)"_suffix"$; putf(linef ,foo);
In standard ALGOL 68 a "book" is a file. A book is composed of pages and lines and therefore a FORMAT be used for inserting backspaces, space, newlines and newpages into books.
INT pages=100, lines=25, characters=80; FILE bookf; FLEX[pages]FLEX[lines]FLEX[characters]CHAR book; associate(bookf, book); # following putf inserts the string " Line 4 indented 5" on page 3 # putf(bookf, $3p"Page 3"4l5x"Line 4 indented 5"$)
Note: ALGOL 68G does not implement newpage and backspace.
C
In C, single characters are contained in single quotes.
char ch = 'z';
Strings are contained in double quotes.
char str[] = "z";
This means that 'z' and "z" are different. The former is a character while the latter is a string, an array of two characters: the letter 'z' and the string-terminator null '\0'.
C has no raw string feature (please define). C also has no built-in mechanism for expanding variables within strings.
A string can span lines. Newlines can be added via backslash escapes, and string literals are concatenated when compiled:
char lines[] = "line 1\n" "line 2\n" "line 3\n";
C can use library functions such as sprintf for doing formatted replacement within strings at run time, or preprocessor concatenation to build string literals at compile time:
#define FOO "prefix_"##MY_SYMBOL##"_suffix"
C#
C# uses single quotes for characters and double quotes for strings just as C. C# also supports verbatim strings. These begin with @" and end with ". Verbatim quotes may contain line breaks and so verbatim strings and here-strings overlap.
C++
Quoting is essentially the same in C and C++. However, C++ adds the ability to prefix an L to an opening quote indicate that a character is a wide character or that a string is an array of wide characters.
D
Character literals:
<lang d>char c = 'a';</lang>
Regular strings support C-style escape sequences.
<lang d>auto str = "hello"; // UTF-8 auto str2 = "hello"c; // UTF-8 auto str3 = "hello"w; // UTF-16 auto str4 = "hello"d; // UTF-32</lang>
Literal string (escape sequences are not interpreted):
<lang d>auto str = `"Hello," he said.`; auto str2 = r"\n is slash-n";</lang>
Specified delimiter string:
<lang d>// Any character is allowed after the first quote; // the string ends with that same character followed // by a quote. auto str = q"$"Hello?" he enquired.$";</lang>
<lang d>// If you include a newline, you get a heredoc string: auto otherStr = q"EOS This is part of the string.
So is this.
EOS";</lang>
Token string:
<lang d>// The contents of a token string must be valid code fragments. auto str = q{int i = 5;}; // The contents here isn't a legal token in D, so it's an error: auto illegal = q{@?};</lang>
Hex string:
<lang d>// assigns value 'hello' to str auto str = x"68 65 6c 6c 6f";</lang>
E
E has three sorts of quotes: strings, characters, and quasiliterals.
'T' # character "The quick brown fox" # string `The $kind brown fox` # "simple" quasiliteral term`the($adjectives*, fox)` # "term" quasiliteral
Strings and characters use syntax similar to Java; double and single quotes, respectively, and common backslash escapes.
Quasiliterals are a user-extensible mechanism for writing any type of object "literally" in source, with "holes" for interpolation or pattern-matching. The fourth example above represents a Term object (terms are a tree language like XML or JSON), with the items from the variable adjectives spliced in.
Quasiliterals can be used for strings as well. The third example above is the built-in simple interpolator, which also supports pattern matching. There is also a regular-expression quasi-pattern:
? if ("<abc,def>" =~ `<@a,@b>`) { [a, b] } else { null } # value: ["abc", "def"] ? if (" >abc, def< " =~ rx`\W*(@a\w+)\W+(@b\w+)\W*`) { [a, b] } else { null } # value: ["abc", "def"]
Haskell
Characters use single quotes, strings use double quotes. Both allow Unicode. Escape sequences start with a backslash. There are no verbatim strings, no here-strings, and no expansion of variables in strings.
Strings may be split across lines, even indented, using the 'gap' syntax:
"abcdef" == "abc\ \def"
"abc\ndef" == "abc\n\ \def"
The Haskell 98 Report section Character and String Literals has more information.
IDL
The single and double quotes are fairly interchangeable allowing one to use whichever isn't to be quoted (though single-quotes seem more well-behaved around integers in strings). Thus the following are both valid character-constant assignments:
a = " that's a string " b = ' a "string" is this '
In a pinch, a character constant doesn't absolutely have to be terminated, rendering the following valid:
a = " that's a string
Duplicating either of them quotes them. Thus the following contains three single quotes and no double-quotes:
a = ' that''s a string print,a ;==> that's a string
Things in quotes are not expanded. To get to the content of a variable, leave it unquoted:
b = 'hello' a = b+' world print,a ;==> hello world
Single-quoted strings of valid hex or octal digits will be expanded if followed by "x" or "o":
print,'777'x ;==> 1911 print,'777'o ;==> 511 print,'777' ;==> 777
so will be unterminated double-quoted strings if they represent valid octal numbers:
print,"777 ;==> 511 print,"877 ;==> 877
Note that this renders the following false (common trip-up for IDL newbies):
a = "0" ;==> Syntax error.
...because the number zero indicates that an octal number follows, but the second double-quote is not a valid octal digit.
Byte-arrays that are converted into strings are converted to the ascii-characters represented by the bytes. E.g.
crlf = string([13b,10b])
J
Like C, J treats strings as lists of characters. Character literals are enclosed in single quotes, and there is no interpolation. Therefore, the only "escape" character neccessary is the single-quote itself, and within a character literal is represented by a pair of adjacent single quotes (much like in C, where within a character literal, a slash is represented by a pair of adjacent slashes).
Examples:
'x' NB. Scalar character 'string' NB. List of characters, i.e. a string 'can''t get simpler' NB. Embedded single-quote
Like VB, J can include newlines and other special characters in literals with concatentation. Also like VB, J comes with certain constants predefined for some characters:
'Here is line 1',LF,'and line two' 'On a mac, you need',CR,'a carriage return' 'And on windows, ',CRLF,'you need both' TAB,TAB,TAB,'Everyone loves tabs!'
These constants are simply names assigned to selections from the ASCII alphabet. That is, the standard library executes lines like this:
CR =: 13 { a. LF =: 10 { a. CRLF =: CR,LF NB. Or just 10 13 { a. TAB =: 9 { a.
Since these constants are nothing special, it can be seen that any variable can be similarly included in a literal:
NAME =: 'John Q. Public' 'Hello, ',NAME,' you may have already won $1,000,000'
For multiline literals, you may define an explicit noun, which is terminated by a lone ) in the very first column:
template =: noun define Hello, NAME. My name is SHYSTER, and I'm here to tell you that you my have already won $AMOUNT!! To collect your winnings, please send $PAYMENT to ADDRESS. )
Simple substition is most easily effected by using loading a standard script:
load 'strings' name =: 'John Q. Public' shyster =: 'Ed McMahon' amount =: 1e6 payment =: 2 * amount address =: 'Publisher''s Clearing House' targets =: ;: 'NAME SHYSTER AMOUNT PAYMENT ADDRESS' sources =: ":&.> name;shyster;amount;payment;address message =: template rplc targets,.sources
While C-like interpolation can be effected with another:
load 'printf' 'This should look %d%% familiar \nto programmers of %s.' sprintf 99;'C' This should look 99% familiar to programmers of C.
Java
char a = 'a'; //prints as: a String b = "abc"; //prints as: abc char doubleQuote = '"'; //prints as: " char singleQuote = '\''; //prints as: ' String singleQuotes = "''"; //prints as: '' String doubleQuotes = "\"\""; //prints as: ""
Null characters ('\0') are printed as spaces in Java. They will not terminate a String as they would in C or C++. So, the String "this \0is \0a \0test" will print like this:
this is a test
LaTeX
Since LaTeX is a markup language rather than a programming language, quotes are displayed rather than interpreted. However, quotes do deserve special mention in LaTeX. Opening (left) quotes are denoted with backquotes and closing (right) quotes are denoted with quotes. Single quotes use a single symbol and double quotes use double symbols. For example, to typeset 'a' is for "apple" in LaTeX, one would type
`a' is for ``apple''
One common mistake is to use the same symbol for opening and closing quotes, which results in the one of the quotes being backward in the output. Another common mistake is to use a double quote symbol in the input file rather than two single quotes in order to produce a double quote in the output.
Logo
Logo does not have a string or character type that is separate from its symbol type ("word"). A literal word is specified by prefixing a double-quote character. Reserved and delimiting characters, ()[];~+-*/\=<>| and newline, may be used if preceded by a backslash. Alternatively, the string may be wrapped in vertical bars, in which case only backslash and vertical bar need be escaped.
print "Hello\,\ world print "|Hello, world|
Modula-3
Characters in Modula-3 use single quotes.
<lang modula3>VAR char: CHAR := 'a';</lang>
Strings in Modula-3 use double quotes.
<lang modula3>VAR str: TEXT := "foo";</lang>
TEXT
is the string type in Modula-3. Characters can be stored in an array and then converted to type TEXT using the function Text.FromChars
in the Text
module.
OCaml
Characters are contained in single quotes:
# 'a';; - : char = 'a'
Strings are contained in double quotes:
# "Hello world";; - : string = "Hello world"
Strings may be split across lines and concatenated using the following syntax: (the newline and any blanks at the beginning of the second line is ignored)
# "abc\ def";; - : string = "abcdef"
If the above syntax is not used then any newlines and whitespace are included in the string:
# "abc def";; - : string = "abc\n def"
Perl
Perl makes no distinction between single characters and strings. One can use single or double quotes, but they are different. Double-quotes allows you to interpolate variables and escape sequences, while single-quotes do not.
'c'; # character 'hello'; # these two strings are the same "hello"; 'Hi $name. How are you?'; # result: "Hi $name. How are you?" "Hi $name. How are you?"; # result: "Hi Bob. How are you?" '\n'; # 2-character string with a backslash and "n" "\n"; # newline character `ls`; # runs a command in the shell and returns the output as a string q/hello/; # same as 'hello', but allows custom delimiters qq/hello/; # same as "hello", but allows custom delimiters qw/one two three/; # same as ('one', 'two', 'three'); constructs a list of the words <<END; # Here-Document Hi, whatever goes here gets put into the string, including newlines, until the label we put above END
Plain TeX
The same as LaTeX case, even though one should say the opposite. The `` and '' in TeX (plainTeX, LaTeX and many more) are just examples of ligatures.
Pop11
In Pop11 charaters literals are written in inverted quotes (backticks)
`a` ;;; charater a
String are written in quotes
'a' ;;; string consisting of single character
Backslash is used to insert special charaters into strings:
'\'\n' ;;; string consisting of quote and newline
Python
Python makes no distinction between single characters and strings. One can use single or double quotes.
'c' == "c" # character 'text' == "text" ' " ' " ' " '\x20' == ' ' u'unicode string' u'\u05d0' # unicode literal
As shown in the last examples Unicode strings are single or double quoted with a "u" or "U" prepended thereto.
Verbatim (a.k.a. "raw") strings are contained within either single or double quotes, but have an "r" or "R" prepended to indicate that backslash characters should NOT be treated as "escape sequences." This is useful when defining regular expressions as it avoids the need to use sequences like \\\\ (a sequence of four backslashes) in order to get one literal backslash into a regular expression string.
r'\x20' == '\\x20'
The Unicode and raw string modifiers can be combined to prefix a raw Unicode string. This must be done as "ur" or "UR" (not with the letters reversed as it: "ru").
Here-strings are denoted with triple quotes.
''' single triple quote ''' """ double triple quote """
The "u" and "r" prefixes can also be used with triple quoted strings.
Triple quoted strings can contain any mixture of double and single quotes as well as embedded newlines, etc. They are terminated by unescaped triple quotes of the same type that initiated the expression. They are generally used for "doc strings" and other multi-line string expressions --- and are useful for "commenting out" blocks of code.
PowerShell
PowerShell makes no distinction between characters and strings. Single quoted strings do not interpolate variable contents but double quoted strings do. Also, escape sequences are quoted literally as separate characters within single quotes.
PowerShell here-strings begin with @' (or @") followed immediately by a line break and end with a line break followed by '@ (or "@). Escape sequences and variables are interpolated in @" quotes but not in @' quotes.
Scheme
Characters are specified using the "#\" syntax:
#\a #\A #\? #\space #\newline
Strings are contained in double quotes:
"Hello world"
Literal symbols, lists, pairs, etc. can be quoted using the quote syntax:
'apple '(1 2 3) ; same as (list 1 2 3) '() ; empty list '(a . b) ; same as (cons 'a 'b)
Seed7
In Seed7, single characters are contained in single quotes.
var char: ch is 'z';
Strings are contained in double quotes.
var string: stri is "hello";
This means that 'z' and "z" are different. The former is a character while the latter is a string. Seed7 strings are not null terminated (they do not end with \0). They can contain any sequence of UNICODE (UCS-32) characters (including a \0). In the source code the UNICODE characters are written with the UTF-8 coding. Empty strings are also allowed. The backslash is used to allow double quotes and control characters in strings. There is also a possibility to break a string into several lines.
var string: example is "this is a string\ \ which continues in the next line\n\ \and contains a line break";
There is no built-in mechanism for expanding variables within strings.
V
A simple quoted string is of the form 'string' e.g
'hello world' puts
Visual Basic .NET
Visual Basic only supports single-line strings. The only escape sequence supported is the double double-quote (""), which is translated into a single double-quote.
Dim s = "Tom said, ""The fox ran away.""" Result: Tom said, "The fox ran away."
XSLT
XSLT is based on XML, and so can use either " or ' to delimit strings. Since XML attribute values are defined using double-quotes, one must use single-quotes for string literals within attributes.
<xsl:if test="starts-with(@name, 'Mr.')">Mister</xsl:if>
Double and single quote characters may also be escaped with XML entities: " and ' respectively.