String concatenation

From Rosetta Code
Task
String concatenation
You are encouraged to solve this task according to the task description, using any language you may know.

Basic Data Operation
This is a basic data operation. It represents a fundamental action on a basic data type.

You may see other such operations in the Basic Data Operations category, or:

Integer Operations
Arithmetic | Comparison

Boolean Operations
Bitwise | Logical

String Operations
Concatenation | Interpolation | Comparison | Matching

Memory Operations
Pointers & references | Addresses

Create a string variable equal to any text value. Create another string variable whose value is the original variable concatenated with another string literal.

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

Metrics: length

Sub-string search: Count occurrences of a substring

Multi-string operations: LCP, LCS, concatenation

Manipulation: reverse, lower- and uppercase

ABAP[edit]

DATA: s1 TYPE string,
s2 TYPE string.
 
s1 = 'Hello'.
CONCATENATE s1 ' literal' INTO s2 RESPECTING BLANKS.
WRITE: / s1.
WRITE: / s2.
 
Output:
Hello
Hello literal

ActionScript[edit]

package
{
public class Str
{
public static function main():void
{
var s:String = "hello";
trace(s + " literal");
var s2:String = s + " literal";
trace(s2);
}
}
}

Ada[edit]

with Ada.Text_IO;  use Ada.Text_IO;
 
procedure String_Concatenation is
S : String := "Hello";
begin
Put_Line (S);
declare
S1 : String := S & " literal";
begin
Put_Line (S1);
end;
end String_Concatenation;
Sample output:
Hello
Hello literal

Aime[edit]

text s, v;
 
s = "Hello";
o_text(s);
o_newline();
v = cat(s, ", World!");
o_text(v);
o_newline();
Output:
Hello
Hello, World!

AppleScript[edit]

try
set endMsg to "world!"
set totMsg to "Hello, " & endMsg
display dialog totMsg
end try

AutoHotkey[edit]

s := "hello"
Msgbox, %s%
s1 := s . " literal" ;the . is optional
Msgbox, %s1%

AWK[edit]

The AWK concatenation operator is nothing.

BEGIN {
s = "hello"
print s " literal"
s1 = s " literal"
print s1
}

Axe[edit]

Lbl CONCAT
Copy(r₁,L₁,length(r₁))
Copy(r₂,L₁+length(r₁),length(r₂)+1)
L₁
Return

ALGOL 68[edit]

Works with: ALGOL 68 version Revision 1 - no extensions to language used
Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny
Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8-8d
STRING s := "hello";
print ((s + " literal", new line));
STRING s1 := s + " literal";
print ((s1, new line))
Output:
hello literal
hello literal

BASIC[edit]

Works with: QuickBasic version 4.5
Works with: Liberty BASIC
s$ = "hello"
PRINT s$;" literal" 'or s$ + " literal"
s2$ = s$ + " literal"
PRINT s2$
Output:
hello literal
hello literal

Applesoft BASIC[edit]

S$ = "HELLO"
PRINT S$;" LITERAL" :REM OR S$ + " LITERAL"
S2$ = S$ + " LITERAL"
PRINT S2$

BBC BASIC[edit]

      stringvar1$ = "Hello,"
