String append

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

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

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

Integer Operations
Arithmetic | Comparison

Boolean Operations
Bitwise | Logical

String Operations
Concatenation | Interpolation | Comparison | Matching

Memory Operations
Pointers & references | Addresses

Most languages provide a way to concatenate two string values, but some languages also provide a convenient way to append in-place to an existing string variable without referring to the variable twice.


Task

Create a string variable equal to any text value.

Append the string variable with another string literal in the most idiomatic way, without double reference if your language supports it.

Show the contents of the variable after the append operation.

11l

Translation of: Python
V s = ‘12345678’
s ‘’= ‘9!’
print(s)
Output:
123456789!

AArch64 Assembly

Works with: as version Raspberry Pi 3B version Buster 64 bits
/* ARM assembly AARCH64 Raspberry PI 3B */
/*  program appendstr64.s   */

/*******************************************/
/* Constantes file                         */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
 
.equ BUFFERSIZE,          100
/*******************************************/
/* Initialized data                        */
/*******************************************/
.data
szMessString:            .asciz "String :\n"
szString1:              .asciz "Alphabet : "
sComplement:            .fill BUFFERSIZE,1,0
szString2:              .asciz "abcdefghijklmnopqrstuvwxyz"
 
szCarriageReturn:       .asciz "\n"
/*******************************************/
/* UnInitialized data                      */
/*******************************************/
.bss 
/*******************************************/
/*  code section                           */
/*******************************************/
.text
.global main 
main: 
 
    ldr x0,qAdrszMessString               // display message
    bl affichageMess
    ldr x0,qAdrszString1                  // display begin string
    bl affichageMess
    ldr x0,qAdrszCarriageReturn           // display return line
    bl affichageMess
    ldr x0,qAdrszString1
    ldr x1,qAdrszString2
    bl append                             // append sting2 to string1
    ldr x0,qAdrszMessString
    bl affichageMess
    ldr x0,qAdrszString1                  // display string
    bl affichageMess 
    ldr x0,qAdrszCarriageReturn
    bl affichageMess
 
100:                                      // standard end of the program
    mov x0,0                              // return code
    mov x8,EXIT                           // request to exit program
    svc 0                                 // perform system call
qAdrszMessString:         .quad szMessString
qAdrszString1:            .quad szString1
qAdrszString2:            .quad szString2
qAdrszCarriageReturn:     .quad szCarriageReturn
/**************************************************/
/*     append two strings                         */ 
/**************************************************/
/* x0 contains the address of the string1 */
/* x1 contains the address of the string2 */
append:
    stp x1,lr,[sp,-16]!            // save  registers
    mov x2,#0                      // counter byte string 1
1:
    ldrb w3,[x0,x2]                // load byte string 1
    cmp x3,#0                      // zero final ?
    add x4,x2,1
    csel x2,x4,x2,ne               // if x3 not equal 0, x2 = X2 +1 else x2
    bne 1b                         // no -> loop
    mov x4,#0                      // counter byte string 2
2:
    ldrb w3,[x1,x4]                // load byte string 2
    strb w3,[x0,x2]                // store byte string 1
    cbz x3,100f                    // zero final ?
    add x2,x2,1                    // no -> increment counter 1
    add x4,x4,1                    // no -> increment counter 2
    b 2b                           // no -> loop
100:

    ldp x1,lr,[sp],16              // restaur  2 registers
    ret                            // return to address lr x30
/********************************************************/
/*        File Include fonctions                        */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
Output:
String :
Alphabet :
String :
Alphabet : abcdefghijklmnopqrstuvwxyz

Action!

CHAR ARRAY S1,S2

Proc Main()
 S1="Hello, "
 S2="world!";
 Sassign(S1,S2,S1(0)+1)
 Print(S1)
Return
Output:
Hello, world!


Ada

with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with Ada.Text_IO.Unbounded_Io; use Ada.Text_IO.Unbounded_IO;

procedure String_Append is
   Str : Unbounded_String := To_Unbounded_String("Hello");
begin
   Append(Str, ", world!");
   Put_Line(Str);
end String_Append;
Output:
Hello, world!

ALGOL 68

Works with: ALGOL 68 version Revision 1.
Works with: ALGOL 68G version Any - tested with release algol68g-2.7.
Works with: ELLA ALGOL 68 version Any (with appropriate job cards).

File: String_append.a68

#!/usr/bin/a68g --script #
# -*- coding: utf-8 -*- #

STRING str := "12345678";
str +:= "9!";
print(str)
Output:
123456789!

