String concatenation: Difference between revisions

{{trans|Python}}

 

print(s1‘ world’)

V s2 = s1‘ world’

 

{{out}}

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program concatStr64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

{{Output}}

<pre>

 

=={{header|ABAP}}==

s2 TYPE string.

 

WRITE: / s1.

WRITE: / s2.

{{out}}

<pre>

</pre>

===Another way===

 

DATA(var1) = 'Hello'.

)->write( |{ var1 } world!|

)->display( ).

{{out}}

<pre>

 

=={{header|Action!}}==

BYTE POINTER srcPtr,dstPtr

BYTE len

PROC Main()

TestConcatenate("Hello", " World!")

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/String_concatenation.png Screenshot from Atari 8-bit computer]

 

=={{header|ActionScript}}==

{

public class Str

}

}

 

=={{header|Ada}}==

 

procedure String_Concatenation is

Put_Line (S1);

Put_Line (S2);

{{out|Sample output}}

<pre>

 

=={{header|Aime}}==

 

s = "Hello";

o_(s, "\n");

v = s + ", World!";

{{out}}

<pre>Hello

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}

print ((s + " literal", new line));

STRING s1 := s + " literal";

{{out}}

<pre>

 

=={{header|ALGOL-M}}==

begin

 

 

end

{{out}}

<pre>

=={{header|Apex}}==

 

String s1 = 'Hello ';

String s2 = 'Salesforce Developer!';

 

// Print output

{{out}}

<pre>Hello Salesforce Developer!</pre>

 

=={{header|AppleScript}}==

set endMsg to "world!"

set totMsg to "Hello, " & endMsg

display dialog totMsg

 

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program strConcat.s */

bx lr @ return

 

 

=={{header|Arturo}}==

str2: "World"

 

{{out}}

 

=={{header|Asymptote}}==

write(s1 + " World!");

write(s1, " World!");

string s2 = s1 + " World!";

 

=={{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|Axe}}==

Copy(r₁,L₁,length(r₁))

Copy(r₂,L₁+length(r₁),length(r₂)+1)

L₁

 

=={{header|BASIC}}==

{{works with|Run Basic}}

{{works with|Yabasic}}

print s$ + " literal"

s2$ = s$ + " literal"

print s$

{{out}}

<pre>hello literal

A semicolon (;) is ''not'' the same as a concatenate operator (+), it is an instruction that works only on the <code>PRINT</code> statement to suppress newlines at the end of a literal or series of literals. For example, the instruction <code>S$="HELLO";"LITERAL"</code> would result in a syntax error.

 

20 PRINT S$ + " LITERAL"

30 PRINT S$

40 S2$ = S$ + " LITERAL"

 

{{out}}

 

==={{header|BaCon}}===

A$ = "hello"

PRINT A$," World"

A2$ = A$ & " using & to concat World"

PRINT A2$

 

==={{header|BBC BASIC}}===

stringvar2$ = stringvar1$ + " world!"

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

{{out}}

<pre>Variable 1 is "Hello,"

 

==={{header|IS-BASIC}}===

110 LET S$=S$&" world!"

 

==={{header|BASIC256}}===

print s1$; " World!"

print s1$ + " World!"

print s2$

s2$ = s1$ & " World!"

 

==={{header|Run BASIC}}===

{{works with|Liberty BASIC}}

print s1$; " World!"

print s1$ + " World!"

print s2$

s2$ = s1$ + " World!"

 

==={{header|True BASIC}}===

{{works with|BASIC256}}

PRINT s1$; " World!"

PRINT s1$ + " World!"

LET s2$ = s1$ & " World!"

PRINT s2$

 

==={{header|uBasic/4tH}}===

Print Show(s); " World!"

Print Show(Join(s, " World!"))

t = Join(s, " World!")

Print Show(t)

==={{header|Yabasic}}===

{{works with|Liberty BASIC}}