stringvar2$ = stringvar1$ + " world!"
PRINT "Variable 1 is """ stringvar1$ """"
PRINT "Variable 2 is """ stringvar2$ """"
Output:
Variable 1 is "Hello,"
Variable 2 is "Hello, world!"

ZX Spectrum Basic[edit]

10 LET s$="Hello"
20 LET s$=s$+" World!"
30 PRINT s$

Batch File[edit]

set string=Hello
echo %string% World
set string2=%string% World
echo %string2%

Bracmat[edit]

"Hello ":?var1 
& "World":?var2
& str$(!var1 !var2):?var12
& put$("var1=" !var1 ", var2=" !var2 ", var12=" !var12 "\n")
Output:
var1= Hello  , var2= World , var12= Hello World

Burlesque[edit]

blsq ) "Hello, ""world!"?+
"Hello, world!"

C[edit]

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
char *sconcat(const char *s1, const char *s2)
{
char *s0 = malloc(strlen(s1)+strlen(s2)+1);
strcpy(s0, s1);
strcat(s0, s2);
return s0;
}
 
int main()
{
const char *s = "hello";
char *s2;
 
printf("%s literal\n", s);
/* or */
printf("%s%s\n", s, " literal");
 
s2 = sconcat(s, " literal");
puts(s2);
free(s2);
}

ChucK[edit]

 
"Hello" => string A;
A + " World!" => string B;
<<< B >>>;
 
Output:
"Hello World!"

C++[edit]

#include <string>
#include <iostream>
 
int main() {
std::string s = "hello";
std::cout << s << " literal" << std::endl;
std::string s2 = s + " literal";
std::cout << s2 << std::endl;
return 0;
}
Output:
hello literal
hello literal

C#[edit]

using System;
 
class Program {
static void Main(string[] args) {
var s = "hello";
Console.Write(s);
Console.WriteLine(" literal");
var s2 = s + " literal";
Console.WriteLine(s2);
}
}

Clojure[edit]

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

COBOL[edit]

With the STRING verb:

       IDENTIFICATION DIVISION.
PROGRAM-ID. Concat.
 
DATA DIVISION.
WORKING-STORAGE SECTION.
01 Str PIC X(7) VALUE "Hello, ".
01 Str2 PIC X(15).
 
PROCEDURE DIVISION.
DISPLAY "Str  : " Str
STRING Str " World!" DELIMITED BY SIZE INTO Str2
DISPLAY "Str2 : " Str2
 
GOBACK
.

Alternate method using the CONCATENATE intrinsic function:

       ...
PROCEDURE DIVISION.
DISPLAY "Str  : " Str
MOVE FUNCTION CONCATENATE(Str, " World!") TO Str2
DISPLAY "Str2 : " Str2
 
GOBACK
.

String literals can also be concatenated in the follwing ways:

*      *> Using a '&'.
01 Long-Str-Val PIC X(200) VALUE "Lorem ipsum dolor sit "
& "amet, consectetuer adipiscing elit, sed diam nonummy "
& "nibh euismod tincidunt ut laoreet dolore magna aliquam "
& "erat volutpat.".
 
* *> Using a '-' in column 7. Note the first two literals have no
* *> closing quotes.
01 Another-Long-Str PIC X(200) VALUE " Ut wisi enim ad minim
- "
veniam, quis nostrud exerci tation ullamcorper suscipit
- "lobortis nisl ut aliquip ex ea commodo consequat".

Common Lisp[edit]

(let ((s "hello"))
(format t "~a there!~%" s)
(let* ((s2 " there!")
(s (concatenate 'string s s2)))
(format t "~a~%" s)))
(defparameter *s* "hello")
(print (concatenate 'string *s* " literal"))
(defparameter *s1* (concatenate 'string *s* " literal"))
(print *s1*)

Component Pascal[edit]

BlackBox Component Builder

 
MODULE StringConcatenation;
IMPORT StdLog;
 
PROCEDURE Do*;
VAR
str1,str2: ARRAY 128 OF CHAR;
BEGIN
str1 := "Hello";
str2 := str1 + " world";
StdLog.String(":> " + str2);StdLog.Ln
END Do;
 
END StringConcatenation.
 

Execute: ^Q StringConcatenation.Do

Output:
:> Hello world

D[edit]

import std.stdio;
 
void main() {
string s = "hello";
writeln(s ~ " world");
auto s2 = s ~ " world";
writeln(s2);
}

DCL[edit]

$ string1 = "hello"
$ string2 = string1 + " world"
$ show symbol string*
Output:
  STRING1 = "hello"
  STRING2 = "hello world"

Delphi[edit]

program Concat;
 
{$APPTYPE CONSOLE}
 
var
s1, s2: string;
begin
s1 := 'Hello';
s2 := s1 + ' literal';
WriteLn(s1);
WriteLn(s2);
end.

Déjà Vu[edit]

local :s1 "hello"
local :s2 concat( s1 ", world" )
!print s2
Output:
hello, world

DWScript[edit]

var s1 := 'Hello';
var s2 := s1 + ' World';
 
PrintLn(s1);
PrintLn(s2);

Dylan.NET[edit]

 
//to be compiled using dylan.NET v. 11.5.1.2 or later.
#refstdasm mscorlib.dll
 
import System
 
assembly concatex exe
ver 1.3.0.0
 
class public Program
 
method public static void main()
var s as string = "hello"
Console::Write(s)
Console::WriteLine(" literal")
var s2 as string = s + " literal"
Console::WriteLine(s2)
end method
 
end class

Ela[edit]

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

hello = "Hello"
hello'world = hello ++ ", " ++ "world"
(hello, hello'world)
Output:
("Hello", "Hello, world!")

However, as long as strings in Ela are indexed arrays, this operator is not very effective for 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:

toString $ "Hello" +> ", " +> "world"

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 as shown above.

Elena[edit]

#import system.
#import extensions.
 
#symbol program =
[
#var s := "Hello".
#var s2 := s + " literal".
 
console writeLine:s.
console writeLine:s2.
].

Elixir[edit]

 
s = "hello"
t = s <> " literal"
 
IO.puts s
IO.puts t
 
Output:
hello
hello literal

Emacs Lisp[edit]

version 1[edit]

 
(defun glue (str1 str2)
(concat str1 str2) )
 

version 2[edit]

 
(defun glue (str1 str2)
(format "%s%s" str1 str2) )
 

Eval:

 
(setq str1 "Hello, ")
(setq str2 "World!")
(insert (glue str1 str2) )
 

Output:

Hello, World!

Erlang[edit]

S = "hello",
S1 = S ++ " literal",
io:format ("~s literal~n",[S]),
io:format ("~s~n",[S1])
Sample output:
hello literal
hello literal

ERRE[edit]

 
..........
S$="HELLO"
PRINT(S$;" LITERAL") ! or S$+" LITERAL"
S2$=S$+" LITERAL"
PRINT(S2$)
..........
 

Euphoria[edit]

sequence s, s1
s = "hello"
puts(1, s & " literal")
puts(1,'\n')
s1 = s & " literal"
print (1, s1))
puts(1,'\n')
Output:
hello literal
hello literal


Excel[edit]

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
 


F#[edit]

Translation of: C#
open System
 
[<EntryPoint>]
let main args =
let s = "hello"
Console.Write(s)
Console.WriteLine(" literal")
let s2 = s + " literal"
Console.WriteLine(s2)
0

Factor[edit]

"wake up" [ " sheeple" append print ] [ ", you sheep" append ] bi print

Fantom[edit]

Illustrating in fansh:

fansh> a := "abc"
abc
fansh> b := a + "def"
abcdef
fansh> a
abc
fansh> b
abcdef

Forth[edit]

Works with: GNU Forth
s" hello" pad place
pad count type
s" there!" pad +place \ +place is called "append" on some Forths
pad count type

Fortran[edit]

program StringConcatenation
 
integer, parameter :: maxstringlength = 64
character (maxstringlength) :: s1, s = "hello"
 
print *,s // " literal"
s1 = trim(s) // " literal"
print *,s1
 
end program

Frink[edit]

 
a = "Frink"
b = a + " rules!"
println[b]
 

Gambas[edit]

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"

Go[edit]

package main
 
import "fmt"
 
func main() {
// text assigned to a string variable
s := "hello"
 
// output string variable
fmt.Println(s)
 
// this output requested by original task descrption, although
// not really required by current wording of task description.
fmt.Println(s + " literal")
 
// concatenate variable and literal, assign result to another string variable
s2 := s + " literal"
 
// output second string variable
fmt.Println(s2)
}
Output:
hello
hello literal
hello literal

Golfscript[edit]

"Greetings ":s;
s"Earthlings"+puts
s"Earthlings"+:s1;
s1 puts

Groovy[edit]

def s = "Greetings "
println s + "Earthlings"
 
def s1 = s + "Earthlings"
println s1
Output:
Greetings Earthlings
Greetings Earthlings

Haskell[edit]

import System.IO
s = "hello"
s1 = s ++ " literal"
main = do putStrLn (s ++ " literal")
putStrLn s1

HicEst[edit]

CHARACTER s = "hello", sl*100
 
WRITE() s // " literal"
sl = s // " literal"
WRITE() sl

Icon and Unicon[edit]

procedure main()
s1 := "hello"
write(s2 := s1 || " there.") # capture the reuslt for
write(s2) # ... the 2nd write
end

IDL[edit]

s1='Hello'
print, s1 + ' literal'
s2=s1 + ' literal'
print, s2

J[edit]

   s1 =. 'Some '
]s1, 'text '
Some text
]s2 =. s1 , 'more text!'
Some more text!

For more info see:

Java[edit]

public class Str{
public static void main(String[] args){
String s = "hello";
System.out.println(s + " literal");
String s2 = s + " literal";
System.out.println(s2);
}
}
Output:
hello literal
hello literal

JavaScript[edit]

var s = "hello"
print(s + " there!")

jq[edit]

"hello" as $s | $s + " there!"
Output:
# Use the -r command-line option if you wish 
# to suppress the string quotation marks
hello there!

Julia[edit]

s = "hello"
println(s * " there!")

LabVIEW[edit]

The two input on the left are String Controls, the output on the right is a String Indicator. All of them can be placed on the Front Panel. The Concatenate Strings function can be placed on the Block Diagram. You can switch between the Front Panel and the Block Diagram by pressing Ctrl+E.

LV strcat.png

Lang5[edit]

: concat  2 compress "" join ;
'hello " literal" concat


Lasso[edit]

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

Liberty BASIC[edit]

See BASIC.

Lisaac[edit]

Section Header
 
+ name := STRING_CONCATENATION;
 
Section Public
 
- main <- (
+ sc : STRING_CONSTANT;
+ sv : STRING;
 
sc := "Hello";
(sc + " literal").println;
 
sv := sc + " literal";
sv.println;
 
);

LiveCode[edit]

local str="live"
put str & "code" into str2
put str && str2
Output
live livecode

[edit]

make "s "hello
print word :s "| there!|

Lua[edit]

a = "hello "
print(a .. "world")
c = a .. "world"
print(c)

Maple[edit]

str := "Hello":
newstr := cat(str,", world!"):
str;
newstr;
Output:
                            "Hello"
                        "Hello, world!"

Mathematica[edit]

str= "Hello ";
str<>"Literal"

MATLAB / Octave[edit]

>> string1 = '1 Fish'
 
string1 =
 
1 Fish
 
>> string2 = [string1 ', 2 Fish, Red Fish, Blue Fish']
 
string2 =
 
1 Fish, 2 Fish, Red Fish, Blue Fish

Maxima[edit]

s: "the quick brown fox";
t: "jumps over the lazy dog";
sconcat(s, " ", t);
/* "the quick brown fox jumps over the lazy dog" */

Mercury[edit]

:- module string_concat.
:- interface.
 
:- import_module io.
:- pred main(io::di, io::uo) is det.
 
:- implementation.
:- import_module string.
 
main(!IO) :-
S = "hello",
S1 = S ++ " world",
io.write_string(S, !IO), io.nl(!IO),
io.write_string(S1, !IO), io.nl(!IO).

MUMPS[edit]

STRCAT
SET S="STRING"
WRITE !,S
SET T=S_" LITERAL"
WRITE !,T
QUIT
Output:
CACHE>D STRCAT^ROSETTA
 
STRING
STRING LITERAL

M4[edit]

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

define(`concat',`$1$2')dnl
define(`A',`any text value')dnl
concat(`A',` concatenated with string literal')
define(`B',`concat(`A',` and string literal')')dnl
B

MAXScript[edit]

s = "hello"
print (s + " literal")
s1 = s + " literal"
print s1

Metafont[edit]

string a, b;
a := "String";
message a & " literal";
b := a & " literal";
message b;

Modula-3[edit]

Strings in Modula-3 are called TEXTs. Concatenation can use &, just like Ada.

MODULE Concat EXPORTS Main;
 
IMPORT IO;
 
VAR string: TEXT := "String";
string1: TEXT;
 
BEGIN
IO.Put(string & " literal.\n");
string1 := string & " literal.\n";
IO.Put(string1);
END Concat.

Modula-3 also provides modules for dealing with TEXTs, such as Text.

string1 := Text.Concat(string, " literal.\n");

Nemerle[edit]

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

using System;
using System.Console;
using Nemerle.Utility.NString; // contains method Concat()
 
module Stringcat
{
Main() : void
{
def text1 = "This string has";
def cat1 = Concat( " ", [text, "been concatenated"]);
def cat2 = text1 + " also been concatenated";
Write($"$cat1\n$cat2\n");
}
}

NetRexx[edit]

/* NetRexx */
 
options replace format comments java crossref savelog symbols
 
s1 = 'any text value'
s2 = 'another string literal'
s3 = s1 s2 -- concatenate variables with blank space (note that only one blank space is added)
s4 = s1 || s2 -- concatenate variables with abuttal (here, no blank spaces are added)
s5 = s1 'another string literal' -- concatenate a variable and a literal with blank space
s6 = s1'another string literal' -- concatenate a variable and a literal using abuttal
s7 = s1 || 'another string literal' -- ditto
 
say 's1:' s1 -- concatenation with blank space is employed here too
say 's2:' s2
say 's3:' s3
say 's4:' s4
say 's5:' s5
say 's6:' s6
say 's7:' s7
 
Output:
s1: any text value
s2: another string literal
s3: any text value another string literal
s4: any text valueanother string literal
s5: any text value another string literal
s6: any text valueanother string literal
s7: any text valueanother string literal

NewLISP[edit]

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

Nim[edit]

Strings can be concatenated with &.

var str, str1 = "String"
echo(str & " literal.")
str1 = str1 & " literal."
echo(str1)
 
# -> String literal.

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

var str1 = "String"
echo(join([str1, " literal.", "HelloWorld!"], "~~"))
 
# -> String~~ literal.~~HelloWorld!

Strings can be combined using string formatting:

var str1 = "String"
echo "$# $# $#" % [str1, "literal.", "HelloWorld!"]
 
# -> String literal. HelloWorld!

Objeck[edit]

bundle Default {
class Repeat {
function : Main(args : String[]) ~ Nil {
s := "hello";
s->PrintLine();
" literal"->PrintLine();
s->Append(" literal");
s->PrintLine();
}
}
}

Objective-C[edit]

#import <Foundation/Foundation.h>
 
int main()
{
@autoreleasepool {
 
NSString *s = @"hello";
printf("%s%s\n", [s UTF8String], " literal");
 
NSString *s2 = [s stringByAppendingString:@" literal"];
// or, NSString *s2 = [NSString stringWithFormat:@"%@%@", s, @" literal"];
puts([s2 UTF8String]);
/* or */
NSMutableString *s3 = [NSMutableString stringWithString: s];
[s3 appendString: @" literal"];
puts([s3 UTF8String]);
 
}
return 0;
}

OCaml[edit]

let s = "hello"
let s1 = s ^ " literal"
let () =
print_endline (s ^ " literal");
(* or Printf.printf "%s literal\n" s; *)
print_endline s1

Oforth[edit]

.s show the stack :

"Hello" dup " World!" + .s 
Output:
[1] (String) Hello World!
[2] (String) Hello

Openscad[edit]

a="straw";
b="berry";
c=str(a,b); /* Concatenate a and b */
echo (c);

Oz[edit]

Strings are lists and are concatenated with the "Append" function. However, often "virtual strings" are used instead. "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".

declare
S = "hello"
{System.showInfo S#" literal"} %% virtual strings are constructed with "#"
S1 = {Append S " literal"}
{System.showInfo S1}

PARI/GP[edit]

s = "Hello ";
s = Str(s, "world");
\\ Alternately, this could have been:
\\ s = concat(s, "world");
print(s);

Pascal[edit]

Program StringConcat;
Var
s, s1 : String;
 
Begin
s := 'hello';
writeln(s + ' literal');
s1 := concat(s, ' literal');
{ s1 := s + ' literal'; works too, with FreePascal }
writeln(s1);
End.

Perl[edit]

my $s = 'hello';
print $s . ' literal', "\n";
my $s1 = $s . ' literal';
print $s1, "\n";

An example of destructive concatenation:

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

Perl 6[edit]

Works with: Rakudo version #22 "Thousand Oaks"
my $s = 'hello';
say $s ~ ' literal';
my $s1 = $s ~ ' literal';
say $s1;

An example of mutating concatenation:

$s ~= ' literal';
say $s;

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

Phix[edit]

string s1 = "at"                                ?s1
string s2 = "c"&s1  ?s2
string s3 = "s"&s1  ?s3
string s4 = "m"&s1  ?s4
string s5 = "The "&s2&" "&s3&" on the "&s4&"."  ?s5
Output:
"at"
"cat"
"sat"
"mat"
"The cat sat on the mat."

PHL[edit]

module stringcat;
 
extern printf;
 
@Integer main [
var a = "hello";
var b = a + " literal";
printf("%s\n", b);
 
return 0;
]

PHP[edit]

<?php
$s = "hello";
echo $s . " literal" . "\n";
$s1 = $s . " literal";
echo $s1 . "\n";
?>

PicoLisp[edit]

(let Str1 "First text"
(prinl Str1 " literal")
(let Str2 (pack Str1 " literal")
(prinl Str2) ) )

PL/I[edit]

declare (s, t) character (30) varying;
 
s = 'hello from me';
display (s || ' to you.' );
t = s || ' to you all';
display (t);

PowerShell[edit]

$s = "Hello"
Write-Host $s World.
 
# alternative, using variable expansion in strings
Write-Host "$s World."
 
$s2 = $s + " World."
Write-Host $s2

PureBasic[edit]

If OpenConsole()
 
s$ = "hello"
PrintN( s$ + " literal")
s2$ = s$ + " literal"
PrintN(s2$)
 
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit")
Input()
CloseConsole()
EndIf

Python[edit]

s1 = "hello"
print s1 + " world"
 
s2 = s1 + " world"
print s2
Output:
hello world
hello world

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.

s1 = "hello"
print ", ".join([s1, "world", "mom"])
 
s2 = ", ".join([s1, "world", "mom"])
print s2
Output:
hello, world, mom
hello, world, mom

R[edit]

hello <- "hello"
paste(hello, "literal") # "hello literal"
hl <- paste(hello, "literal") #saves concatenates string to a new variable
paste("no", "spaces", "between", "words", sep="") # "nospacesbetweenwords"

Racket[edit]

#lang racket
(define hello "hello")
(displayln hello)
 
(define world (string-append hello " " "world" "!"))
(displayln world)
 
;outputs:
; hello
; hello world!

Raven[edit]

# Cat strings
"First string and " "second string" cat print
 
# Join
[ "First string" "second string" "third string" ] " and " join print
 
# print
[ "First string" "second string" "third string" ] each print
 
# Formatted print
"\n" "Third string" "Second string" "First string" "%s %s %s %s" print
 
# Heredoc
" - NOT!!" as $x
"This is the only way to do it%($x)s" print
Output:
First string and second string
First string and second string and third string
First stringsecond stringthird string
First string Second string Third string 

This is the only way to do it - NOT!!

REBOL[edit]

s: "hello"
print s1: rejoin [s " literal"]
print s1

REXX[edit]

s = "hello"
say s "literal"
t = s "literal" /* Whitespace between the two strings causes a space in the output */
say t
 
/* The above method works without spaces too */
genus="straw"
say genus"berry" /* This outputs strawberry */
say genus || "berry" /* Concatenation using a doublepipe does not cause spaces */

Retro[edit]

with strings'
"hello" "literal" append puts

Ring[edit]

 
aString = "Welcome to the "
bString = "Ring Programming Language"
 
see astring + bString + nl
 

Ruby[edit]

s = "hello"
p s + " literal" #=> "hello literal"
s1 = s + " literal"
p s1 #=> "hello literal"
s1 << " another" # append to s1
p s1 #=> "hello literal another"
 
s = "hello"
p s.concat(" literal") #=> "hello literal"
p s #=> "hello literal"

Rust[edit]

fn main() {
let s = "hello".to_owned();
println!("{}", s);
 
let s1 = s + " world";
println!("{}", s1);
}

SAS[edit]

data _null_;
a="Hello,";
b="World!";
c=a !! " " !! b;
put c;
*Alternative using the catx function;
c=catx (" ", a, b);
put c;
run;

Sather[edit]

class MAIN is
main is
s ::= "hello";
#OUT + s + " literal\n";
s2 ::= s + " literal";
#OUT + s2 + "\n";
end;
end;

Scala[edit]

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

  val s = "hello"                                 //> s  : String = hello
val s2 = s + " world" //> s2  : String = hello world
val f2 = () => " !" //> f2  : () => String = <function0>
 
println(s2 + f2()) //> hello world !

Scheme[edit]

(define s "hello")
(display (string-append s " literal"))
(newline)
(define s1 (string-append s " literal"))
(display s1)
(newline)

Scilab[edit]

s1="Hello"
s1+" world!"
s2=s1+" world"
s2
 
Output:
 --> s1="Hello"
 s1  =
 Hello   
 -->s1+" world!"
 ans  =
 Hello world!   
 -->s2=s1+" world!"
 s2  =
 Hello world!   
 -->s2
 Hello world!   


Seed7[edit]

$ include "seed7_05.s7i";
 
const proc: main is func
local
var string: s is "hello";
var string: s2 is "";
begin
writeln(s <& " world");
s2 := s & " world";
writeln(s2);
end func;
Output:
hello world
hello world

Sidef[edit]

var s = 'hello';
say s+' literal';
var s1 = s+' literal';
say s1;

An example of destructive concatenation:

s += ' literal';
say s;

Slate[edit]

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

Smalltalk[edit]

|s s1| s := 'hello'.
(s,' literal') printNl.
s1 := s,' literal'.
s1 printNl.

SNOBOL4[edit]

	greet1 = "Hello, "
output = greet1
greet2 = greet1 "World!"
output = greet2
end

Sparkling[edit]

let s1 = "Hello";
let s2 = " world!";
print(s1 .. s2); // prints "Hello world!"

Standard ML[edit]

val s = "hello"
val s1 = s ^ " literal\n"
val () =
print (s ^ " literal\n");
print s1

Swift[edit]

let s = "hello"
println(s + " literal")
let s1 = s + " literal"
println(s1)

Tcl[edit]

set s hello
puts "$s there!"
append s " there!"
puts $s

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 s "Hello "
set t "World"
set u "!"
puts $s$t$u ;# There is nothing special here about using puts; just an example

TI-83 BASIC[edit]

"HELLO"→Str0
Str0+" WORLD!"→Str0
Output:
HELLO WORLD!

TI-89 BASIC[edit]

"aard" → sv
Disp sv & "vark"
sv & "wolf" → sv2

TorqueScript[edit]

%string = "Hello";
echo(%string);
%other = " world!";
echo(%other);
echo(%string @ %other);

TUSCRIPT[edit]

$$ MODE TUSCRIPT
s = "Hello "
print s, "literal"
 
s1 = CONCAT (s,"literal")
print s1
Output:
Hello literal
Hello literal 

UNIX Shell[edit]

Works with: Bourne Shell
Works with: bash
s="hello"
echo "$s literal"
s1="$s literal" # This method only works with a space between the strings
echo $s1
 
# To concatenate without the space we need squiggly brackets:
genus='straw'
fruit=${genus}berry # This outputs the word strawberry
echo $fruit

UnixPipes[edit]

echo "hello" 
| xargs -n1 -i echo {} literal

Visual Basic .NET[edit]

Platform: .NET

Works with: Visual Basic .NET version 9.0+
s = "Hello"
Console.WriteLine(s & " literal")
s1 = s + " literal"
Console.WriteLine(s1)

XPL0[edit]

func Concat(S1, S2, S3);        \Concatenate strings: S3:= S1 + S2
char S1, S2, S3;
int C, I, J;
[I:= 0;
repeat C:= S1(I);
S3(I):= C & $7F; \remove MSb terminator from first string
I:= I+1;
until C >= $80;
J:= 0;
repeat C:= S2(J);
S3(I+J):= C;
J:= J+1;
until C >= $80;
return S3;
];
 
code Text=12;
char A, B, C(80);
[A:= "Hello";
B:= " World!";
Concat(A, B, C);
Text(0, C);
]

Yorick[edit]

var1 = "Hello";
var2 = var1 + ", world!";
write, var1;
write, var2;

zkl[edit]

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

https://en.wikipedia.org/wiki/Comparison_of_programming_languages_%28string_functions%29#Concatenation