Amazing Hopper

#include <jambo.h>

Main
    r="un corderito", s="María tenía", t="felpudo"
    
    Multicat ( s," ",r," ",t ),Get utf8, and print it
    
    d=0
    Let ' d := Utf8( Cat( Cat ( s, " un " ), t ) )'
    Printnl ( "\n",d )
End
Output:
María tenía un corderito felpudo
María tenía un felpudo

ARM Assembly

Works with: as version Raspberry Pi
/* ARM assembly Raspberry PI  */
/*  program appendstr.s   */

/* Constantes    */
.equ STDOUT, 1                           @ Linux output console
.equ EXIT,   1                           @ Linux syscall
.equ WRITE,  4                           @ Linux syscall

.equ BUFFERSIZE,          100

/* Initialized data */
.data
szMessString:            .asciz "String :\n"
szString1:              .asciz "Alphabet : "
sComplement:            .fill BUFFERSIZE,1,0
szString2:              .asciz "abcdefghijklmnopqrstuvwxyz"

szCarriageReturn:       .asciz "\n"

/* UnInitialized data */
.bss 

/*  code section */
.text
.global main 
main: 

    ldr r0,iAdrszMessString                     @ display message
    bl affichageMess
    ldr r0,iAdrszString1                        @ display begin string
    bl affichageMess
    ldr r0,iAdrszCarriageReturn                 @ display line return
    bl affichageMess
    ldr r0,iAdrszString1
    ldr r1,iAdrszString2
    bl append                                   @ append sting2 to string1
    ldr r0,iAdrszMessString
    bl affichageMess
    ldr r0,iAdrszString1                        @ display string
    bl affichageMess 
    ldr r0,iAdrszCarriageReturn
    bl affichageMess

100:                                            @ standard end of the program
    mov r0, #0                                  @ return code
    mov r7, #EXIT                               @ request to exit program
    svc 0                                       @ perform system call
iAdrszMessString:         .int szMessString
iAdrszString1:            .int szString1
iAdrszString2:            .int szString2
iAdrszCarriageReturn:     .int szCarriageReturn
/******************************************************************/
/*     append two strings                         */ 
/******************************************************************/
/* r0 contains the address of the string1 */
/* r1 contains the address of the string2 */
append:
    push {r0,r1,r2,r7,lr}                       @ save  registers 
    mov r2,#0                                   @ counter byte string 1
1:
    ldrb r3,[r0,r2]                             @ load byte string 1
    cmp r3,#0                                   @ zero final ?
    addne r2,#1
    bne 1b                                      @ no -> loop
    mov r4,#0                                   @ counter byte string 2
2:
    ldrb r3,[r1,r4]                             @ load byte string 2
    strb r3,[r0,r2]                             @ store byte string 1
    cmp r3,#0                                   @ zero final ?
    addne r2,#1                                 @ no -> increment counter 1
    addne r4,#1                                 @ no -> increment counter 2
    bne 2b                                      @ no -> loop
100:
    pop {r0,r1,r2,r7,lr}                        @ restaur registers
    bx lr                                       @ return

