String concatenation
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
You are encouraged to solve this task according to the task description, using any language you may know.
- Task
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
- Counting
- Word frequency
- Letter frequency
- Jewels and stones
- I before E except after C
- Bioinformatics/base count
- Count occurrences of a substring
- Count how many vowels and consonants occur in a string
- Remove/replace
- XXXX redacted
- Conjugate a Latin verb
- Remove vowels from a string
- String interpolation (included)
- Strip block comments
- Strip comments from a string
- Strip a set of characters from a string
- Strip whitespace from a string -- top and tail
- Strip control codes and extended characters from a string
- Anagrams/Derangements/shuffling
- Word wheel
- ABC problem
- Sattolo cycle
- Knuth shuffle
- Ordered words
- Superpermutation minimisation
- Textonyms (using a phone text pad)
- Anagrams
- Anagrams/Deranged anagrams
- Permutations/Derangements
- Find/Search/Determine
- ABC words
- Odd words
- Word ladder
- Semordnilap
- Word search
- Wordiff (game)
- String matching
- Tea cup rim text
- Alternade words
- Changeable words
- State name puzzle
- String comparison
- Unique characters
- Unique characters in each string
- Extract file extension
- Levenshtein distance
- Palindrome detection
- Common list elements
- Longest common suffix
- Longest common prefix
- Compare a list of strings
- Longest common substring
- Find common directory path
- Words from neighbour ones
- Change e letters to i in words
- Non-continuous subsequences
- Longest common subsequence
- Longest palindromic substrings
- Longest increasing subsequence
- Words containing "the" substring
- Sum of the digits of n is substring of n
- Determine if a string is numeric
- Determine if a string is collapsible
- Determine if a string is squeezable
- Determine if a string has all unique characters
- Determine if a string has all the same characters
- Longest substrings without repeating characters
- Find words which contains all the vowels
- Find words which contain the most consonants
- Find words which contains more than 3 vowels
- Find words whose first and last three letters are equal
- Find words with alternating vowels and consonants
- Formatting
- Substring
- Rep-string
- Word wrap
- String case
- Align columns
- Literals/String
- Repeat a string
- Brace expansion
- Brace expansion using ranges
- Reverse a string
- Phrase reversals
- Comma quibbling
- Special characters
- String concatenation
- Substring/Top and tail
- Commatizing numbers
- Reverse words in a string
- Suffixation of decimal numbers
- Long literals, with continuations
- Numerical and alphabetical suffixes
- Abbreviations, easy
- Abbreviations, simple
- Abbreviations, automatic
- Song lyrics/poems/Mad Libs/phrases
- Mad Libs
- Magic 8-ball
- 99 bottles of beer
- The Name Game (a song)
- The Old lady swallowed a fly
- The Twelve Days of Christmas
- Tokenize
- Text between
- Tokenize a string
- Word break problem
- Tokenize a string with escaping
- Split a character string based on change of character
- Sequences
11l
V s1 = ‘hello’
print(s1‘ world’)
V s2 = s1‘ world’
print(s2)
- Output:
hello world hello world
AArch64 Assembly
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program concatStr64.s */
/*******************************************/
/* Constantes file */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
/*******************************************/
/* Initialized data */
/*******************************************/
.data
szMessFinal: .asciz "The final string is \n"
szString: .asciz "Hello "
szString1: .asciz " the world. \n"
/*******************************************/
/* UnInitialized data */
/*******************************************/
.bss
szFinalString: .skip 255
/*******************************************/
/* code section */
/*******************************************/
.text
.global main
main:
// load string
ldr x1,qAdrszString
ldr x2,qAdrszFinalString
mov x4,0
1:
ldrb w0,[x1,x4] // load byte of string
strb w0,[x2,x4]
cmp x0,0 // compar with zero ?
add x3,x4,1
csel x4,x3,x4,ne // if x0 <> 0 x4 = x4 +1 sinon x4
bne 1b
ldr x1,qAdrszString1
mov x3,0
2:
ldrb w0,[x1,x3] // load byte of string 1
strb w0,[x2,x4]
cmp x0,0 // compar with zero ?
add x5,x4,1
csel x4,x5,x4,ne
add x5,x3,1
csel x3,x5,x3,ne
bne 2b
mov x0,x2 // display final string
bl affichageMess
100: // standard end of the program */
mov x0,0 // return code
mov x8,EXIT // request to exit program
svc 0 // perform the system call
qAdrszString: .quad szString
qAdrszString1: .quad szString1
qAdrszFinalString: .quad szFinalString
qAdrszMessFinal: .quad szMessFinal
/********************************************************/
/* File Include fonctions */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
- Output:
Hello the world.
ABAP
DATA: s1 TYPE string,
s2 TYPE string.
s1 = 'Hello'.
CONCATENATE s1 ' literal' INTO s2 RESPECTING BLANKS.
WRITE: / s1.
WRITE: / s2.
- Output:
Hello Hello literal
Another way
REPORT string_concatenation.
DATA(var1) = 'Hello'.
DATA(var2) = 'Literal'.
cl_demo_output=>new(
)->begin_section( 'String concatenation using |{ }|'
)->write( 'Statement: |{ var1 } { var2 }|'
)->write( |{ var1 } { var2 }|
)->begin_section( 'String concatenation with new string'
)->write( 'Statement: |{ var1 } world!|'
)->write( |{ var1 } world!|
)->display( ).
- Output:
Hello literal Hello world!
Action!
PROC Append(CHAR ARRAY text,suffix)
BYTE POINTER srcPtr,dstPtr
BYTE len
len=suffix(0)
IF text(0)+len>255 THEN
len=255-text(0)
FI
IF len THEN
srcPtr=suffix+1
dstPtr=text+text(0)+1
MoveBlock(dstPtr,srcPtr,len)
text(0)==+suffix(0)
FI
RETURN
PROC Concatenate(CHAR ARRAY text,left,right)
SCopy(text,left)
Append(text,right)
RETURN
PROC TestConcatenate(CHAR ARRAY left,right)
CHAR ARRAY text(256)
Concatenate(text,left,right)
PrintF("""%S""+""%S""=""%S""%E",left,right,text)
RETURN
PROC Main()
TestConcatenate("Hello", " World!")
RETURN
- Output:
Screenshot from Atari 8-bit computer
"Hello"+" World!"="Hello World!"
ActionScript
package
{
public class Str
{
public static function main():void
{
var s:String = "hello";
trace(s + " literal");
var s2:String = s + " literal";
trace(s2);
}
}
}
Ada
with Ada.Text_IO; use Ada.Text_IO;
procedure String_Concatenation is
S1 : constant String := "Hello";
S2 : constant String := S1 & " literal";
begin
Put_Line (S1);
Put_Line (S2);
end String_Concatenation;
- Sample output:
Hello Hello literal
Aime
text s, v;
s = "Hello";
o_(s, "\n");
v = s + ", World!";
o_(v, "\n");
- Output:
Hello Hello, World!
ALGOL 68
STRING s := "hello";
print ((s + " literal", new line));
STRING s1 := s + " literal";
print ((s1, new line))
- Output:
hello literal hello literal
ALGOL-M
begin
comment
The string concatenation operator is ||, and the
default string length is 10 characters unless a
longer length (up to 255) is explicitly declared;
string(20) s1, s2;
s1 := "Hello";
write (s1 || ", world");
s2 := s1 || ", world";
write (s2);
end
- Output:
Hello, world Hello, world
Apex
String s1 = 'Hello ';
String s2 = 'Salesforce Developer!';
String s3 = s1+s2;
// Print output
System.debug(s3);
- Output:
Hello Salesforce Developer!
AppleScript
try
set endMsg to "world!"
set totMsg to "Hello, " & endMsg
display dialog totMsg
end try
ARM Assembly
/* ARM assembly Raspberry PI */
/* program strConcat.s */
/* Constantes */
.equ STDOUT, 1 @ Linux output console
.equ EXIT, 1 @ Linux syscall
.equ WRITE, 4 @ Linux syscall
/* Initialized data */
.data
szMessFinal: .asciz "The final string is \n"
szString: .asciz "Hello "
szString1: .asciz " the world. \n"
/* UnInitialized data */
.bss
szFinalString: .skip 255
/* code section */
.text
.global main
main:
@ load string
ldr r1,iAdrszString
ldr r2,iAdrszFinalString
mov r4,#0
1:
ldrb r0,[r1,r4] @ load byte of string
strb r0,[r2,r4]
cmp r0,#0 @ compar with zero ?
addne r4,#1
bne 1b
ldr r1,iAdrszString1
mov r3,#0
2:
ldrb r0,[r1,r3] @ load byte of string 1
strb r0,[r2,r4]
cmp r0,#0 @ compar with zero ?
addne r4,#1
addne r3,#1
bne 2b
mov r0,r2 @ display final string
bl affichageMess
100: @ standard end of the program */
mov r0, #0 @ return code
mov r7, #EXIT @ request to exit program
svc 0 @ perform the system call
iAdrszString: .int szString
iAdrszString1: .int szString1
iAdrszFinalString: .int szFinalString
iAdrszMessFinal: .int szMessFinal
/******************************************************************/
/* display text with size calculation */
/******************************************************************/
/* r0 contains the address of the message */
affichageMess:
push {r0,r1,r2,r7,lr} @ save registers
mov r2,#0 @ counter length */
1: @ loop length calculation
ldrb r1,[r0,r2] @ read octet start position + index
cmp r1,#0 @ if 0 its over
addne r2,r2,#1 @ else add 1 in the length
bne 1b @ and loop
@ so here r2 contains the length of the message
mov r1,r0 @ address message in r1
mov r0,#STDOUT @ code to write to the standard output Linux
mov r7, #WRITE @ code call system "write"
svc #0 @ call systeme
pop {r0,r1,r2,r7,lr} @ restaur des 2 registres
bx lr @ return
Arturo
str1: "Hello "
str2: "World"
print str1 ++ str2 ++ "!"
- Output:
Hello World!
Asymptote
string s1 = "Hello";
write(s1 + " World!");
write(s1, " World!");
string s2 = s1 + " World!";
write(s2);
AutoHotkey
s := "hello"
Msgbox, %s%
s1 := s . " literal" ;the . is optional
Msgbox, %s1%
AWK
The AWK concatenation operator is nothing.
BEGIN {
s = "hello"
print s " literal"
s1 = s " literal"
print s1
}
Axe
Lbl CONCAT
Copy(r₁,L₁,length(r₁))
Copy(r₂,L₁+length(r₁),length(r₂)+1)
L₁
Return
BASIC
s$ = "hello"
print s$ + " literal"
s2$ = s$ + " literal"
print s$
print s2$
- Output:
hello literal hello hello literal
Applesoft BASIC
A semicolon (;) is not the same as a concatenate operator (+), it is an instruction that works only on the PRINT
statement to suppress newlines at the end of a literal or series of literals. For example, the instruction S$="HELLO";"LITERAL"
would result in a syntax error.
10 S$ = "HELLO"
20 PRINT S$ + " LITERAL"
30 PRINT S$
40 S2$ = S$ + " LITERAL"
50 PRINT S2$
- Output:
HELLO LITERAL HELLO HELLO LITERAL
BaCon
A$ = "hello"
PRINT A$," World"
A2$ = A$ & " using & to concat World"
PRINT A2$
BBC BASIC
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!"
IS-BASIC
100 LET S$="Hello"
110 LET S$=S$&" world!"
120 PRINT S$
BASIC256
s1$ = "Hello"
print s1$; " World!"
print s1$ + " World!"
print s1$ & " World!"
s2$ = s1$; " World!"
print s2$
s2$ = s1$ + " World!"
print s2$
s2$ = s1$ & " World!"
print s2$
Run BASIC
s1$ = "Hello"
print s1$; " World!"
print s1$ + " World!"
s2$ = s1$; " World!"
print s2$
s2$ = s1$ + " World!"
print s2$
True BASIC
LET s1$ = "Hello"
PRINT s1$; " World!"
PRINT s1$ + " World!"
LET s2$ = s1$ & " World!"
PRINT s2$
END
uBasic/4tH
s = Dup("Hello")
Print Show(s); " World!"
Print Show(Join(s, " World!"))
t = Join(s, " World!")
Print Show(t)
End
Yabasic
s1$ = "Hello"
print s1$, " World!"
print s1$ + " World!"
s2$ = s1$ + " World!"
print s2$
ZX Spectrum Basic
10 LET s$="Hello"
20 LET s$=s$+" World!"
30 PRINT s$
Batch File
set string=Hello
echo %string% World
set string2=%string% World
echo %string2%
Beef
using System;
namespace StringConcatenation
{
class Program {
static void Main() {
String s = scope ("hello");
Console.Write(s);
Console.WriteLine(" literal");
s.Append(" literal");
Console.WriteLine(s);
}
}
}
BQN
∾
(Join) will concatenate two strings together.
str ← "Hello "
newstr ← str ∾ "world"
•Show newstr
"Hello world"
Bracmat
"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
blsq ) "Hello, ""world!"?+
"Hello, world!"
C
#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);
}
Version Gadget library for Ansi C:
#include <gadget/gadget.h>
LIB_GADGET_START
Main
String v="Mensaje lanzado al mar", w=Space(100);
Stack{
Store ( w, Pad_c( Multi_cat(w, Upper( Str_tran_all(v,"lanzado","tirado",1)),\
" adentro de una botella", NULL ), '-', 70 ));
}
puts(w);
Free secure v, w;
End
- Output:
$ ./tests/concat -------------MENSAJE TIRADO AL MAR adentro de una botella-------------
C#
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);
}
}
C++
#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
ChucK
"Hello" => string A;
A + " World!" => string B;
<<< B >>>;
- Output:
"Hello World!"
Clojure
(def a-str "abcd")
(println (str a-str "efgh"))
(def a-new-str (str a-str "efgh"))
(println a-new-str)
COBOL
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
(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
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
import std.stdio;
void main() {
string s = "hello";
writeln(s ~ " world");
auto s2 = s ~ " world";
writeln(s2);
}
DCL
$ string1 = "hello"
$ string2 = string1 + " world"
$ show symbol string*
- Output:
STRING1 = "hello" STRING2 = "hello world"
Delphi
program Concat;
{$APPTYPE CONSOLE}
var
s1, s2: string;
begin
s1 := 'Hello';
s2 := s1 + ' literal';
WriteLn(s1);
WriteLn(s2);
end.
DWScript
var s1 := 'Hello';
var s2 := s1 + ' World';
PrintLn(s1);
PrintLn(s2);
Dyalect
var s = "hello"
print(s + " literal")
var s1 = s + " literal"
print(s1)
Dylan.NET
//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
Déjà Vu
local :s1 "hello"
local :s2 concat( s1 ", world" )
!print s2
- Output:
hello, world
EasyLang
a$ = "hello"
b$ = a$ & " world"
print b$
Ecstasy
module StringAppend {
void run() {
String start = "hello";
String finish = " world";
// approach #1: add strings together
String approach1 = start + finish;
// approach #2: StringBuffer
String approach2 = new StringBuffer()
.append(start)
.append(finish)
.toString();
// approach #3: string template
String approach3 = $"{start}{finish}";
@Inject Console console;
console.print($|
|Appending strings:
|
| {start=}
| {finish=}
|
| {approach1=}
| {approach2=}
| {approach3=}
|
);
}
}
- Output:
x$ xec doc/examples/StringAppend Appending strings: start=hello finish= world approach1=hello world approach2=hello world approach3=hello world
ed
Join two strings as lines. That's it.
# by Artyom Bologov
a
Hello
World!
.
,jp
Q
- Output:
$ ed -s < concat.ed HelloWorld!
Ela
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
ELENA 6.x:
public program()
{
var s := "Hello";
var s2 := s + " literal";
console.writeLine(s);
console.writeLine(s2);
console.readChar()
}
- Output:
Hello Hello literal
EMal
text s = "hello"
write(s)
writeLine(" literal")
text s2 = s + " literal"
writeLine(s2)
- Output:
hello literal hello literal
Elixir
s = "hello"
t = s <> " literal"
IO.puts s
IO.puts t
- Output:
hello hello literal
Emacs Lisp
(defvar foo "foo")
(defvar foobar (concat foo "bar"))
(message "%sbar" foo)
(message "%s" foobar)
- Output:
foobar foobar
Erlang
S = "hello",
S1 = S ++ " literal",
io:format ("~s literal~n",[S]),
io:format ("~s~n",[S1])
- Sample output:
hello literal hello literal
ERRE
..........
S$="HELLO"
PRINT(S$;" LITERAL") ! or S$+" LITERAL"
S2$=S$+" LITERAL"
PRINT(S2$)
..........
Euphoria
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
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#
open System
[<EntryPoint>]
let main args =
let s = "hello"
Console.Write(s)
Console.WriteLine(" literal")
let s2 = s + " literal"
Console.WriteLine(s2)
0
Factor
"wake up" [ " sheeple" append print ] [ ", you sheep" append ] bi print
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 */
s = "critical"
> s + " literal"
s2 = s + " literal"
> s2
- Output:
critical literal critical literal [Finished in 0.2s]
Fantom
Illustrating in fansh:
fansh> a := "abc"
abc
fansh> b := a + "def"
abcdef
fansh> a
abc
fansh> b
abcdef
/* gary chike 08/27/2023 */
class Main
{
static Void main() {
s1 := "Only The"
s2 := "knows"
s3 := s1 + " Fantom " + s2 + "!" // Concatenation
echo(s3)
s4 := "$s1 Fantom $s2!" // String interpolation
echo(s4)
}
}
- Output:
Only The Fantom knows! Only The Fantom knows!
Fe
pack is not a built-in function, see its definition here.
(print (pack '("Hello" " world!")))
Forth
s" hello" pad place
pad count type
s" there!" pad +place \ +place is called "append" on some Forths
pad count type
Fortran
program StringConcatenation
integer, parameter :: maxstringlength = 64
character (maxstringlength) :: s1, s = "hello"
print *,s // " literal"
s1 = trim(s) // " literal"
print *,s1
end program
FreeBASIC
' FB 1.05.0 Win64
Var s1 = "String"
Var s2 = s1 + " concatenation"
Print s1
Print s2
Sleep
- Output:
String String concatenation
Frink
a = "Frink"
b = a + " rules!"
println[b]
FutureBasic
Option 1
window 1
CFStringRef s1, s2
s1 = @"any text value "
print s1
s2 = fn StringByAppendingString( s1, @"another string literal" )
print s2
HandleEvents
Option 2
void local fn StringConcatentation
CFStringRef s1 = @"alpha "
print s1
CFStringRef s2 = concat(s1,@"bravo")
print s2
end fn
fn StringConcatentation
HandleEvents
- Output:
alpha alpha bravo
Gambas
In gambas, the ampersand symbol is used as a concatenation operator:
Click this link to run this code
Public sub main()
DIM bestclub AS String
DIM myconcat AS String
bestclub = "Liverpool"
myconcat = bestclub & " Football Club"
Print myconcat
End
GDScript
extends MainLoop
func _process(_delta: float) -> bool:
var first: String = "123"
var second: String = first + "abc"
print(first)
print(second)
return true # Exit
GlovePIE
var.text1="Hello, "
debug=var.text1+"world!"
Go
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
"Greetings ":s;
s"Earthlings"+puts
s"Earthlings"+:s1;
s1 puts
Groovy
def s = "Greetings "
println s + "Earthlings"
def s1 = s + "Earthlings"
println s1
- Output:
Greetings Earthlings Greetings Earthlings
Halon
The dot (concatenation) operator may cast datatypes to strings.
echo "Hello" . "World " . 123;
Haskell
import System.IO
s = "hello"
s1 = s ++ " literal"
main = do putStrLn (s ++ " literal")
putStrLn s1
HicEst
CHARACTER s = "hello", sl*100
WRITE() s // " literal"
sl = s // " literal"
WRITE() sl
Icon and Unicon
IDL
s1='Hello'
print, s1 + ' literal'
s2=s1 + ' literal'
print, s2
J
s1 =. 'Some '
]s1, 'text '
Some text
]s2 =. s1 , 'more text!'
Some more text!
For more info see:
- http://www.jsoftware.com/help/dictionary/d320.htm on
,
- http://www.jsoftware.com/help/dictionary/d500.htm on
]
Java
There are multiple ways to concatenate string values in Java.
The most common way is through the plus operator.
String string = "abc" + "def";
Which can also be written as
String string = "abc";
string += "def";
There is also the String.concat method
String string = "abc".concat("def");
You could use a StringBuilder object if you're appending multiple strings.
StringBuilder string = new StringBuilder();
string.append("abc").append("def");
StringBuilder also conveniently lets you insert strings within strings.
So, you can also concatenate a string as follows
StringBuilder string = new StringBuilder();
string.append("abc");
string.insert(3, "def");
A less common approach would be to use the String.format or String.formatted methods.
String string = String.format("%s%s", "abc", "def");
String string = "%s%s".formatted("abc", "def");
All of these methods will produce the following string
abcdef
Alternately
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
var s = "hello"
print(s + " there!")
Joy
"title:" " text" concat.
- Output:
"title: text"
jq
"hello" as $s | $s + " there!"
- Output:
# Use the -r command-line option if you wish # to suppress the string quotation marks hello there!
Julia
s = "hello"
println(s * " there!")
K
Translation of J code:
s1: "Some "
s1, "text "
s2: s1 , "more text!"
- Output:
"Some " "Some text" "Some more text!"
Komodo
let s := "hello"
println(s + " world")
let ss := s + " world"
println(ss)
Kotlin
fun main() {
val s1 = "James"
val s2 = "Bond"
println(s1)
println(s2)
val s3 = s1 + " " + s2
println(s3)
}
- Output:
James Bond James Bond
LabVIEW
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.
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
{def name de Jeumont-Schneidre}
-> name
{christian_name} {name}
-> Albert de Jeumont-Schneidre
Lang
$s1 = hello
$s2 = \sworld
fn.println($s1 world)
# Output: hello world
fn.println($s1$s2)
# Output: hello world
fn.println(fn.concat($s1, $s2))
# Output: hello world
fn.println(parser.op($s1 ||| $s2))
# Output: hello world
fn.println(fn.add($s1, $s2))
# Output: hello world
fn.println(parser.op($s1 + $s2))
# Output: hello world
Lang5
: concat 2 compress "" join ;
'hello " literal" concat
Lasso
local(x = 'Hello')
local(y = #x + ', World!')
#x // Hello
#y // Hello, World!
Liberty BASIC
See BASIC.
Lingo
a = "Hello"
b = a & " world!"
put b
-- "Hello world!"
Lisaac
Section Header
+ name := STRING_CONCATENATION;
Section Public
- main <- (
+ sc : STRING_CONSTANT;
+ sv : STRING;
sc := "Hello";
(sc + " literal").println;
sv := sc + " literal";
sv.println;
);
LiveCode
local str="live"
put str & "code" into str2
put str && str2
Output
live livecode
Logo
make "s "hello
print word :s "| there!|
Lua
a = "hello "
print(a .. "world")
c = a .. "world"
print(c)
M2000 Interpreter
M2000 Environment is an application written in Visual Basic 6, so can use strings UTF16LE (max 2GByte), and Ansi strings. So here is an example which add two Ansi strings. To print them to console we have to convert to UTF16LE. We can use ansi strings for files and for buffers (memory blocks). Conversion use Locale (so Locale 1032 can be used for Greek Ansi codepage)
A memory word is two bytes.
Module CheckString {
s$ = "hello"
PRINT s$;" literal" 'or s$ + " literal"
s2$ = s$ + " literal"
PRINT s2$
Print Len(s2$)=13
\\ get an ansi string
k$=Str$("Hello")
Print Len(k$)=2.5 ' 2.5 words or 5 bytes
Print Chr$(k$)
k2$=k$+Str$(" literal")
Print Len(k2$)=6.5 ' 13 bytes
Print Chr$(k2$)
Print Len(Chr$(k2$))=13 ' words
}
CheckString
M4
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
Maple
str := "Hello":
newstr := cat(str,", world!"):
str;
newstr;
- Output:
"Hello" "Hello, world!"
Mathcad
Uses Mathcad's built-in concat function to join the contents of a (string) variable to a string literal. Both equations and text are typed directly onto, and evaluated on, a Mathcad worksheet.
Define (:=) and display (=) the (string) variable Carpenter
Carpenter := "Gort. " (Carpenter = "Gort. ")
Define (:=) and display (=) the (string) variable Helen concatenated with a string literal.
Helen := concat(Carpenter,"Klaatu barada nikto." Helen = "Gort. Klaatu barada nikto."
Mathematica /Wolfram Language
str= "Hello ";
str<>"Literal"
MATLAB / Octave
>> string1 = '1 Fish'
string1 =
1 Fish
>> string2 = [string1 ', 2 Fish, Red Fish, Blue Fish']
string2 =
1 Fish, 2 Fish, Red Fish, Blue Fish
Maxima
s: "the quick brown fox";
t: "jumps over the lazy dog";
sconcat(s, " ", t);
/* "the quick brown fox jumps over the lazy dog" */
MAXScript
s = "hello"
print (s + " literal")
s1 = s + " literal"
print s1
Mercury
:- 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).
Metafont
string a, b;
a := "String";
message a & " literal";
b := a & " literal";
message b;
min
"butter" :a
(a "scotch")=> "" join :b
a puts!
b puts!
- Output:
butter butterscotch
MiniScript
s = "hello"
print s + " world!"
- Output:
hello world!
MIPS Assembly
Using the following implementation of C's strcpy()
, 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.
main:
la $a0,String1
la $a1,UserRam
jal strcpy
nop
la $a0,String2
jal strcpy
nop
la $a0,UserRam
jal PrintString
nop
shutdown:
nop ;normally not needed, but Project 64 will throw an exception if I don't have a nop here.
b shutdown ;loop forever
nop
strcpy:
LBU t0,(a0)
nop
beqz t0,strcpy_done
SB t0,(a1) ;branch delay slot - this is actually executed BEFORE the beqz!
addiu a0,a0,1
b strcpy
addiu a1,a1,1 ;branch delay slot
strcpy_done:
jr ra
nop
String1:
.ascii "abcdefghijk"
.byte 0
.align 4
String2:
.ascii "lmnopqrstuvwxyz"
.byte 0
.align 4
- Output:
abcdefghijklmnopqrstuvwxyz
Modula-3
Strings in Modula-3 are called TEXT
s. 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 TEXT
s, such as Text
.
string1 := Text.Concat(string, " literal.\n");
MUMPS
STRCAT
SET S="STRING"
WRITE !,S
SET T=S_" LITERAL"
WRITE !,T
QUIT
- Output:
CACHE>D STRCAT^ROSETTA STRING STRING LITERAL
Nanoquery
s1 = "hello"
println s1 + " world"
s2 = s1 + " world"
println s2
- Output:
hello world hello world
Neko
/**
String concatenation, in Neko
Tectonics:
nekoc string-concatenation.neko
neko string-concatenation [addon]
*/
var arg = $loader.args[0]
var addon
if arg != null addon = $string(arg)
var s = "abc"
$print("s: ", s, "\n")
var c = s + "def"
$print("c: ", c, "\n")
if arg != null {
c += addon
$print("addon: ", addon, "\n")
$print("c: ", c, "\n")
}
- Output:
prompt$ nekoc string-concatenation.neko prompt$ neko string-concatenation.n xyz s: abc c: abcdef addon: xyz c: abcdefxyz
Nemerle
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
/* 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
(let (str1 "foo")
(println str1)
(let (str2 (string str1 "bar"))
(println str2)))
Nim
Strings can be concatenated with &
.
let str = "String"
echo str & " literal."
# -> String literal.
Strings can be concatenated as arrays and joined with separating characters:
import strutils
var str = "String"
echo join([str, " literal.", "HelloWorld!"], "~~")
# -> String~~ literal.~~HelloWorld!
Strings can be combined using string formatting:
import strutils
var str = "String"
echo "$# $# $#" % [str, "literal.", "HelloWorld!"]
# -> String literal. HelloWorld!
# Alternate form providing automatic conversion of arguments to strings.
echo "$# $# $#".format(str, 123, "HelloWorld!")
# -> String 123 HelloWorld!
NS-HUBASIC
10 STRING$="HELLO"
20 STRING$=STRING$+" WORLD!"
30 PRINT STRING$
Objeck
bundle Default {
class Repeat {
function : Main(args : String[]) ~ Nil {
s := "hello";
s->PrintLine();
" literal"->PrintLine();
s->Append(" literal");
s->PrintLine();
}
}
}
Oberon-2
MODULE Concat;
IMPORT Out,Strings;
VAR
S1:ARRAY 16 OF CHAR;
S2:ARRAY 8 OF CHAR;
PS1,PS2:POINTER TO ARRAY OF CHAR;
BEGIN
(* Static *)
S1 := "Hello ";
S2 := "literal";
Strings.Append(S2, S1);
Out.String(S1); Out.Ln;
(* Dynamic *)
NEW(PS1, 16);
NEW(PS2, 8);
COPY("Hello ", PS1^);
COPY("literal", PS2^);
Strings.Append(PS2^, PS1^);
Out.String(PS1^); Out.Ln;
END Concat.
Objective-C
#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
let s = "hello"
let s1 = s ^ " literal"
let () =
print_endline (s ^ " literal");
print_endline s1
Oforth
.s show the stack :
"Hello" dup " World!" + .s
- Output:
[1] (String) Hello World! [2] (String) Hello
Openscad
a="straw";
b="berry";
c=str(a,b); /* Concatenate a and b */
echo (c);
Oz
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
s = "Hello ";
s = Str(s, "world");
\\ Alternately, this could have been:
\\ s = concat(s, "world");
print(s);
Pascal
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.
PascalABC.NET
##
var s := 'Pascal';
s := s + 'ABC' + '.NET';
Print(s);
- Output:
PascalABC.NET
Perl
my $s = 'hello';
print $s . ' literal', "\n";
my $s1 = $s . ' literal';
print $s1, "\n";
An example of destructive concatenation:
$s .= ' literal';
print $s, "\n";
Phix
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."
Phixmonti
/# Rosetta Code problem: https://rosettacode.org/wiki/String_concatenation
by Galileo, 11/2022 #/
"Hello" " world" chain print nl
"Hello" var a
"world" var b
a print nl
b print nl
a " " b chain chain print
- Output:
Hello world Hello world Hello world === Press any key to exit ===
PHL
module stringcat;
extern printf;
@Integer main [
var a = "hello";
var b = a + " literal";
printf("%s\n", b);
return 0;
]
PHP
<?php
$s = "hello";
echo $s . " literal" . "\n";
$s1 = $s . " literal";
echo $s1 . "\n";
?>
Picat
main =>
Hello = "Hello, ",
print(Hello ++ "world!" ++ "\n"),
String = Hello ++ "world!",
String := String ++ "\n",
print(String).
PicoLisp
(let Str1 "First text"
(prinl Str1 " literal")
(let Str2 (pack Str1 " literal")
(prinl Str2) ) )
Pike
string hello = "hello ";
write(hello + "world" + "\n");
string all_of_it = hello + "world";
write(all_of_it + "\n");
- Output:
hello world hello world
PL/I
declare (s, t) character (30) varying;
s = 'hello from me';
display (s || ' to you.' );
t = s || ' to you all';
display (t);
Plain English
Strings (and other values) can be concatenated to strings with then
.
To run:
Start up.
Put "hello" into a string.
Put the string then " world" into another string.
Write the string to the console.
Write the other string to the console.
Wait for the escape key.
Shut down.
- Output:
hello hello world
PowerShell
$s = "Hello"
Write-Host $s World.
# alternative, using variable expansion in strings
Write-Host "$s World."
$s2 = $s + " World."
Write-Host $s2
PureBasic
If OpenConsole()
s$ = "hello"
PrintN( s$ + " literal")
s2$ = s$ + " literal"
PrintN(s2$)
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit")
Input()
CloseConsole()
EndIf
- Output:
hello literal hello literal
This version uses the debugger versus outputting to the console. It implements 'EnableExplicit' which is similar to VisuaBasic's 'Option Explicit' which means all variables must be declared. It also features the use of string variables WITHOUT the dollar-sign suffix '$' which is common in BASIC variants to indicate the string datatype:
EnableExplicit
Define.s s1, s2, s3
s1 = "Hello "
s2 = "World"
s3 = s1 + s2
Debug s3
s3 = s3 + "!"
Debug s3
- Output:
Hello World Hello World!
Python
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
QB64
s1$ = "String"
s2$ = s1$ + " concatenation"
Print s1$
Print s2$
- Output:
String String concatenation
Quackery
$ "A duck's quack"
$ " has no echo."
join
echo$
- Output:
A duck's quack has no echo.
R
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
#lang racket
(define hello "hello")
(displayln hello)
(define world (string-append hello " " "world" "!"))
(displayln world)
;outputs:
; hello
; hello world!
Raku
(formerly Perl 6)
my $s = 'hello';
say $s ~ ' literal';
my $s1 = $s ~ ' literal';
say $s1;
# or, using mutating concatenation:
$s ~= ' literal';
say $s;
Note also that most concatenation in Raku is done implicitly via interpolation.
Raven
# 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
s: "hello"
print s1: rejoin [s " literal"]
print s1
Red
>>str1: "Hello"
>>str2: append str1 " World"
>> print str2
Hello World
>> print str1
Hello World
ReScript
let s1 = "hello"
let s2 = s1 ++ " literal"
Js.log(s1)
Js.log(s2)
- Output:
$ bsc sc.res > sc.js $ node sc.js hello hello literal
Retro
'hello_ 'literal s:append s:put
REXX
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 double-pipe does not cause spaces.*/
Ring
aString = "Welcome to the "
bString = "Ring Programming Language"
see astring + bString + nl
RPL
This example showcases the 2 types of variables offered by RPL : temporary ones declared with →
that disappear when the program ends, and persistent ones declared with the STO
(for STOre) instruction.
≪ "Hello " → string1 ≪ string1 " world" + 'string2' STO string1 string2 ≫
- Output:
2: "Hello" 1: "Hello world"
Ruby
s = "hello"
puts "#{s} template" #=> "hello template"
# Variable s is intact
puts s #=> "hello"
puts s + " literal" #=> "hello literal"
# Variable s is still the same
puts s #=> "hello"
# Mutating s variable:
s += " literal"
puts s #=> "hello literal"
s << " another" # append to s, use only when string literals are not frozen
puts s #=> "hello literal another"
s = "hello"
puts s.concat(" literal") #=> "hello literal"
puts s #=> "hello literal"
puts s.prepend("Alice said: ") #=> "Alice said: hello literal"
puts s #=> "Alice said: hello literal"
Rust
fn main() {
let s = "hello".to_owned();
println!("{}", s);
let s1 = s + " world";
println!("{}", s1);
}
SAS
data _null_;
a="Hello,";
b="World!";
c=a !! " " !! b;
put c;
*Alternative using the catx function;
c=catx (" ", a, b);
put c;
run;
Sather
class MAIN is
main is
s ::= "hello";
#OUT + s + " literal\n";
s2 ::= s + " literal";
#OUT + s2 + "\n";
end;
end;
S-BASIC
rem - the + operator is used to concatenate strings
var s1, s2 = string
s1 = "Hello"
print s1 + ", world"
s2 = s1 + ", world"
print s2
end
- Output:
Hello, world Hello, world
Scala
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
(define s "hello")
(display (string-append s " literal"))
(newline)
(define s1 (string-append s " literal"))
(display s1)
(newline)
Scilab
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!
sed
There are no variables in sed, just two distinct locations for storing a string: The "pattern space" and the "hold space".
The pattern space contains the current input line. With the h
command, it is copied to the hold space. Then, the s
command appends a string literal to the pattern space:
h
s/$/String Literal/
If necessary, the content of both spaces could be exchanged by a final x
command.
Seed7
$ 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
var s = 'hello';
say s+' literal';
var s1 = s+' literal';
say s1;
An example of destructive concatenation:
s += ' literal';
say s;
Simula
TEXT PROCEDURE concatenate(head, tail);
TEXT head, tail;
BEGIN TEXT c;
c :- blanks(head.length + tail.length);
c.sub(c.start, head.length) := head; ! putText(), anyone?;
c.sub(c.start + head.length, tail.length) := tail;
concatenate:- c;
END;
TEXT stringVariable, another;
stringVariable :- "head ";
another :- concatenate(stringVariable, "and tail");
OutText("stringVariable: """); OutText(stringVariable);
OutText(""", another: "); OutText(another); Outimage;
Slate
define: #s -> 'hello'.
inform: s ; ' literal'.
define: #s1 -> (s ; ' literal').
inform: s1.
Slope
(define s1 "Hello")
(display (append s1 ", World!"))
- Output:
Hello, World!
Smalltalk
In Smalltalk "," (comma) is a binary message (virtual function) implemented by Collection (and therefore also understood by strings):
|s s1| s := 'hello'.
(s,' literal') printNl.
s1 := s,' literal'.
s1 printNl.
SNOBOL4
greet1 = "Hello, "
output = greet1
greet2 = greet1 "World!"
output = greet2
end
Sparkling
let s1 = "Hello";
let s2 = " world!";
print(s1 .. s2); // prints "Hello world!"
Standard ML
val s = "hello"
val s1 = s ^ " literal\n"
val () =
print (s ^ " literal\n");
print s1
Stata
Stata string scalars
sca a = "foo"
sca b = "bar"
sca c = a+b
di c
foobar
Mata
a = "foo"
b = "bar"
c = a+b
c
foobar
Swift
let s = "hello"
println(s + " literal")
let s1 = s + " literal"
println(s1)
Symsyn
| concatenate a string
'The quick brown fox ' $s
+ 'jumped over the lazy moon.' $s
$s []
- Output:
The quick brown fox jumped over the lazy moon.
Tailspin
Tailspin has no operator for concatenating strings, you simply use interpolation instead
def a: 'Hello';
'$a;, World!' -> !OUT::write
- Output:
Hello, World!
Tcl
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
"HELLO"→Str0
Str0+" WORLD!"→Str0
- Output:
HELLO WORLD!
TI-89 BASIC
"aard" → sv
Disp sv & "vark"
sv & "wolf" → sv2
TorqueScript
%string = "Hello";
echo(%string);
%other = " world!";
echo(%other);
echo(%string @ %other);
Transd
#lang transd
MainModule: {
_start: (λ locals:
s1 "concat"
s2 (+ s1 "enation")
(lout "s1: " s1)
(lout "s2: " s2)
)
}
- Output:
s1: concat s2: concatenation
TUSCRIPT
$$ MODE TUSCRIPT
s = "Hello "
print s, "literal"
s1 = CONCAT (s,"literal")
print s1
- Output:
Hello literal Hello literal
uBasic/4tH
s := "Hello"
t = Join(s, " world!")
Print Show (s), Show (t)
- Output:
Hello Hello world! 0 OK, 0:61
Uiua
A ← "Hello "
B ← ⊂ A "world"
B
- Output:
"Hello world"
UNIX Shell
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
echo "hello"
| xargs -n1 -i echo {} literal
Ursa
decl string s1 s2
# make s1 contain "hello "
set s1 "hello "
# set s2 to contain s1 and "world"
set s2 (+ s1 "world")
# outputs "hello world"
out s2 endl console
Uxntal
|10 @Console &vector $2 &read $1 &pad $4 &type $1 &write $1 &error $1
|0100 @on-reset ( -> )
;str3 ;str1 copy-str
;str3 ;str2 append-str
;str3 print-str
#0a .Console/write DEO
BRK
@print-str ( str* -: )
&loop ( -- )
LDAk .Console/write DEO
INC2 LDAk ?&loop
POP2 JMP2r
@copy-str ( dest* src* -: )
STH2
&loop ( -- )
LDAkr STH2k STAr INC2 LDAkr STHr INC2r ?&loop
POP2 POP2r JMP2r
@append-str ( dest* src* -: )
STH2 end-str STH2r copy-str JMP2r
@end-str ( str* -: str* )
!&inner
&loop ( -- )
INC2 &inner LDAk ?&loop
JMP2r
@str1 "Uxn 00
@str2 "tal 00
@str3
Vala
void main() {
var s = "hello";
print(s);
print(" literal\n");
var s2 = s + " literal\n";
print(s2);
}
VBA
Option Explicit
Sub String_Concatenation()
Dim str1 As String, str2 As String
str1 = "Rosetta"
Debug.Print str1
Debug.Print str1 & " code!"
str2 = str1 & " code..."
Debug.Print str2 & " based on concatenation of : " & str1 & " and code..."
End Sub
- Output:
Rosetta Rosetta code! Rosetta code... based on concatenation of : Rosetta and code...
VBScript
s1="Hello"
s2=s1 & " World!"
WScript.Echo s2
- Output:
Hello World!
Visual Basic
works the same as in VBA, see String_concatenation#VBA
Visual Basic .NET
Platform: .NET
s = "Hello"
Console.WriteLine(s & " literal")
s1 = s + " literal"
Console.WriteLine(s1)
V (Vlang)
s := 'hello'
println(s)
println(s+' literal')
s2:= s+ ' literal'
println(s2)
- Output:
hello hello literal hello literal
Wee Basic
let string1$="Hello "
let string2$="world!"
print 1 string1$+string2$
end
Wren
var s = "Hello, "
var t = s + "world!"
System.print(s)
System.print(t)
- Output:
Hello, Hello, world!
XPL0
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
var1 = "Hello";
var2 = var1 + ", world!";
write, var1;
write, var2;
Zig
const std = @import("std");
const debug = std.debug;
const heap = std.heap;
const mem = std.mem;
test "string concatenation" {
const hello = "Hello,";
debug.warn("\n{}{}\n", .{ hello, " world!" });
// Method 1: Array concatenation
//
// This only works if the values are known at compile-time.
const hello_world_at_comptime = hello ++ " world!";
debug.warn("{}\n", .{hello_world_at_comptime});
// Method 2: std.mem.concat
var buf: [128]u8 = undefined;
const allocator = &heap.FixedBufferAllocator.init(&buf).allocator;
const hello_world_concatenated = try mem.concat(allocator, u8, &[_][]const u8{ hello, " world!" });
debug.warn("{}\n", .{hello_world_concatenated});
// Method 3: std.mem.join
const hello_world_joined = try mem.join(allocator, " ", &[_][]const u8{ hello, "world!" });
debug.warn("{}\n", .{hello_world_joined});
}
- Output:
Test [1/1] test "string concatenation"... Hello, world! Hello, world! Hello, world! Hello, world! All 1 tests passed.
zkl
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#ConcatenationProperty "Wikipedia" (as page type) with input value "https://en.wikipedia.org/wiki/Comparison_of_programming_languages_%28string_functions%29#Concatenation" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process.
Zoea
program: string_concat
input: ['hello', 'literal']
output: 'hello literal'
Zoea Visual
- String manipulation
- Basic Data Operations
- Simple
- Programming Tasks
- Basic language learning
- 11l
- AArch64 Assembly
- ABAP
- Action!
- ActionScript
- Ada
- Aime
- ALGOL 68
- ALGOL-M
- Apex
- AppleScript
- ARM Assembly
- Arturo
- Asymptote
- AutoHotkey
- AWK
- Axe
- BASIC
- Applesoft BASIC
- BaCon
- BBC BASIC
- IS-BASIC
- BASIC256
- Run BASIC
- True BASIC
- UBasic/4tH
- Yabasic
- ZX Spectrum Basic
- Batch File
- Beef
- BQN
- Bracmat
- Burlesque
- C
- Gadget
- C sharp
- C++
- ChucK
- Clojure
- COBOL
- Common Lisp
- Component Pascal
- D
- DCL
- Delphi
- DWScript
- Dyalect
- Dylan.NET
- Déjà Vu
- EasyLang
- Ecstasy
- Ed
- Ela
- Elena
- EMal
- Elixir
- Emacs Lisp
- Erlang
- ERRE
- Euphoria
- Excel
- F Sharp
- Factor
- Falcon
- Fantom
- Fe
- Forth
- Fortran
- FreeBASIC
- Frink
- FutureBasic
- Gambas
- GDScript
- GlovePIE
- Go
- Golfscript
- Groovy
- Halon
- Haskell
- HicEst
- Icon
- Unicon
- IDL
- J
- Java
- JavaScript
- Joy
- Jq
- Julia
- K
- Komodo
- Kotlin
- LabVIEW
- Lambdatalk
- Lang
- Lang5
- Lasso
- Liberty BASIC
- Lingo
- Lisaac
- LiveCode
- Logo
- Lua
- M2000 Interpreter
- M4
- Maple
- Mathcad
- Mathematica
- Wolfram Language
- MATLAB
- Octave
- Maxima
- MAXScript
- Mercury
- Metafont
- Min
- MiniScript
- MIPS Assembly
- Modula-3
- MUMPS
- Nanoquery
- Neko
- Nemerle
- NetRexx
- NewLISP
- Nim
- NS-HUBASIC
- Objeck
- Oberon-2
- Objective-C
- OCaml
- Oforth
- Openscad
- Oz
- PARI/GP
- Pascal
- PascalABC.NET
- Perl
- Phix
- Phix/basics
- Phixmonti
- PHL
- PHP
- Picat
- PicoLisp
- Pike
- PL/I
- Plain English
- PowerShell
- PureBasic
- Python
- QB64
- Quackery
- R
- Racket
- Raku
- Raven
- REBOL
- Red
- ReScript
- Retro
- REXX
- Ring
- RPL
- Ruby
- Rust
- SAS
- Sather
- S-BASIC
- Scala
- Scheme
- Scilab
- Sed
- Seed7
- Sidef
- Simula
- Slate
- Slope
- Smalltalk
- SNOBOL4
- Sparkling
- Standard ML
- Stata
- Swift
- Symsyn
- Tailspin
- Tcl
- TI-83 BASIC
- TI-89 BASIC
- TorqueScript
- Transd
- TUSCRIPT
- Uiua
- UNIX Shell
- UnixPipes
- Ursa
- Uxntal
- Vala
- VBA
- VBScript
- Visual Basic
- Visual Basic .NET
- V (Vlang)
- Wee Basic
- Wren
- XPL0
- Yorick
- Zig
- Zkl
- Bc/Omit
- Dc/Omit
- Zoea
- Zoea Visual
- Pages with too many expensive parser function calls