String concatenation

Create a string variable equal to any text value.

Task

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.

Other tasks related to string operations:

Metrics

Counting

Remove/replace

Anagrams/Derangements/shuffling

Find/Search/Determine

Formatting

Song lyrics/poems/Mad Libs/phrases

Tokenize

Sequences

11l

Translation of: Python

V s1 = ‘hello’ print(s1‘ world’) V s2 = s1‘ world’ print(s2)

Output:

hello world hello world

AArch64 Assembly

Works with: as version Raspberry Pi 3B version Buster 64 bits

/* 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

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

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

ArkScript

Works with: ArkScript version 4.0.0

(let s "hello") (print (+ s " world!")) (let w " there") (let v (+ s w)) (print v)

Output:

hello world! hello there

ARM Assembly

Works with: as version Raspberry Pi

/* 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

Works with: QBasic version 1.1

Works with: QuickBasic version 4.5

Works with: BASIC256

Works with: Liberty BASIC

Works with: QB64

Works with: Run Basic

Works with: Yabasic

s$ = "hello" print s$ + " literal" s2$ = s$ + " literal" print s$ print s2$

Output:

hello literal hello hello literal

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

Works with: Liberty BASIC

s1$ = "Hello" print s1$; " World!" print s1$ + " World!" s2$ = s1$; " World!" print s2$ s2$ = s1$ + " World!" print s2$

True BASIC

Works with: BASIC256

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

Works with: Liberty BASIC

Works with: QB64

Works with: QBasic

Works with: Run BASIC

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); }

Library: Gadget

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); }

Dart

main() { var s1 = 'hello'; var s2 = ' world'; print(s1 + s2); }

Output:

hello world

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.

DuckDB

Works with: DuckDB version V1.1

The 'SET VARIABLE' statement was introduced in DuckDB V1.1, so the following transcript of an interactive session with DuckDB begins with that. In practice, however, columns are typically used as variables, so the second example illustrates that as well.

The 'D ' signifies the prompt.

D .mode list D .header off D set variable s='Hello'; D select getvariable('s') || ', ducks!'; Hello, ducks! D select concat from (select 'Duck' as s, s || ' and run.' as concat); Duck and run.

DWScript

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

Dyalect

Translation of: Swift

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#

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

"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

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

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

Works with: Godot version 4.0.1

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

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

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:

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" console.log(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.

[1]

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

Works with: min version 0.19.3

"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 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");

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

Library: Phix/basics

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

Pluto

a = "Hello " b = a.."world!" print(b)

Output:

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

Prolog

In Prolog, strings can be one of several representations. Two of the ISO standard representations are codes where strings are a list of numerical codepoints, and chars where strings are a list of single character atoms. In these representations, the ISO predicate append/3 which appends two lists can be used to join strings.

ISO Prolog lacks a standard predicate for printing a string, so we must define println/1 for a portable way to print a string. Most Prolog implementations will already have a convenient way to print strings defined, format/2 is a common one.

:- set_prolog_flag(double_quotes, chars). println([]) :- write('\n'). println([Char | Chars]) :- write(Char), println(Chars). :- S0 = "Hello, ", S1 = "world!", append(S0, S1, S), println(S).

Output:

Hello, world!

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 VisualBasic'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)

Works with: Rakudo version #22 "Thousand Oaks"

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"] ; Or: print s2: join s " literal" ; Or: print s3: ajoin [s " literal"]

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

RISC-V Assembly

for Raspberry pi pico 2 see instructions to page risc v

# riscv assembly raspberry pico2 rp2350 # program concatstring.s # connexion putty com3 /*********************************************/ /* CONSTANTES */ /********************************************/ /* for this file see risc-v task include a file */ .include "../../constantesRiscv.inc" .equ BUFFERSIZE, 255 /*******************************************/ /* INITIALED DATAS */ /*******************************************/ .data szMessStart: .asciz "Program riscv start.\r\n" szMessEndOk: .asciz "Program riscv end OK.\r\n" szCariageReturn: .asciz "\r\n" szMessFinal: .asciz "The final string is \n" szString1: .asciz "Hello " szString2: .asciz " the world. \n" szMessErrorSize: .asciz "Error : size final string too small\n" .align 2 /*******************************************/ /* UNINITIALED DATA */ /*******************************************/ .bss szFinalString: .skip BUFFERSIZE .align 2 /**********************************************/ /* SECTION CODE */ /**********************************************/ .text .global main main: call stdio_init_all # général init 1: # start loop connexion li a0,0 # raz argument register call tud_cdc_n_connected # waiting for USB connection beqz a0,1b # return code = zero ? la a0,szMessStart # message address call writeString # display message	la a0,szString1 # adresse string 1	la a1,szString2 # adresse string 2	la a2,szFinalString # adresse string final	li a3,BUFFERSIZE # size area string final call concatString # concat string	li t0,-1 beq a0,t0,100f # error ?	la a0,szMessFinal # message address call writeString # display message	la a0,szFinalString call writeString # display message	la a0,szCariageReturn # message address call writeString # display message la a0,szMessEndOk # message address call writeString # display message call getchar 100: # final loop j 100b /*********************************************/ /* add string to string */ /*********************************************/ /* a0 contains address String 1 */ /* a1 contains address String 2 */ /* a2 contains address String final */ /* a3 contains string final size */ concatString: addi sp, sp, -4 sw ra, 0(sp)	li t0,0 # counter byte string 1 1: add t1,a0,t0 lbu t2,(t1) # load byte string 1	add t1,a2,t0	sb t2,(t1) # store byte final string	beqz t2,2f # zero final ?	addi t0,t0,1 # no -> increment counter	bge t0,a3,99f # size maxi ?	j 1b # loop 2: li t3, 0 # counter byte string 2 3: add t4,a1,t3 lbu t5,(t4) # load byte string 2	add t1,a2,t0	sb t5,(t1) # store byte string final beqz t5,100f # zero final ? -> end	addi t3,t3,1 # increment counter	addi t0,t0,1	bge t0,a3,99f # size maxi ?	j 3b # end loop 99: la a0,szMessErrorSize	call writeString	li a0,-1 # return error 100: lw ra, 0(sp) addi sp, sp, 4 ret /************************************/ /* file include Fonctions */ /***********************************/ /* for this file see risc-v task include a file */ .include "../../includeFunctions.s"