/******************************************************************/
/*     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 system
    pop {r0,r1,r2,r7,lr}                        @ restaur registers
    bx lr                                       @ return

AppleScript

set {a, b} to {"Apple", "Script"}
set a to a & b
return a as string
Output:
"AppleScript"

APL

      s'hello'
      s,'world'
helloworld

Arturo

print join ["Hello" "World"]

a: new "Hello"
'a ++ "World"
print a

b: new "Hello"
append 'b "World"
print b

c: "Hello"
print append c "World"
Output:
HelloWorld
HelloWorld
HelloWorld
HelloWorld

Asymptote

string s = "Hello";
s = s + " Wo";
s += "rld!";
write(s);

AutoHotkey

s := "Hello, "
s .= "world."
MsgBox % s
Output:
Hello, world.

Avail

Avail's normal strings are immutable, however string variables can leverage tuple's appending-assignment method, _↑++=_.

str : string := "99 bottles of ";
str ++= "beer";
Print: str;

Note that one can define methods similar to this, thanks to the variable occurrence message pattern, _↑, whose slot accepts a variable usage and then passes the variable container itself as the corresponding argument. Consider the source for the append used above:

Public method "_↑++=_" is
[
	var : read tuple/write ⊥,
	t : tuple
|
	var ?= eject var ++ t;
] : ⊤;

(eject and ?= are methods used for unassign-retrieving and assigning to a variable, respectively, only needed when dealing with the containers themselves.)

AWK

# syntax: GAWK -f STRING_APPEND.AWK
BEGIN {
    s = "foo"
    s = s "bar"
    print(s)
    exit(0)
}
Output:
foobar

Axe

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

BASIC

Applesoft BASIC

S$ = "Hello"
S$ = S$ + " World!"
PRINT S$

BaCon

A$ = "Hello"
A$ = A$ & " World!"
PRINT A$

BASIC256

a$ = "He"
a$ = a$ & "llo"
a$ = a$ + " Wo"
a$ += "rld"
a$ &= "!"
print a$

BBC BASIC

      S$="Hello"
      S$+=" World!"
      PRINT S$
      END
Output:
Hello World!

Commodore BASIC

10 S$ = "HELLO"
20 S$ = S$ + " WORLD!"
30 PRINT S$
40 END
Output:
HELLO WORLD!

Chipmunk Basic

Works with: Chipmunk Basic version 3.6.4
10 a$ = "Hello"
20 a$ = a$ + " World!"
30 print a$

GW-BASIC

Works with: PC-BASIC version any
Works with: BASICA
Works with: Applesoft Basic
Works with: Chipmunk Basic
Works with: QBasic
Works with: Quite BASIC
Works with: MSX BASIC
10 LET a$ = "Hello"
20 LET a$ = a$ + " World!"
30 PRINT a$

IS-BASIC

100 LET S$="Hello"
110 LET S$=S$&" World!"
120 PRINT S$

Liberty BASIC

a$ = "Hello"
a$ = a$ + " World"
a$ = a$ ; "!"
print a$

MSX Basic

The GW-BASIC solution works without any changes.

QBasic

Works with: Liberty BASIC
Works with: QB64
Works with: Run BASIC
Works with: Yabasic
a$ = "Hello"
a$ = a$ + " World!"
PRINT a$

Quite BASIC

The GW-BASIC solution works without any changes.

Run BASIC

Works with: Liberty BASIC
Works with: QB64
Works with: QBasic
Works with: Yabasic
a$ = "Hello"
a$ = a$ + " World!"
print a$

True BASIC

LET a$ = "Hello"
LET a$ = a$ & " World!"
PRINT a$
END

uBasic/4tH

a := "Hello"
a = Join (a, " World!")
Print Show(a)

XBasic

Works with: Windows XBasic
PROGRAM	"String append"
VERSION	"0.0000"

DECLARE FUNCTION  Entry ()

FUNCTION  Entry ()
  a$ = "Hello"
  a$ = a$ + " World!"
  PRINT a$
END FUNCTION
END PROGRAM

Yabasic

Works with: Liberty BASIC
Works with: QB64
Works with: QBasic
Works with: Run BASIC
a$ = "Hello"
a$ = a$ + " World!"
print a$


Binary Lambda Calculus

BLC program

18 16 46 80 05 bc bc fd f6 e0 69 6f 6e

based on https://github.com/tromp/AIT/blob/master/rosetta/catstrings.lam appends "ion" to "on" to output "onion".

BQN

str  "oneTwo"

•Out str  "Three"

str
Output:
oneTwoThree
"oneTwoThree"

Bracmat

str="Hello";
str$(!str " World!"):?str;
out$!str;
Output:
Hello World!

C

#include<stdio.h>
#include<string.h>

int main()
{
    char str[24]="Good Morning";
    char *cstr=" to all";
    char *cstr2=" !!!";
    int x=0;
    //failure when space allocated to str is insufficient.

    if(sizeof(str)>strlen(str)+strlen(cstr)+strlen(cstr2))
            {
                /* 1st method*/
                strcat(str,cstr);

                /*2nd method*/
                x=strlen(str);
                sprintf(&str[x],"%s",cstr2);

                printf("%s\n",str);

            }
    return 0;
}
Output:
Good Morning to all !!!

C#

class Program
{
    static void Main(string[] args)
    {
        string x = "foo";
        x += "bar";
        System.Console.WriteLine(x);
    }
}

C++

#include <iostream>
#include <string>

int main( ) {
   std::string greeting( "Hello" ) ;
   greeting.append( " , world!" ) ;
   std::cout << greeting << std::endl ;
   return 0 ;
}
Output:
Hello , world!

Clojure

Using global vars.

user=> (def s "app")
#'user/s
user=> s
"app"
user=> (def s (str s "end"))
#'user/s
user=> s
"append"

Using local bindings.

user=> (let [s "ap", s (str s "pend")] s)
"append"

