Literals/String: Difference between revisions

 

=={{header|Ada}}==

 

Single character literals require single quotes

String literals use double quotes

 

=={{header|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.

Strings are contained in double quotes.

STRING stringxyz = "xyz";

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

The STRING type is simply a FLEX array of CHAR.

ALGOL 68 also has raw strings called BYTES, this type is a fixed width packed array of CHAR.

A string quote character is inserted in a string when two quotes are entered, eg:

A string can span lines, but cannot contain newlines. String literals are concatenated when compiled:

"line Y;" +

ALGOL 68 uses FORMATs for doing more advanced manipulations.

For example given:

Instead of using preprocessor macros ALGOL 68 can do FORMAT variable replacement within FORMATs at run time.

FORMAT foo = $"prefix_"f(my_symbol)"_suffix"$;

In <b>standard</b> 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.

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 #

Note: ALGOL 68G does not implement newpage and backspace.

=={{header|AutoHotkey}}==

unicode

"text" ; string

hereString = ; with interpolation of %variables%

(Comments %

literal %A_Now% ; no interpolation here

=={{header|AWK}}==

 

=={{header|BASIC}}==

 

 

Strings can optionally be declared as being a certain length, much like C strings.

 

 

c = "char" 'everything after the first character is silently discarded

s = "string"

 

"string data c"

 

 

 

10 REM Print some quotes

20 PRINT CHR$(34)

50 REM Output the word hello enclosed in doublequotes

60 PRINT """Hello"""

 

=={{header|Befunge}}==

 

=={{header|C}}==

In C, single characters are contained in single quotes.

 

 

Strings are contained in double quotes.

 

 

 

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:

"line 2\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:

 

=={{header|C sharp|C#}}==

'''C#''' supports verbatim strings. These begin with @" and end with ". Verbatim quotes may contain line breaks and so verbatim strings and here-strings overlap.

 

string multiline = @"Line 1.

Line 2.

 

=={{header|C++}}==

 

 

=={{header|Clojure}}==

Character literals are prefixed by a backslash:

\uXXXX ; where XXXX is some hex Unicode code point

There are also identifiers for special characters:

\newline

\tab

\formfeed

\return

Clojure strings ''are'' Java Strings, and literals are written in the same manner:

 

=={{header|Common Lisp}}==

Character literals are referenced using a hash-backslash notation. Strings are arrays or sequences of characters and can be declared using double-quotes or constructed using other sequence commands.

(str "http://www.rosettacode.com/"))

 

=={{header|D}}==

Character literals:

 

 

Regular strings support C-style escape sequences.

 

auto str2 = "hello"c; // UTF-8

auto str3 = "hello"w; // UTF-16

 

Literal string (escape sequences are not interpreted):

 

 

Specified delimiter string:

 

// the string ends with that same character followed

// by a quote.

 

auto otherStr = q"EOS

This is part of the string.

So is this.

 

Token string:

 

auto str = q{int i = 5;};

// The contents here isn't a legal token in D, so it's an error:

 

Hex string:

 

 

=={{header|E}}==

E has three sorts of quotes: ''strings'', ''characters'', and ''quasiliterals''.

 

"The quick brown fox" # string

`The $kind brown fox` # "simple" quasiliteral

 

Strings and characters use syntax similar to Java; double and single quotes, respectively, and common backslash escapes.

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:

 

# value: ["abc", "def"]

 

? if (" >abc, def< " =~ rx`\W*(@a\w+)\W+(@b\w+)\W*`) { [a, b] } else { null }

 

=={{header|Forth}}==

In the interpreter:

In the compiler:

[char] c emit

Strings may contain any printable character except a double quote, and may not span multiple lines. Strings are done via the word S" which parses ahead for a terminal quote. The space directly after S" is thus not included in the string.

 

 

GNU Forth has a prefix syntax for character literals, and another string literal word S\" which allows escaped characters, similar to [[C]].

 

=={{header|Go}}==

 

 

 

This means that 'z' and "z" are different. The former is a character while the latter is a string.

 

 

 

 

=={{header|Groovy}}==

 

In [[Groovy]], unlike in [[Java]], a String literal is delimited with ''single quotes'' (apostrophes(')).

 

There is a ''double quote'' (quotation mark(")) delimited syntax in Groovy, but it represents an expression construct called a ''GString'' (I know, I know). Inside of a GString, sub-expression substitution of the form ${''subexpression''} may take place. Thus the following results:

 

println gString

 

//Outputs:

 

 

assert gString2 == '1 + 1 = 2'

 

def gString3 = "1 + 1 = \${1 + 1}"

 

Groovy also supports multi-line String literals and multi-line GString expressions.

 

A man

A plan

//A canal:

//Panama!

 

[[UNIX Shell]] programmers should recognize these forms of syntax as similar in function to the strong and weak forms of ''Here Document'' syntax.

However, [[Groovy]] has a special GString syntax that uses slash (/) as a GString delimiter rather that quote ("). In this special syntax, most backslash usages that would require a double backslash in a regular String or GString require only a single backslash (\). This does not create a "regular expression object" (there is not such a thing in [[Groovy]]); however, it does evaluate to form a "regular expression ready" String, as demonstrated in the following:

 

 

 

[[Javascript]] users (and others) will recognize the roots of this "regex-ready" syntax as a feature in their own language.

Since apostrophe is used to delimit String literals, that delimiter syntax is not available, as it is in [[Java]], to denote single character literals (type char or Character). However, single character string literals can be converted to character literals by casting. Shown in the examples below are casting using the ''as'' operator, Java-style parenthetical casting, and forced coercion in the intialization of a variable of type char or Character.

 

assert ('a' as char) instanceof Character

assert ((char)'a') instanceof Character

assert x instanceof Character

Character y = 'b'

 

As in [[Java]], backslash is also used to mask a string delimiter. Thus the following two assignments represent strings containing a single quote and a single apostrophe respectively

 

 

Of course, if you are not using GString subexpression evaluation, you can just use apostrophe delimiters to contain a quote, or quote delimiters to contain an apostrophe.

 

def apostrophe2 = "'"

assert quote == quote2

 

=={{header|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:

 

\def"

 

"abc\ndef" == "abc\n\

 

The [http://www.haskell.org/onlinereport/lexemes.html#sect2.6 Haskell 98 Report section Character and String Literals] has more information.

 

=={{header|HicEst}}==

HicEst makes no distinction between single characters and strings. One can use single quotes, or double quotes, or most non-standard characters.

CHARACTER str1='single quotes', str2="double quotes", str3*100

 

A null character CHAR(0) is printed as " ", displayed as "." in dialogs, but ends the string in Windows controls such as StatusBar or ClipBoard

Named literal constants in HicEst:

$LF == CHAR(10)

$CR == CHAR(13)

 

=={{header|Icon}} and {{header|Unicon}}==

Below is a little program to demonstrate string literals.

 

# strings are variable length are not NUL terminated

every x := c1|s1|s2 do # show them

write(" size=",*x,", type=", type(x),", value=", image(x))

 

<pre> size=2, type=cset, value='ab'

size=4, type=string, value="aaab"

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:

 

 

In a pinch, a character constant doesn't absolutely have to be terminated, rendering the following valid:

 

 

Duplicating either of them quotes them. Thus the following contains three single quotes and no double-quotes:

 

print,a

 

Things in quotes are not expanded. To get to the content of a variable, leave it unquoted:

 

a = b+' world

print,a

 

Single-quoted strings of valid hex or octal digits will be expanded if followed by "x" or "o":

 

;==> 1911

print,'777'o

;==> 511

print,'777'

 

so will be unterminated double-quoted strings if they represent valid octal numbers:

 

;==> 511

print,"877

 

Note that this renders the following false (common trip-up for IDL newbies):

 

 

...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.

 

 

=={{header|Inform 7}}==

String literals are enclosed in double quotes. These may include raw line breaks, or expressions to be substituted enclosed in square brackets.

 

 

 

will print as

<pre>"That's nice," said the captain.</pre>

 

There are no character literals: phrases that manipulate characters pass them as single-character strings.

Examples:

 

'string' NB. List of characters, i.e. a string

 

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:

 

 

'On a mac, you need',CR,'a carriage return'

'And on windows, ',CRLF,'you need both'

 

 

These constants are simply names assigned to selections from the ASCII alphabet. That is, the standard library executes lines like this:

 

LF =: 10 { a.

CRLF =: CR,LF NB. Or just 10 13 { a.

 

Since these constants are nothing special, it can be seen that any variable can be similarly included in a literal:

 

 

For multiline literals, you may define an explicit noun, which is terminated by a lone <code>)</code>

 

Hello, NAME.

 

To collect your winnings, please send $PAYMENT

to ADDRESS.

 

Simple substitution is most easily effected by using loading a standard script:

 

 

name =: 'John Q. Public'

sources =: ":&.> name;shyster;amount;payment;address

 

While C-like interpolation can be effected with another:

 

'This should look %d%% familiar \nto programmers of %s.' sprintf 99;'C'

This should look 99% familiar

 

=={{header|Java}}==

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:

 

=={{header|JavaScript}}==

A JavaScript string is a sequence of zero or more characters enclosed in either 'single quotes' or "double quotes". Neither form prevents escape sequences: <code>"\n"</code> and <code>'\n'</code> are both strings of length 1. There is no variable interpolation.

 

=={{header|LaTeX}}==

 

 

 

 

=={{header|Lisaac}}==

Characters:

c2 := '\n'; // newline

c3 := '\''; // quote

c5 := '\10\'; // decimal

c6 := '\0Ah\'; // hexadecimal

Strings:

s2 := "\""; // double quote

s3 := "abc\

 

=={{header|Logo}}==

=={{header|Lua}}==

doublequotestring = "can contain 'single quotes'"

longstring = [[can contain

newlines]]

 

=={{header|M4}}==

 

=={{header|Metafont}}==

In Metafont there's no difference between a single character string and a single character. Moreover, the double quotes (which delimites a string) cannot be inserted directly into a string; for this reason, the basic Metafont macro set defines

 

 

i.e. a string which is the single character having ASCII code 34 ("). Macro or variables expansion inside a string block is inhibited.

 

 

=={{header|Modula-3}}==

Characters in Modula-3 use single quotes.

Strings in Modula-3 use double quotes.

 

Strings (of type <code>TEXT</code>) can be converted into an array of characters using the function <code>Text.SetChars</code>.

VAR chrarray: ARRAY [1..3] OF CHAR;

 

Text.SetChars(chrarray, str);

=={{header|MUMPS}}==

<pre>USER>SET S1="ABC"

</pre>

 

 

 

=={{header|Objeck}}==

 

=={{header|OCaml}}==

 

Characters are contained in single quotes:

 

Strings are contained in double quotes:

 

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)

def";;

 

If the above syntax is not used then any newlines and whitespace are included in the string:

def";;

 

=={{header|Oz}}==

Digit0 = &0 %% the character '0'

NewLine = &\n %% a character with special representation

MyName = "Peter"

MyAge = 8

 

=={{header|PARI/GP}}==

\n newline

 

 

Version 2.4.3 added the functions <code>printf</code> and <code>Strprintf</code> which allow interpolation (typically with %Ps).

 

=={{header|Perl}}==

 

 

'hello'; # these two strings are the same

"hello";

<<'END'; # Here-Document like single-quoted

Same as above, but no interpolation of $variables.

 

=={{header|PHP}}==

 

 

'hello'; # these two strings are the same

"hello";

<<'END' # Here-Document like single-quoted

Same as above, but no interpolation of $variables.

 

=={{header|PicoLisp}}==

 

Syntactically, transient symbols (called "strings" in the following) are surrounded by double quotes.

Double quotes in strings are escaped with a backslash.

 

ASCII control characters can be written using the hat ('^') character:

There is no special character type or representation. Individual characters are handled as single-character strings:

-> ("a" "b" "c")

 

: (pack (reverse @))

A limited handling of here-strings is available with the '[http://software-lab.de/doc/refH.html#here here]' function.

 

=={{header|Pike}}==

'c'; // Character code (ASCII) (result: 99)

"c"; // String (result: "c")

string using the

preprocessor" // single literal string with newlines in it

 

=={{header|PL/I}}==

'H' /* a single character as a literal. */

'this is a string'

/* stored are <<John's cat>> */

'101100'b /* a bit string, stored as one bit per digit. */

 

=={{header|plainTeX}}==

 

 

 

=={{header|Pop11}}==

String are written in quotes

 

 

Backslash is used to insert special charaters into strings:

 

=={{header|PureBasic}}==

PureBasic supports char in ASCII and UNICODE as well as both dynamic and fixed length strings.

Define.c AChar='A'

; defines as *.a it will be ASCII and *.u is always UNICODE

; '"' can be included via CHR() or its predefined constant

Define AStringQuotes$=Chr(34)+"Buu"+Chr(34)+" said the ghost!"

To dynamically detect the current sizes of a character, e.g. ASCI or UNICODE mode, StringByteLength() can be used.

Case 1

Print("ASCII-mode; Soo, Hello world!")

Case 2

Print("UNICODE-mode; Soo, 您好世界!")

 

=={{header|Python}}==

 

 

 

 

 

 

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.

 

 

The "u" and "r" prefixes can also be used with triple quoted strings.

 

 

 

 

 

=={{header|R}}==

str2 <- 'the quick brown fox, etc.'

R also uses backticks, for creating non-standard variable names (amongst other things).

`a b` # 4

R will print different styles of single and double quote using sQuote and dQuote

plain quotes: "double" and 'single'

fancy quotes: “double” and ‘single’

 

=={{header|Retro}}==

 

 

 

=={{header|REXX}}==

char2 = 'A'

str = "this is a string"

another = 'this is also a string'

escape1 = "that's it!"

result = "You got" amount "points."

<pre>

You got 100 points.

</pre>

cr = '0D'x

 

 

Binary strings are also possible:

 

 

=={{header|Ruby}}==

Quotes that do not interpolate:

%q(not interpolating with (nested) parentheses

Quotes that interpolate:

"double quotes with \"embedded quote\"\nnewline and variable interpolation: #{a} % 10 = #{a % 10}"

%Q(same as above)

Heredocs

With an unquoted delimiter, this interpolates:

a = #{a}

print <<'NON_INTERPOLATING'

This will not interpolate: #{a}

 

=={{header|Scala}}==

Character literals use single quotes marks:

 

 

 

 

 

res5: java.lang.String =

newline and slash:

 

scala> """newline and slash: \n and \\"""

 

 

uniquote: java.lang.String = normal string

 

scala> val insidequote = """an inside \u0022 quote"""

 

Finally, on version 2.7, the triple-double-quoted string ends at the third consecutive quote, on version 2.8 it ends on the last quote of a series of at least three double-quotes.

 

'''Scala 2.7'''

<console>:1: error: unterminated string

val error = """can't finish with a quote: """"

 

'''Scala 2.8'''

 

=={{header|Scheme}}==

 

Characters are specified using the "#\" syntax:

#\A

#\?

#\space

 

Strings are contained in double quotes:

 

Literal symbols, lists, pairs, etc. can be quoted using the quote syntax:

'(1 2 3) ; same as (list 1 2 3)

'() ; empty list

 

=={{header|Seed7}}==

 

 

 

 

 

 

\ which continues in the next line\n\

 

There is no built-in mechanism for expanding variables within strings.

 

=={{header|Slate}}==

Characters are specified using the <tt>$</tt> syntax:

 

$D

$8

$,

$\s

 

Strings are contained in single quotes, with backslash for escaping:

 

=={{header|Standard ML}}==

 

Characters are contained in the <code>#""</code> syntax:

 

Strings are contained in double quotes:

 

\def";

 

=={{header|Tcl}}==

 

Double quotes allow command and variable interpolation:

 

Braces prevent interpolation

 

=={{header|TI-89 BASIC}}==

 

 

=={{header|UNIX Shell}}==

 

=== Quotation marks within a literal String ===

 

 

We can also use an escapesequence to put doublequote characters in an interpolated string:

 

 

=== Here documents ===

 

1, High Street,

SMALLTOWN,

West Midlands.

WM4 5HD.

 

=={{header|Ursala}}==

 

Single characters are denoted with a back quote.

Unprintable character constants can be expressed like this.

Strings are enclosed in single forward quotes.

A single quote in a string is escaped by another single quote.

Multi-line strings are enclosed in dash-brackets.

 

-[this is a list

Dash-bracket enclosed text can have arbitrary nested

unquoted expressions, provided they evaluate to lists

of character strings.

 

This notation can also be used for defining functions.

The double quotes aren't for character strings but

dummy variables.

A simple quoted string is of the form 'string'

e.g

 

=={{header|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.

 

 

 

=={{header|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.

 

Double and single quote characters may also be escaped with XML entities: &amp;quot; and &amp;apos; respectively.