Program riscv start. The final string is Hello the world. Program riscv end OK.

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 ≫

Works with: Halcyon Calc version 4.2.7

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!

TAV

The underscore is the string catenation (double underscore with a blank), and numbers are converted to standard format. Assignment '=_' appends the right hand side

 x =: 'a' print x _ 'b' print x __ 'b' x =_ '+' print x print 'a=' _ 14 print 'b=' _ 1.23e2

Output:

ab a b a+ a=14 b=123.0

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

Note: the concat command will create a string that is a list of two words.

set s "Hello" set w "World" set hw "$s $w"  ; # "hello world" set hw [concat $s $w]  ; # {hello world}, same as above set hw [string cat $s $w]  ; # "helloworld" set hw [join [list $s $w] " "] ; # "hello world" \w space delimiter

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

Works with: Uiua version 0.11.1

A ← "Hello " B ← ⊂ A "world" B

Output:

"Hello world"

UNIX Shell

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

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

|18 @Console/write |0100 @on-reset ( -> ) ;str3 ;str1 copy-str ;str3 ;str2 append-str ;str3 print-str BRK @print-str_ ( str* -: ) LDAk .Console/write DEO INC2 @print-str LDAk ?print-str_ POP2 JMP2r @append-str ( dest* src* -: ) STH2 end-str STH2r ( >> ) @copy-str ( dest* src* -: ) STH2 &loop ( -- ) LDAkr STH2k STAr INC2 LDAkr STHr INC2r ?&loop POP2 POP2r JMP2r @end-str_ ( str* -: str* ) INC2 @end-str LDAk ?end-str_ JMP2r @str1 "Uxn 00 @str2 "tal 0a00 @str3

Output:

Uxntal

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 with: Visual Basic version VB6 Standard

works the same as in VBA, see String_concatenation#VBA

Visual Basic .NET

Platform: .NET

Works with: Visual Basic .NET version 9.0+

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#Concatenation

Zoea

program: string_concat input: ['hello', 'literal'] output: 'hello literal'

Zoea Visual

String concatenation