{{works with|QBasic}}

{{works with|Run BASIC}}

print s1$, " World!"

print s1$ + " World!"

s2$ = s1$ + " World!"

 

==={{header|ZX Spectrum Basic}}===

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

 

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

echo %string% World

set string2=%string% World

 

=={{header|BQN}}==

<code>∾</code>(Join) will concatenate two strings together.

 

newstr ← str ∾ "world"

 

=={{header|Bracmat}}==

& "World":?var2

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

{{out}}

<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 sharp|C#}}==

 

class Program {

Console.WriteLine(s2);

}

 

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

#include <iostream>

 

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

return 0;

{{out}}

<pre>hello literal

 

=={{header|ChucK}}==

"Hello" => string A;

A + " World!" => string B;

<<< B >>>;

{{out}}

<pre>"Hello World!"</pre>

 

=={{header|Clojure}}==

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

 

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

 

=={{header|COBOL}}==

With the <code>STRING</code> verb:

PROGRAM-ID. Concat.

 

 

GOBACK

Alternate method using the <code>CONCATENATE</code> intrinsic function:

PROCEDURE DIVISION.

DISPLAY "Str : " Str

 

GOBACK

 

String literals can also be concatenated in the follwing ways:

01 Long-Str-Val PIC X(200) VALUE "Lorem ipsum dolor sit "

& "amet, consectetuer adipiscing elit, sed diam nonummy "

01 Another-Long-Str PIC X(200) VALUE " Ut wisi enim ad minim

- "veniam, quis nostrud exerci tation ullamcorper suscipit

 

=={{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|Component Pascal}}==

BlackBox Component Builder

MODULE StringConcatenation;

IMPORT StdLog;

 

END StringConcatenation.

Execute: ^Q StringConcatenation.Do<br/>

{{out}}

 

=={{header|D}}==

