String concatenation: Difference between revisions

 

To illustrate the operation, show the content of the variables.

 

=={{header|ActionScript}}==

{

public class Str

}

}

 

=={{header|Ada}}==

 

procedure String_Concatenation is

begin

<pre>

Hello literal

</pre>

 

=={{header|Aime}}==

 

s = "Hello";

{{out}}

<pre>Hello

Hello, World!</pre>

 

=={{header|AppleScript}}==

set endMsg to "world!"

set totMsg to "Hello, " & endMsg

display dialog totMsg

 

=={{header|AutoHotkey}}==

Msgbox, %s%

s1 := s . " literal" ;the . is optional

 

=={{header|AWK}}==

The AWK concatenation operator is nothing.

s = "hello"

print s " literal"

s1 = s " literal"

print s1

 

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

{{works with|Liberty BASIC}}

s2$ = s$ + " literal"

<pre>hello literal

hello literal</pre>

 

stringvar2$ = stringvar1$ + " world!"

PRINT "Variable 1 is """ stringvar1$ """"

<pre>Variable 1 is "Hello,"

Variable 2 is "Hello, world!"</pre>

 

20 LET s$=s$+" World!"

 

=={{header|Batch File}}==

echo %string% World

 

 

& "World":?var2

& str$(!var1 !var2):?var12

<pre>var1= Hello , var2= World , var12= Hello World</pre>

 

=={{header|Burlesque}}==

 

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

puts(s2);

free(s2);

 

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

#include <iostream>

 

std::cout << s2 << std::endl;

return 0;

<pre>hello literal

hello literal</pre>

 

 

=={{header|Clojure}}==

(println (str a-str "efgh"))

 

(def a-new-str (str a-str "efgh"))

 

=={{header|COBOL}}==

PROGRAM-ID. Concat.

 

 

GOBACK

PROCEDURE DIVISION.

DISPLAY "Str : " Str

 

GOBACK

 

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

(format t "~a there!~%" s)

(let* ((s2 " there!")

(s (concatenate 'string s s2)))

(print (concatenate 'string *s* " literal"))

(defparameter *s1* (concatenate 'string *s* " literal"))

 

=={{header|D}}==

void main() {

auto s2 = s ~ " world";

writeln(s2);

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

WriteLn(s1);

WriteLn(s2);

 

=={{header|DWScript}}==

var s2 := s1 + ' World';

 

PrintLn(s1);

 

=={{header|Dylan.NET}}==

#refstdasm mscorlib.dll

 

ver 1.3.0.0

 

 

method public static void main()

end method

 

 

=={{header|Erlang}}==

S1 = S ++ " literal",

io:format ("~s literal~n",[S]),

<pre>

hello literal

hello literal

</pre>

 

=={{header|Euphoria}}==

s = "hello"

puts(1, s & " literal")

s1 = s & " literal"

print (1, s1))

hello literal

hello literal

 

=={{header|Factor}}==

 

 

abc

fansh> b := a + "def"

abc

fansh> b

 

=={{header|Forth}}==

{{works with|GNU Forth}}

pad count type

s" there!" pad +place \ +place is called "append" on some Forths

 

=={{header|Fortran}}==

 

integer, parameter :: maxstringlength = 64

print *,s1

 

 

 

In gambas, the ampersand symbol is used as a concatenation operator:

 

DIM bestclub AS String

DIM myconcat AS String

bestclub = "Liverpool"

myconcat = bestclub & " Football Club"

 

=={{header|Go}}==

 

import "fmt"

// output second string variable

fmt.Println(s2)

<pre>

hello

 

=={{header|Golfscript}}==

s"Earthlings"+puts

s"Earthlings"+:s1;

 

=={{header|Groovy}}==

println s + "Earthlings"

 

def s1 = s + "Earthlings"

<pre>Greetings Earthlings

Greetings Earthlings</pre>

 

=={{header|Haskell}}==

s = "hello"

s1 = s ++ " literal"

main = do putStrLn (s ++ " literal")

 

=={{header|HicEst}}==

 

WRITE() s // " literal"

sl = s // " literal"

 

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

s1 := "hello"

write(s2 := s1 || " there.") # capture the reuslt for

write(s2) # ... the 2nd write

 

=={{header|IDL}}==

print, s1 + ' literal'

s2=s1 + ' literal'

 

=={{header|J}}==

]s1, 'text '

Some text

]s2 =. s1 , 'more text!'

For more info see:

 

=={{header|Java}}==

public static void main(String[] args){

String s = "hello";

System.out.println(s2);

}

<pre>hello literal

hello literal</pre>

 

=={{header|JavaScript}}==

 

 

 

[[File:LV_strcat.png]]

 

=={{header|Lang5}}==

 

=={{header|Liberty BASIC}}==

 

=={{header|Lisaac}}==

 

+ name := STRING_CONCATENATION;

sv.println;

 

 

=={{header|Logo}}==

print(a .. "world")

c = a .. "world"

 

 

 

string1 =

string2 =

 

 

=={{header|Maxima}}==

t: "jumps over the lazy dog";

sconcat(s, " ", t);

 

=={{header|Mercury}}==

:- interface.

 

S1 = S ++ " world",

io.write_string(S, !IO), io.nl(!IO),

 

</pre>

 

 

 

 

 

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

Strings in Modula-3 are called <code>TEXT</code>s. Concatenation can use <code>&</code>, just like [[Ada]].

 

IMPORT IO;

string1 := string & " literal.\n";

IO.Put(string1);

Modula-3 also provides modules for dealing with <code>TEXT</code>s, such as <code>Text</code>.

 

=={{header|Nemerle}}==

Can be done with Concat() method or + operator:

using System.Console;

using Nemerle.Utility.NString; // contains method Concat()

Write($"$cat1\n$cat2\n");

}

 

=={{header|NetRexx}}==

 

options replace format comments java crossref savelog symbols

say 's6:' s6

say 's7:' s7

s1: any text value

s2: another string literal

s7: any text valueanother string literal</pre>

 

Strings can be concatenated with <code>&</code>.

 

=={{header|Objeck}}==

class Repeat {

function : Main(args : String[]) ~ Nil {

}

}

 

=={{header|Objective-C}}==

 

int main()

{

return 0;

 

=={{header|OCaml}}==

let s1 = s ^ " literal"

let () =

print_endline (s ^ " literal");

 

=={{header|Openscad}}==

b="berry";

c=str(a,b); /* Concatenate a and b */

 

=={{header|Oz}}==

Strings are lists and are concatenated with the "Append" function. However, often "virtual strings" are used instead. [http://www.mozart-oz.org/home/doc/base/virtualstring.html "Virtual string are designed as a convenient way to combine strings, byte strings, atoms, integers and floats to compound strings without explicit concatenation and conversion"].

S = "hello"

{System.showInfo S#" literal"} %% virtual strings are constructed with "#"

S1 = {Append S " literal"}

 

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

s = Str(s, "world");

\\ Alternately, this could have been:

\\ s = concat(s, "world");

 

=={{header|Pascal}}==

Var

s, s1 : String;

{ s1 := s + ' literal'; works too, with FreePascal }

writeln(s1);

 

=={{header|Perl}}==

print $s . ' literal', "\n";

my $s1 = $s . ' literal';

An example of destructive concatenation:

 

 

 

 

 

 

 

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

 

s = 'hello from me';

display (s || ' to you.' );

t = s || ' to you all';

 

=={{header|PowerShell}}==

Write-Host $s World.

 

 

$s2 = $s + " World."

 

=={{header|PureBasic}}==

s$ = "hello"

PrintN( s$ + " literal")

Input()

CloseConsole()

 

=={{header|Python}}==

print s1 + " world"

 

s2 = s1 + " world"

<pre>hello world

hello world</pre>

print ", ".join([s1, "world", "mom"])

 

s2 = ", ".join([s1, "world", "mom"])

 

 

=={{header|R}}==

paste(hello, "literal") # "hello literal"

hl <- paste(hello, "literal") #saves concatenates string to a new variable

 

=={{header|Racket}}==

(define hello "hello")

(displayln hello)

;outputs:

; hello

=={{header|Raven}}==

"First string and " "second string" cat print

 

# Heredoc

" - NOT!!" as $x

<pre>First string and second string

First string and second string and third string

 

=={{header|REBOL}}==

print s1: rejoin [s " literal"]

 

=={{header|REXX}}==

say s "literal"

say t

 

 

 

=={{header|Ruby}}==

 

 

 

 

 

 

 

=={{header|SAS}}==

a="Hello,";

b="World!";

c=a !! " " !! b;

put c;

 

=={{header|Sather}}==

main is

s ::= "hello";

#OUT + s2 + "\n";

end;

 

=={{header|Scala}}==

 

=={{header|Scheme}}==

(display (string-append s " literal"))

(newline)

(define s1 (string-append s " literal"))

(display s1)

 

=={{header|Seed7}}==

const proc: main is func

s2 := s & " world";

writeln(s2);

<pre>

hello world

hello world

</pre>

 

=={{header|Slate}}==

inform: s ; ' literal'.

define: #s1 -> (s ; ' literal').

 

=={{header|Smalltalk}}==

(s,' literal') printNl.

s1 := s,' literal'.

 

=={{header|SNOBOL4}}==

output = greet1

greet2 = greet1 "World!"

output = greet2

 

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

val s1 = s ^ " literal\n"

val () =

print (s ^ " literal\n");

 

=={{header|Tcl}}==

puts "$s there!"

append s " there!"

You can also just group the strings to concatenate together at the point where they are used, using Tcl's built-in syntactic concatenation:

set t "World"

set u "!"

 

 

Disp sv & "vark"

 

=={{header|TorqueScript}}==

echo(%string);

%other = " world!";

echo(%other);

 

=={{header|TUSCRIPT}}==

s = "Hello "

print s, "literal"

 

s1 = CONCAT (s,"literal")

<pre>

Hello literal

</pre>

 

 

 

echo "$s literal"

s1="$s literal" # This method only works with a space between the strings

genus='straw'

fruit=${genus}berry # This outputs the word strawberry

 

=={{header|UnixPipes}}==

 

=={{header|Visual Basic .NET}}==

'''Platform:''' [[.NET]]

{{works with|Visual Basic .NET|9.0+}}

Console.WriteLine(s & " literal")

s1 = s + " literal"

 

=={{header|XPL0}}==

char S1, S2, S3;

int C, I, J;

Concat(A, B, C);

Text(0, C);

 

=={{header|Yorick}}==

var2 = var1 + ", world!";

write, var1;