COBOL

COBOL is not really a variable length field programming language. Most data items are fixed in size at compile time.

This example uses OCCURS DEPENDING ON, and reference modification to simulate a string append, all within an already maximally bounded character field. This type of programming task, while possible, is not overly common in COBOL applications.

Works with: GnuCOBOL
      identification division.                                         
       program-id. string-append.                                       

       data division.
       working-storage section.
       01 some-string.
          05 elements pic x occurs 0 to 80 times depending on limiter.
       01 limiter     usage index value 7.
       01 current     usage index.

       procedure division.
       append-main.

       move "Hello, " to some-string

      *> extend the limit and move using reference modification
       set current to length of some-string
       set limiter up by 5
       move "world" to some-string(current + 1:)
       display some-string

       goback.
       end program string-append.
Output:
$ cobc -xj string-append.cob
Hello, world

CoffeeScript

Works with: Node.js
a = "Hello, "
b = "World!"
c = a + b

console.log c

Or with concat:

console.log "Hello, ".concat "World!"
Output:
Hello, World!

Common Lisp

Similar to the Racket solution, a macro is necessary to append in-place:

(defmacro concatenatef (s &rest strs) 
  "Append additional strings to the first string in-place."
  `(setf ,s (concatenate 'string ,s ,@strs)))
(defvar *str* "foo")
(concatenatef *str* "bar")
(format T "~a~%" *str*)
(concatenatef *str* "baz" "abc" "def")
(format T "~a~%" *str*)

Output:

foobar
foobarbazabcdef

D

import std.stdio;

void main() {
    string s = "Hello";
    s ~= " world!"; 
    writeln(s);
}
Output:
Hello world!

Dart

void main() {
  String str = "Hello";
  str = str + " World!";
  print(str);
}

DBL

;Concatenate "Hello world!"
STR='Hello'
STR(%TRIM(STR)+2:5)='world'
STR(%TRIM(STR)+1:1)='!'

Delphi

program String_append;

{$APPTYPE CONSOLE}

uses
  System.SysUtils;

type
  TStringHelper = record helper for string
    procedure Append(str: string);
  end;

{ TStringHelper }

procedure TStringHelper.Append(str: string);
begin
  Self := self + str;
end;

begin
  var h: string;

  // with + operator
  h := 'Hello';
  h := h + ' World';
  writeln(h);

  // with a function concat
  h := 'Hello';
  h := Concat(h, ' World');
  writeln(h);

  // with helper
  h := 'Hello';
  h.Append(' World');
  writeln(h);
  readln;
end.
Output:
Hello World
Hello World
Hello World


Dyalect

var str = "foo"
str += str
print(str)

EasyLang

a$ = "hello"
a$ &= " world"
print a$

EchoLisp

;; Solution from Common Lisp and Racket
(define-syntax-rule (set-append! str tail) 
   (set! str (string-append str tail)))

(define name "Albert")  name

(set-append! name " de Jeumont-Schneidre")
name
    "Albert de Jeumont-Schneidre"

Elena

ELENA 6.x :

import extensions'text;

public program()
{
    var s := StringWriter.load("Hello");
    s.append(" World");
    
    console.writeLine(s).readChar()
}

Elixir

iex(60)> s = "Hello"
"Hello"
iex(61)> s <> " World!"
"Hello World!"

Emacs Lisp

While strings in Emacs Lisp are mutable, they're fixed size. Therefore the concat function creates a new string and the existing string must be referenced twice:

(defvar str "foo")
(setq str (concat str "bar"))
str ;=> "foobar"

This can be hidden by using a macro such as cl-callf which expands into the above code:

Library: cl-lib
(require 'cl-lib)

(defvar str "foo")
(cl-callf concat str "bar")
str ;=> "foobar"

Buffers can be thought of as expandable strings:

(let ((buf (get-buffer-create "*foo*")))
  (with-current-buffer buf
    (insert "foo"))
  (with-current-buffer buf
    (goto-char (point-max))
    (insert "bar")
    (buffer-string)))
;; => "foobar"

EMal

^|EMal has mutable strings;
 |the append method changes the value in-place.
 |^
text hello = "Hello, "
hello.append("world!")
writeLine(hello)
Output:
Hello, world!

Erlang

Output:
1> S = "Hello".
"Hello"
2> S ++ " world".
"Hello world"

Euphoria

sequence string = "String"

printf(1,"%s\n",{string})

string &= " is now longer\n"

printf(1,"%s",{string})
Output:
String
String is now longer

F#

Strings are immutable in .NET. To append (to the same variable) the variable has to be declared mutable.

let mutable x = "foo"
x <- x + "bar"
printfn "%s" x

Factor

"Hello, " "world!" append
Output:
"Hello, world!"

Falcon

/* Added by Aykayayciti Earl Lamont Montgomery
April 10th, 2018 */

s1, s2 = "Hello", "Foo"
> s1 + " World"
printl(s2 + " bar")
Output:
Hello World
Foo bar
[Finished in 0.2s]

Forth

\ Strings in Forth are simply named memory locations

create astring  256 allot   \ create a "string"

s" Hello " astring PLACE     \ initialize the string

s" World!" astring +PLACE   \ append with "+place"

Test at the console

  ok
s" Hello " astring place  ok
s" World!" astring +place  ok
astring count type Hello World! ok

Fortran

Using deferred length character strings:

program main

 character(len=:),allocatable :: str

 str = 'hello'
 str = str//' world'

 write(*,*) str

end program main
Output:
hello world


Using pre-allocated character strings:

program str_append
    implicit none

    character(len=20) :: str

    str= 'String'
    str(len_trim(str)+1:) = 'Append'
    print *, str

end program str_append
Output:
StringAppend

FreeBASIC

' FB 1.05.0 Win64

Var s = "String"
s += " append"
Print s 
Sleep
Output:
String append

FutureBasic

Str255 s

s = "Hello"
s += " World!"

print s

HandleEvents

Gambas

Click this link to run this code

Public Sub Main()
Dim sString As String = "Hello "

sString &= "World!"
Print sString

End

Output:

Hello World!

GDScript

Works with: Godot version 4.0.1
extends MainLoop


func _process(_delta: float) -> bool:
	var string: String = "123"
	string += "abc"
	print(string)
	return true # Exit
Output:
123abc

Genie

[indent=4]
/* String append, in Genie */
init
    str:string = "Hello"
    str += ", world"

    print str
Output:
prompt$ valac stringAppend.gs
prompt$ ./stringAppend
Hello, world

GlovePIE

var.string="This is "
var.string+="Sparta!"
debug=var.string

Go

s := "foo"
s += "bar"

String Builder

The first solution redefines the string variable every time. It might be short in code but it uses much CPU cycles. A better way is to use `string.Builder` but it is not a string. It is more like a buffer which can produce a string. And it really appends the string to the existing variable.

package main

import (
  "fmt"
  "strings"
)

func main() {
  var s strings.Builder
  s.WriteString("foo")
  s.WriteString("bar")
  fmt.Print(s.String())
}
Output:

foobar

Gosu

// Example 1
var s = "a"
s += "b"
s += "c"
print(s)

// Example 2
print("a" + "b" + "c")

// Example 3
var a = "a"
var b = "b"
var c = "c"
print("${a}${b}${c}")
Output:
abc
abc
abc

Groovy

class Append{
static void main(String[] args){
def c="Hello ";
def d="world";
def e=c+d;
println(e);
}
}
Output:
Hello world

Haskell

main = putStrLn ("Hello" ++ "World")

Icon and Unicon

In both languages you can:

procedure main()
    s := "foo"
    s ||:= "bar"
    write(s)
end

Outputs:

->ss
foobar
->

J

   s=: 'new'
   s
new
   s=: s,' value'   NB. append is in-place
   s
new value

Java

There are multiple ways to append 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 append 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

String sa = "Hello";
sa += ", World!";
System.out.println(sa);

StringBuilder ba = new StringBuilder();
ba.append("Hello");
ba.append(", World!");
System.out.println(ba.toString());
Output:
Hello, World!
Hello, World!

JavaScript

Works with: Rhino
Works with: SpiderMonkey
var s1 = "Hello";
s1 += ", World!";
print(s1);

var s2 = "Goodbye";
// concat() returns the strings together, but doesn't edit existing string
// concat can also have multiple parameters
print(s2.concat(", World!"));
Output:
"Hello, World!"
"Goodbye, World!"

jq

jq's + operator can be used to append two strings, and under certain circumstances the += operator can be used as an abbreviation for appending a string to an existing string. For example, all three of the following produce the same output:

"Hello" | . += ", world!"

["Hello"] | .[0] += ", world!" | .[0]

{ "greeting": "Hello"} | .greeting += ", world!" | .greeting

However the += operator cannot be used with jq variables in the conventional manner. One could nevertheless use the technique illustrated by the following:

"Hello" as $a | $a | . += ", world!" as $a | $a

Jsish

From Javascript entry.

/* String append, in Jsish */
var str = 'Hello';
;str += ', world';

var s2 = 'Goodbye';
;s2.concat(', World!');

/*
=!EXPECTSTART!=
str += ', world' ==> Hello, world
s2.concat(', World!') ==> Goodbye, World!
=!EXPECTEND!=
*/
Output:
prompt$ jsish --U stringAppend.jsi
str += ', world' ==> Hello, world
s2.concat(', World!') ==> Goodbye, World!

Julia

s = "Hello"
s *= ", world!"
Output:
"Hello, world!"

K

h: "hello "
h,: "world"
h
"hello world"

Kotlin

fun main(args: Array<String>) {
    var s = "a"
    s += "b"
    s += "c"
    println(s)
    println("a" + "b" + "c")
    val a = "a"
    val b = "b"
    val c = "c"
    println("$a$b$c")
}
Output:
abc
abc
abc

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

$s = Hello
$s += \, World!

fn.println($s)
Output:
Hello World

langur

var s = "no more "
s ~= "foo bars"
writeln s
Output:
no more foo bars

Lasso

local(x = 'Hello')
#x->append(', World!')
#x
Output:
Hello, World!

LDPL

data:
myText is text

procedure:
store "LD" in myText
in myText join myText "PL"
display myText lf
Output:
LDPL

Lingo

str = "Hello" 
put " world!" after str
put str
-- "Hello world!"

LiveCode

Livecode has an "after" keyword for this

local str="live"
put "code" after str

Output is "livecode"

Lua

Not possible as strings are immutable. We can demonstrate their immutability using 'self':

function string:show ()
    print(self)
end

function string:append (s)
    self = self .. s
end

x = "Hi "
x:show()
x:append("there!")
x:show()
Output:
Hi 
Hi 

You can of course concatentate them and store the result in the original variable name but that requires a double reference:

x = "Hi "
x = x .. "there!"
print(x)
Output:
Hi there!

M2000 Interpreter

Documents in M2000 are objects with paragraphs. From Version 12 we can use variable names for strings without suffix $, although a and a$ are different variable names.

a="ok"
a+="(one)"
Print a

a$="ok"
a$+="(one)"
Print a$

Document b$
b$="ok"
b$="(one)"
Print b$
Output:
ok(one)
ok(one)

Maple

a := "Hello";
b := cat(a, " World");
c := `||`(a, " World");
Output:
                            "Hello"
                         "Hello World"
                         "Hello World"

Mathematica/Wolfram Language

(* mutable strings are not supported *)
s1 = "testing";
s1 = s1 <> " 123";
s1
Output:
"testing 123"

min

Works with: min version 0.19.6
(quote cons "" join) :str-append

"foo" "bar" str-append puts!
Output:
foobar

MiniScript

s1 = "Hello"
s1 = s1 + ", "
s1 += "World!"
print s1
Output:
Hello, World!

MontiLang

|Hello | |world!| swap + print
|Hello | var hello .
|world!| var world .
world hello + print

Nanoquery

s1 = "this is"
s1 += " a test"

println s1
Output:
this is a test

Neko

The plus operator +, concats strings.

/**
 <doc><p>String append in Neko</pre></doc>
**/

var str = "Hello"
str += ", world"
$print(str, "\n")
Output:
prompt$ nekoc string-append.neko
prompt$ neko ./string-append.n
Hello, world

NetRexx

s_ = 'Hello'
s_ = s_', world!'
say s_
Output:
Hello, world!

NewLISP

(setq str "foo")

(push "bar" str -1)
; or as an alternative introduced in v.10.1
(extend str "bar")

(println str)

Nim

var str = "123456"
str.add("78") # Using procedure "add".
str &= "9!"   # Using operator "&=".
echo str
Output:
123456789!

NS-HUBASIC

10 S$ = "HELLO"
20 S$ = S$ + " WORLD!"
30 PRINT S$

Objeck

class Append {
  function : Main(args : String[]) ~ Nil {
    x := "foo";
    x->Append("bar");
    x->PrintLine();
  }
}

OCaml

let () =
  let s = Buffer.create 17 in
  Buffer.add_string s "Bonjour";
  Buffer.add_string s " tout le monde!";
  print_endline (Buffer.contents s)
Output:
Bonjour tout le monde!

Oforth

StringBuffer new "Hello, " << "World!" << println

PARI/GP

Not supported in GP.

s = "Hello";
s = Str(s, ", world!")
Output:
%1 = "Hello, world!"

Pascal

Works with: Free Pascal version 2.6.2
program StringAppend;
{$mode objfpc}{$H+}

uses
  {$IFDEF UNIX}{$IFDEF UseCThreads}
  cthreads,
  {$ENDIF}{$ENDIF}
  Classes
  { you can add units after this };

var
    s: String = 'Hello';
begin
  s += ' World !';
  WriteLn(S);
  ReadLn;
end.

Output:

Hello  World !

PascalABC.NET

begin
  var s := 'Pascal';
  s += 'ABC';
  s += '.NET';
  s.Println;
end.
Output:
PascalABC.NET



Perl

my $str = 'Foo';
$str .= 'bar';
print $str;
Output:
Foobar

Phix

Library: Phix/basics
string s = "this string"        ?s
s &= " is now longer"           ?s
Output:
"this string"
"this string is now longer"

Phixmonti

/# Rosetta Code problem: https://rosettacode.org/wiki/String_append
by Galileo, 11/2022 #/

"Hello" var s
s " world" chain var s
s print
Output:
Hello world
=== Press any key to exit ===

Picat

main =>
  S = "a string",
  S := S + " that is longer",
  println(S).
Output:
a string that is longer


PicoLisp

(setq Str1 "12345678")
(setq Str1 (pack Str1 "9!"))
(println Str1)
Output:
"123456789!"

Pike

string msg = "hello";
msg += " world";
write(msg +"\n");
Output:
hello world

PL/I

Cat: procedure options (main);
   declare s character (100) varying;
   s = 'dust ';
   s ||= 'bowl';
   put (s);
end Cat;
dust bowl

Plain English

To run:
Start up.
Put "abc" into a string.
Append "123" to the string.
Write the string to the console.
Wait for the escape key.
Shut down.
Output:
abc123

Plain TeX

Works with any TeX engine

\def\addtomacro#1#2{\expandafter\def\expandafter#1\expandafter{#1#2}}
\def\foo{Hello}
Initial: \foo

\addtomacro\foo{ world!}
Appended: \foo
\bye

pdf or dvi output:

Initial: Hello
Appended: Hello world!

PowerShell

$str = "Hello, "
$str += "World!"
$str
Hello, World!

PureBasic

S$ = "Hello"
S$ = S$ + " Wo" ;by referencing the string twice
S$ + "rld!"     ;by referencing the string once
If OpenConsole()
  PrintN(S$)

  Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
  CloseConsole()
EndIf

Sample output:

Hello World!

Python

File: String_append.py

#!/usr/bin/env python
# -*- coding: utf-8 -*- #

str = "12345678";
str += "9!";
print(str)
Output:
123456789!

QB64

s$ = "String"
s$ = s$ + " append"
Print s$
Output:
String append

Quackery

Quackery has no variables. The nearest equivalent is ancillary stacks. The word join will return the concatenation of two nests on the stack, and hence two strings, as strings are a particular usage of nests. Here we define the word append to join a nest on the stack to a nest on an ancillary stack, and then demonstrate its use with a Jules Renard quotation and the predefined ancillary stack temp.

  [ tuck take swap join swap put ] is append ( [ s --> )
  
  $ "L'homme qui attend de voir un canard roti voler "   temp put
  $ "dans sa bouche doit attendre tres, tres longtemps." temp append
  temp take echo$
Output:
L'homme qui attend de voir un canard roti voler dans sa bouche doit attendre tres, tres longtemps.

Racket

;there is no built-in way to set! append in racket
(define mystr "foo")
(set! mystr (string-append mystr " bar"))
(displayln mystr)

;but you can create a quick macro to solve that problem
(define-syntax-rule (set-append! str value)
  (set! str (string-append str value)))

(define mymacrostr "foo")
(set-append! mymacrostr " bar")
(displayln mystr)
Output:
foo bar
foo bar

Raku

(formerly Perl 6)

my $str = "foo";
$str ~= "bar";
say $str;
Output:
foobar

Relation

set a = "Hello"
set b = " World"
set c = a.b
echo c

REXX

using abutment

s='he'
s=s'llo world!'
Say s

output

hello world!

using concatenation

s="He"
s=s || 'llo, World!'       /*same as:   s=s||'llo, World!'    */
say s

output

Hello, World!

Ring

aString1 = "Welcome to the "
aString2 = "Ring Programming Language"
aString3 = aString1 + aString2
see aString3

Robotic

set "$str1" to "Hello "
inc "$str1" by "world!"
* "&$str1&"
end

RPL

In HP-48+ RPL versions, the STO+ instruction can append a string to a variable containing already a string.

"def" 'Z' STO
'Z' "ghi" STO+
Z

Output

 1: "defghi"

Ruby

s = "Hello wo"
s += "rld" # new string object
s << "!"   # mutates in place, same object
puts s
Output:
Hello world!

Rust

use std::ops::Add;

fn main(){
    let hello = String::from("Hello world");
    println!("{}", hello.add("!!!!"));
}
Output:

Hello world!!!!

Real append

The first solution doesn't append to the string variable. This solution really appends to the existing variable.

fn main(){
    let mut hello = String::from("Hello world");
    hello.push_str("!!!!");
    println!("{}", hello);
}
Output:

Hello world!!!!

Scala

An evaluation in Scala worksheet.

  var d = "Hello" // Mutables are discouraged     //> d  : String = Hello
  d += ", World!" // var contains a totally new re-instantiationed String

  val s = "Hello" // Immutables are recommended   //> s  : String = Hello
  val s1 = s + s                                  //> s1  : String = HelloHello
  val f2 = () => " !" //Function assigned to variable
                                                  //> f2  : () => String = <function0>
  println(s1 + f2());                             //> HelloHello !

sed

There are no variables in sed, just two distinct locations for storing a string: The "pattern space" and the "hold space".

  • The H command appends the content of pattern space to the hold space.
  • The G command appends the content of hold space to the pattern space.
  • The N command appends the next input line to the pattern space.

All three commands insert a newline character between both strings during appending. In pattern space, it can be removed afterwards with the s command, like this:

N
s/\n//
  • The s command can also be used to append a string literal to the pattern space:
s/$/String Literal/
  • To append further lines to the output (after the printing of the pattern space), the a command is useful:
a\
one more line\
and another one

Seed7

$ include "seed7_05.s7i";

const proc: main is func
  local
    var string: str is "12345678";
  begin
    str &:= "9!";
    writeln(str);
  end func;
Output:
123456789!

Sidef

var str = 'Foo';
str += 'bar';
say str;
Output:
Foobar

SNOBOL4

     s = "Hello"
     s = s ", World!"
     OUTPUT = s
END
Output:
Hello, World!

Stata

sca s="Ars Longa"
sca s=s+" Vita Brevis"
di s

Ars Longa Vita Brevis

Swift

var s = "foo"              // "foo"
s += "bar"                 // "foobar"
print(s)                   // "foobar"
s.appendContentsOf("baz")  // "foobarbaz"
print(s)                   // "foobarbaz"

Tcl

String concatenation is a fundamental feature of the Tcl language, and there is also an append that makes concatenation even simpler:

set s "he"
set s "${s}llo wo";   # The braces distinguish varname from text to concatenate
append s "rld"
puts $s
Output:
hello world

Transd

#lang transd

MainModule: {
    _start: (λ 
        (with s1 "aaa" s2 "bbb" s3 "ccc"
            (+= s1 s2 s3) 
            (textout s1))
    )
}
Output:
aaabbbccc

Ursa

decl string str
set str "hello "

# append "world" to str
set str (+ str "world")

# outputs "hello world"
out str endl console

Vala

void main() {
  string x = "foo";
  x += "bar\n";
  print(x);
}

VBA

Function StringAppend()
Dim s As String
s = "foo"
s = s & "bar"
Debug.Print s
End Function

VBScript

s = "Rosetta"
s = s & " Code"
WScript.StdOut.Write s
Output:
Rosetta Code

V (Vlang)

mut s:= 'foo'
s += 'bar'
println(s)

foo := 'foo'
bar := 'bar'
foobar := '$foo$bar'
println(foobar)
Output:
foobar
foobar

String Builder

TODO

Wart

s <- "12345678"
s <- (s + "9!")

Wren

var s = "Hello, "
s = s + "world!"
System.print(s)
Output:
Hello, world!

XPL0

include xpllib;
char A, B, C(80);
[A:= "Hello, ";
B:= "world!";
StrCopy(C, A);
StrCat(C, B);
Text(0, C);
]
Output:
Hello, world!

zkl

zkl strings are immutable, but byte blobs are mutable.

var s="foo";
s.append("bar"); //-->new string "foobar", var s unchanged
s+="bar";        //-->new string "foobar", var s modifed to new value

s=Data(Void,"foo");	// byte blob/character blob/text editor buffer
s.append("bar");  // or s+="bar"
s.text; //-->"foobar"