void main() {

auto s2 = s ~ " world";

writeln(s2);

 

=={{header|DCL}}==

$ string2 = string1 + " world"

{{out}}

<pre> STRING1 = "hello"

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

WriteLn(s1);

WriteLn(s2);

 

=={{header|DWScript}}==

var s2 := s1 + ' World';

 

PrintLn(s1);

 

=={{header|Dyalect}}==

{{trans|Swift}}

 

print(s + " literal")

var s1 = s + " literal"

 

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

//to be compiled using dylan.NET v. 11.5.1.2 or later.

#refstdasm mscorlib.dll

end method

 

 

=={{header|Déjà Vu}}==

local :s2 concat( s1 ", world" )

{{out}}

<pre>hello, world</pre>

 

=={{header|EasyLang}}==

b$ = a$ & " world"

 

=={{header|Ela}}==

Strings in Ela support a polymorphic concatenation operator (++):

hello'world = hello ++ ", " ++ "world"

{{out}}

<pre>("Hello", "Hello, world!")</pre>

a large number of concatenations. Therefore one can use an alternate technique (a pure StringBuilder

type defined in standard prelude). The resulting code would look like so:

The (+>) token is a type constructor. Therefore the result of its application is an instance of type

StringBuilder. In order to produce a string one should call a polymorphic toString function at the end

=={{header|Elena}}==

ELENA 4.x:

{

var s := "Hello";

console.writeLine:s2;

console.readChar()

{{out}}

<pre>

 

=={{header|Elixir}}==

s = "hello"

t = s <> " literal"

IO.puts s

IO.puts t

{{out}}

<pre>

=={{header|Emacs Lisp}}==

 

(defvar foobar (concat foo "bar"))

(message "%sbar" foo)

 

{{out}}

 

=={{header|Erlang}}==

S1 = S ++ " literal",

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

{{out|Sample output}}

<pre>

 

=={{header|ERRE}}==

..........

S$="HELLO"

PRINT(S2$)

..........

 

=={{header|Euphoria}}==

s = "hello"

puts(1, s & " literal")

s1 = s & " literal"

print (1, s1))

{{out}}

hello literal

Take three cells, say A1,B1 and C1. In C1, type in :

 

 

=CONCATENATE(A1;" ";B1)

 

 

As the text in A1 and/or B1 is changed, C1 will be updated.

 

Hello World Hello World

 

=={{header|F_Sharp|F#}}==

{{trans|C#}}

 

[<EntryPoint>]

let s2 = s + " literal"

Console.WriteLine(s2)

 

=={{header|Factor}}==

 

=={{header|Falcon}}==

'''VBA/Python programmer's approach. I'm just a junior Falconeer but this code seems falconic''

/* created by Aykayayciti Earl Lamont Montgomery

April 9th, 2018 */

s2 = s + " literal"

> s2

{{out}}

<pre>

=={{header|Fantom}}==

Illustrating in <tt>fansh</tt>:

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

 

 

=={{header|FreeBASIC}}==

 

Var s1 = "String"

Print s1

Print s2

 

{{out}}

 

=={{header|Frink}}==

a = "Frink"

b = a + " rules!"

println[b]

 

=={{header|FutureBasic}}==

 

CFStringRef s1, s2

print s2

 

 

=={{header|Gambas}}==

 

'''[https://gambas-playground.proko.eu/?gist=098450adbbe0e284f0b9cdac67d74dda Click this link to run this code]'''

DIM bestclub AS String

DIM myconcat AS String

Print myconcat

 

 

=={{header|GlovePIE}}==

 

=={{header|Go}}==

 

import "fmt"

// output second string variable

fmt.Println(s2)

{{out}}

<pre>

 

=={{header|Golfscript}}==

s"Earthlings"+puts

s"Earthlings"+:s1;

 

=={{header|Groovy}}==

println s + "Earthlings"

 

def s1 = s + "Earthlings"

{{out}}

<pre>Greetings Earthlings

=={{header|Halon}}==

The dot (concatenation) operator may cast datatypes to strings.

 

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

* http://www.jsoftware.com/help/dictionary/d320.htm on <code>,</code>

 

=={{header|Java}}==

public static void main(String[] args){

String s = "hello";

System.out.println(s2);

}

{{out}}

<pre>hello literal

 

=={{header|JavaScript}}==

 

=={{header|jq}}==

{{Out}}

# Use the -r command-line option if you wish

 

=={{header|Julia}}==

 

=={{header|K}}==

Translation of <b>J</b> code:

s1: "Some "

s1, "text "

s2: s1 , "more text!"

{{out}}

<pre>

 

=={{header|Kotlin}}==

val s1 = "James"

val s2 = "Bond"

val s3 = s1 + " " + s2

println(s3)

{{Out}}

<pre>James

=={{header|Lambdatalk}}==

In Lambdatalk writing {def name a sequence of words} replaces the sequence of words by the given name in the code string. The name is a word and is not evaluated. Bracketing a name between two curly braces returns its related value. And concatenating named strings is simply done by writing names between curly braces and separated by spaces.

{def christian_name Albert}

-> christian_name

{christian_name} {name}

-> Albert de Jeumont-Schneidre

 

=={{header|Lang5}}==

 

=={{header|Lasso}}==

local(y = #x + ', World!')

#x // Hello

 

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

 

=={{header|Lingo}}==

b = a & " world!"

put b

 

=={{header|Lisaac}}==

 

+ name := STRING_CONCATENATION;

sv.println;

 

 

=={{header|LiveCode}}==

put str & "code" into str2

Output<pre>live livecode</pre>

 

=={{header|Logo}}==

 

=={{header|Lua}}==

print(a .. "world")

c = a .. "world"

 

=={{header|M2000 Interpreter}}==

A memory word is two bytes.

 

Module CheckString {

s$ = "hello"

}

CheckString

 

=={{header|M4}}==

M4 has macros rather than variables, but a macro expanded can work like a variable.

define(`A',`any text value')dnl

concat(`A',` concatenated with string literal')

define(`B',`concat(`A',` and string literal')')dnl

 

=={{header|Maple}}==

newstr := cat(str,", world!"):

str;

{{out}}

<pre>

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

 

=={{header|MATLAB}} / {{header|Octave}}==

 

string1 =

string2 =

 

 

=={{header|Maxima}}==

t: "jumps over the lazy dog";

sconcat(s, " ", t);

 

=={{header|MAXScript}}==

print (s + " literal")

s1 = s + " literal"

 

=={{header|Mercury}}==

:- interface.

 

S1 = S ++ " world",

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

 

=={{header|Metafont}}==

a := "String";

message a & " literal";

b := a & " literal";

 

=={{header|min}}==

{{works with|min|0.19.3}}

(a "scotch")=> "" join :b

a puts!

{{out}}

<pre>

 

=={{header|MiniScript}}==

 

{{output}}

Using the following implementation of [[C]]'s <code>strcpy()</code>, we can concatenate strings easily by copying them to a RAM buffer back-to-back. We'll only do a few so that we don't clobber any other RAM we're using.

 

la $a0,String1

la $a1,UserRam

.ascii "lmnopqrstuvwxyz"

.byte 0

{{out}}

<pre>abcdefghijklmnopqrstuvwxyz</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|MUMPS}}==

SET S="STRING"

WRITE !,S

SET T=S_" LITERAL"

WRITE !,T

{{out}}

<pre>

 

=={{header|Nanoquery}}==

println s1 + " world"

 

s2 = s1 + " world"

{{out}}

<pre>hello world

 

=={{header|Neko}}==

String concatenation, in Neko

Tectonics:

$print("addon: ", addon, "\n")

$print("c: ", c, "\n")

 

{{out}}

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

{{out}}

<pre>

 

=={{header|NewLISP}}==

(println str1)

(let (str2 (string str1 "bar"))

 

=={{header|Nim}}==

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

echo str & " literal."

 

 

Strings can be concatenated as arrays and joined with separating characters:

var str = "String"

echo join([str, " literal.", "HelloWorld!"], "~~")

 

 

Strings can be combined using string formatting:

 

var str = "String"

# Alternate form providing automatic conversion of arguments to strings.

echo "$# $# $#".format(str, 123, "HelloWorld!")

 

=={{header|NS-HUBASIC}}==

20 STRING$=STRING$+" WORLD!"

 

=={{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|Oforth}}==

 

.s show the stack :

 

{{out}}

 

=={{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|Phix}}==

{{libheader|Phix/basics}}

<span style="color: #004080;">string</span> <span style="color: #000000;">s1</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"at"</span> <span style="color: #0000FF;">?</span><span style="color: #000000;">s1</span>

<span style="color: #004080;">string</span> <span style="color: #000000;">s2</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"c"</span><span style="color: #0000FF;">&</span><span style="color: #000000;">s1</span> <span style="color: #0000FF;">?</span><span style="color: #000000;">s2</span>

<span style="color: #004080;">string</span> <span style="color: #000000;">s4</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"m"</span><span style="color: #0000FF;">&</span><span style="color: #000000;">s1</span> <span style="color: #0000FF;">?</span><span style="color: #000000;">s4</span>

<span style="color: #004080;">string</span> <span style="color: #000000;">s5</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"The "</span><span style="color: #0000FF;">&</span><span style="color: #000000;">s2</span><span style="color: #0000FF;">&</span><span style="color: #008000;">" "</span><span style="color: #0000FF;">&</span><span style="color: #000000;">s3</span><span style="color: #0000FF;">&</span><span style="color: #008000;">" on the "</span><span style="color: #0000FF;">&</span><span style="color: #000000;">s4</span><span style="color: #0000FF;">&</span><span style="color: #008000;">"."</span> <span style="color: #0000FF;">?</span><span style="color: #000000;">s5</span>

{{out}}

<pre>

=={{header|PHL}}==

 

 

extern printf;

 

return 0;

 

=={{header|PHP}}==

$s = "hello";

echo $s . " literal" . "\n";

$s1 = $s . " literal";

echo $s1 . "\n";

 

=={{header|Picat}}==

Hello = "Hello, ",

print(Hello ++ "world!" ++ "\n"),

String = Hello ++ "world!",

String := String ++ "\n",

 

=={{header|PicoLisp}}==

(prinl Str1 " literal")

(let Str2 (pack Str1 " literal")

 

=={{header|Pike}}==

string hello = "hello ";

write(hello + "world" + "\n");

string all_of_it = hello + "world";

write(all_of_it + "\n");

{{Out}}

<pre>

 

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

 

s = 'hello from me';

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

t = s || ' to you all';

 

=={{header|Plain English}}==

Strings (and other values) can be concatenated to strings with <code>then</code>.

Start up.

Put "hello" into a string.

Write the other string to the console.

Wait for the escape key.

{{out}}

<pre>

 

=={{header|PowerShell}}==

Write-Host $s World.

 

 

$s2 = $s + " World."

 

=={{header|PureBasic}}==

 

s$ = "hello"

Input()

CloseConsole()

 

=={{header|Python}}==

print s1 + " world"

 

s2 = s1 + " world"

{{out}}

<pre>hello world

hello world</pre>

When concatenating many strings, it is more efficient to use the join method of a string object, which takes a list of strings to be joined. The string on which join is called is used as a separator.

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

 

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

{{out}}

<pre>hello, world, mom

 

=={{header|QB64}}==

s2$ = s1$ + " concatenation"

Print s1$

{{out}}

<pre>

=={{header|Quackery}}==

 

$ " has no echo."

join

 

{{out}}

 

=={{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|Raku}}==

(formerly Perl 6)

{{works with|Rakudo|#22 "Thousand Oaks"}}

say $s ~ ' literal';

my $s1 = $s ~ ' literal';

 

$s ~= ' literal';

Note also that most concatenation in Raku is done implicitly via interpolation.

 

=={{header|Raven}}==

"First string and " "second string" cat print

 

# Heredoc

" - NOT!!" as $x

{{out}}

<pre>First string and second string

 

=={{header|REBOL}}==

print s1: rejoin [s " literal"]

 

=={{header|Red}}==

>>str2: append str1 " World"

>> print str2

Hello World

>> print str1

 

=={{header|ReScript}}==

let s2 = s1 ++ " literal"

 

Js.log(s1)

Js.log(s2)

{{output}}

<pre>$ bsc sc.res > sc.js

 

=={{header|Retro}}==

 

=={{header|REXX}}==

say s "literal"

t = s "literal" /*whitespace between the two strings causes a space in the output.*/

genus= "straw"

say genus"berry" /*this outputs strawberry.*/

 

=={{header|Ring}}==

aString = "Welcome to the "

bString = "Ring Programming Language"

 

see astring + bString + nl

 

=={{header|Ruby}}==

s = "hello"

 

puts s #=> "Alice said: hello literal"

 

 

=={{header|Rust}}==

let s = "hello".to_owned();

println!("{}", s);

let s1 = s + " world";

println!("{}", s1);

 

=={{header|SAS}}==

a="Hello,";

b="World!";

c=catx (" ", a, b);

put c;

 

=={{header|Sather}}==

main is

s ::= "hello";

#OUT + s2 + "\n";

end;

 

=={{header|S-BASIC}}==

rem - the + operator is used to concatenate strings

 

 

end

{{out}}

<pre>

=={{header|Scala}}==

Evaluation in a Scala worksheet, to val f2 is an anonymous function assigned.

val s2 = s + " world" //> s2 : String = hello world

val f2 = () => " !" //> f2 : () => String = <function0>

 

 

=={{header|Scheme}}==

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

(newline)

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

(display s1)

 

=={{header|Scilab}}==

s1+" world!"

s2=s1+" world"

s2

{{out}}

<pre style="height:20ex> --> s1="Hello"

 

=={{header|Seed7}}==

const proc: main is func

s2 := s & " world";

writeln(s2);

{{out}}

<pre>

 

=={{header|Sidef}}==

say s+' literal';

var s1 = s+' literal';

An example of destructive concatenation:

 

=={{header|Simula}}==

TEXT head, tail;

BEGIN TEXT c;

another :- concatenate(stringVariable, "and tail");

OutText("stringVariable: """); OutText(stringVariable);

 

=={{header|Slate}}==

inform: s ; ' literal'.

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

 

=={{header|Smalltalk}}==

In Smalltalk "," (comma) is a binary message (virtual function) implemented by Collection (and therefore also understood by strings):

 

(s,' literal') printNl.

s1 := s,' literal'.

 

=={{header|SNOBOL4}}==

output = greet1

greet2 = greet1 "World!"

output = greet2

 

=={{header|Sparkling}}==

let s2 = " world!";

 

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

val s1 = s ^ " literal\n"

val () =

print (s ^ " literal\n");

 

=={{header|Stata}}==

=== Stata string scalars ===

sca b = "bar"

sca c = a+b

di c

 

=== Mata ===

b = "bar"

c = a+b

c

 

=={{header|Swift}}==

println(s + " literal")

let s1 = s + " literal"

 

=={{header|Symsyn}}==

| concatenate a string

 

$s []

 

 

{{out}}

=={{header|Tailspin}}==

Tailspin has no operator for concatenating strings, you simply use interpolation instead

def a: 'Hello';

'$a;, World!' -> !OUT::write

{{out}}

<pre>

 

=={{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 "!"

 

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

{{out}}

<pre>HELLO WORLD!</pre>

 

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

Disp sv & "vark"

 

=={{header|TorqueScript}}==

echo(%string);

%other = " world!";

echo(%other);

 

=={{header|TUSCRIPT}}==

s = "Hello "

print s, "literal"

 

s1 = CONCAT (s,"literal")

{{out}}

<pre>

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

{{works with|Bourne Shell}} {{works with|bash}}

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|Ursa}}==

# make s1 contain "hello "

set s1 "hello "

 

# outputs "hello world"

 

=={{header|Vala}}==

var s = "hello";

print(s);

var s2 = s + " literal\n";

print(s2);

 

=={{header|VBA}}==

 

Option Explicit

 

Debug.Print str2 & " based on concatenation of : " & str1 & " and code..."

End Sub

{{out}}

<pre>

 

=={{header|VBScript}}==

s2=s1 & " World!"

{{out}}

<pre>

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

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

Console.WriteLine(s & " literal")

s1 = s + " literal"

 

=={{header|Vlang}}==

 

println(s)

s2:= s+ ' literal'

 

{{out}}

<pre>

 

=={{header|Wee Basic}}==

let string2$="world!"

print 1 string1$+string2$

 

=={{header|Wren}}==

var t = s + "world!"

System.print(s)

 

{{out}}

 

=={{header|XPL0}}==

char S1, S2, S3;

int C, I, J;

Concat(A, B, C);

Text(0, C);

 

=={{header|Yorick}}==

var2 = var1 + ", world!";

write, var1;

 

=={{header|Zig}}==

 

const debug = std.debug;

 

debug.warn("{}\n", .{hello_world_joined});

 

{{out}}

 

=={{header|zkl}}==

s2:=s+", world!"; s2.println(); //-->Hello, world!

 

 

 

=={{header|Zoea}}==

program: string_concat

input: ['hello', 'literal']

output: 'hello literal'

 

=={{header|Zoea Visual}}==