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

<lang 11l>V s = ‘12345678’ s ‘’= ‘9!’ print(s)</lang>

Output:

123456789!

AArch64 Assembly

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

<lang AArch64 Assembly> /* 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" </lang>

Output:

String :
Alphabet :
String :
Alphabet : abcdefghijklmnopqrstuvwxyz

Action!

<lang Action!> CHAR ARRAY S1,S2

Proc Main()

S1="Hello, "
S2="world!";
Sassign(S1,S2,S1(0)+1)
Print(S1)

Return </lang>

Output:

Hello, world!

Ada

<lang 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; </lang>

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<lang algol68>#!/usr/bin/a68g --script #

-*- coding: utf-8 -*- #

STRING str := "12345678"; str +:= "9!"; print(str)</lang>

Output:

123456789!

ARM Assembly

Works with: as version Raspberry Pi

<lang ARM Assembly> /* 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

</lang>

AppleScript

<lang AppleScript> set {a, b} to {"Apple", "Script"} set a to a & b return a as string </lang>

Output:

"AppleScript"

APL

<lang APL> s←'hello'

     s,'world'

helloworld</lang>

Arturo

<lang rebol>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"</lang>

Output:

HelloWorld
HelloWorld
HelloWorld
HelloWorld

Asymptote

<lang Asymptote>string s = "Hello"; s = s + " Wo"; s += "rld!"; write(s);</lang>

AutoHotkey

<lang autohotkey>s := "Hello, " s .= "world." MsgBox % s</lang>

Output:

Hello, world.

Avail

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

<lang Avail>str : string := "99 bottles of "; str ++= "beer"; Print: str;</lang>

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:

<lang Avail>Public method "_↑++=_" is [ var : read tuple/write ⊥, t : tuple | var ?= eject var ++ t; ] : ⊤;</lang> (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)

} </lang>

Output:

foobar

Axe

<lang axe>Lbl STRCAT Copy(r₂,r₁+length(r₁),length(r₂)+1) r₁ Return</lang>

BASIC

Applesoft BASIC

<lang BASIC>S$ = "Hello" S$ = S$ + " World!" PRINT S$</lang>

BaCon

<lang freebasic> A$ = "Hello" A$ = A$ & " World!" PRINT A$ </lang>

BBC BASIC

<lang BBC BASIC> S$="Hello"

     S$+=" World!"
     PRINT S$
     END</lang>

Output:

Hello World!

Commodore BASIC

<lang GWBASIC>10 S$ = "HELLO" 20 S$ = S$ + " WORLD!" 30 PRINT S$ 40 END</lang>

Output:

HELLO WORLD!

IS-BASIC

<lang IS-BASIC>100 LET S$="Hello" 110 LET S$=S$&" World!" 120 PRINT S$</lang>

BASIC256

<lang freebasic>a$ = "He" a$ = a$ & "llo" a$ = a$ + " Wo" a$ += "rld" a$ &= "!" print a$</lang>

Liberty BASIC

<lang lb>a$ = "Hello" a$ = a$ + " World" a$ = a$ ; "!" print a$</lang>

QBasic

Works with: Liberty BASIC

Works with: QB64

Works with: Run BASIC

Works with: Yabasic

<lang QBasic>a$ = "Hello" a$ = a$ + " World!" PRINT a$</lang>

Run BASIC

Works with: Liberty BASIC

Works with: QB64

Works with: QBasic

Works with: Yabasic

<lang runbasic>a$ = "Hello" a$ = a$ + " World!" print a$</lang>

True BASIC

<lang qbasic>LET a$ = "Hello" LET a$ = a$ & " World!" PRINT a$ END</lang>

Yabasic

Works with: Liberty BASIC

Works with: QB64

Works with: QBasic

Works with: Run BASIC

<lang yabasic>a$ = "Hello" a$ = a$ + " World!" print a$</lang>

Bracmat

<lang Bracmat>str="Hello"; str$(!str " World!"):?str; out$!str;</lang>

Output:

Hello World!

C

<lang 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;

}</lang>

Output:

Good Morning to all !!!

C#

<lang csharp>class Program {

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

}</lang>

C++

<lang cpp>#include <iostream>

include <string>

int main( ) {

  std::string greeting( "Hello" ) ;
  greeting.append( " , world!" ) ;
  std::cout << greeting << std::endl ;
  return 0 ;

}</lang>

Output:

Hello , world!

Clojure

Using global vars. <lang clojure>user=> (def s "app")

'user/s

user=> s "app" user=> (def s (str s "end"))

'user/s

user=> s "append"</lang>

Using local bindings. <lang clojure> user=> (let [s "ap", s (str s "pend")] s) "append"</lang>

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

<lang COBOL> 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.

</lang>

Output:

$ cobc -xj string-append.cob
Hello, world

CoffeeScript

Works with: Node.js

<lang coffeescript>a = "Hello, " b = "World!" c = a + b

console.log c</lang> Or with concat: <lang coffeescript>console.log "Hello, ".concat "World!"</lang>

Output:

Hello, World!

Common Lisp

Similar to the Racket solution, a macro is necessary to append in-place: <lang lisp>(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*)</lang>

Output:

foobar
foobarbazabcdef

D

<lang d>import std.stdio;

void main() {

   string s = "Hello";
   s ~= " world!"; 
   writeln(s);

}</lang>

Output:

Hello world!

DBL

<lang DBL>;Concatenate "Hello world!" STR='Hello' STR(%TRIM(STR)+2:5)='world' STR(%TRIM(STR)+1:1)='!'</lang>

Delphi

Library: System.SysUtils

<lang 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.</lang>

Output:

Hello World
Hello World
Hello World

Dyalect

<lang dyalect>var str = "foo" str += str print(str)</lang>

EasyLang

<lang>a$ = "hello" a$ &= " world" print a$</lang>

EchoLisp

(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"

</lang>

Elena

ELENA 4.x : <lang elena>import extensions; import extensions'text;

public program() {

   var s := StringWriter.load("Hello");
   s.append:" World";
    
   console.printLine:s.readChar()

}</lang>

Elixir

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

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:

<lang Lisp>(defvar str "foo") (setq str (concat str "bar")) str ;=> "foobar"</lang>

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

Library: cl-lib

<lang Lisp>(require 'cl-lib)

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

Buffers can be thought of as expandable strings:

<lang Lisp>(let ((buf (get-buffer-create "*foo*")))

 (with-current-buffer buf
   (insert "foo"))
 (with-current-buffer buf
   (goto-char (point-max))
   (insert "bar")
   (buffer-string)))

Erlang

Output:

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

Euphoria

<lang euphoria> sequence string = "String"

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

string &= " is now longer\n"

printf(1,"%s",{string}) </lang>

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. <lang fsharp>let mutable x = "foo" x <- x + "bar" printfn "%s" x</lang>

Factor

<lang factor>"Hello, " "world!" append</lang>

Output:

"Hello, world!"

Falcon

<lang falcon> /* Added by Aykayayciti Earl Lamont Montgomery April 10th, 2018 */

s1, s2 = "Hello", "Foo" > s1 + " World" printl(s2 + " bar") </lang>

Output:

Hello World
Foo bar
[Finished in 0.2s]

Forth

<lang 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"</lang>

Test at the console

<lang> ok s" Hello " astring place ok s" World!" astring +place ok astring count type Hello World! ok </lang>

Fortran

Using deferred length character strings:

<lang Fortran> program main

character(len=:),allocatable :: str

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

write(*,*) str

end program main </lang>

Output:

hello world

Using pre-allocated character strings:

<lang Fortran> program str_append

   implicit none

   character(len=20) :: str

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

end program str_append </lang>

Output:

StringAppend

FreeBASIC

<lang freebasic>' FB 1.05.0 Win64

Var s = "String" s += " append" Print s Sleep</lang>

Output:

String append

Gambas

Click this link to run this code <lang gambas>Public Sub Main() Dim sString As String = "Hello "

sString &= "World!" Print sString

End</lang> Output:

Hello World!

Genie

<lang genie>[indent=4] /* String append, in Genie */ init

   str:string = "Hello"
   str += ", world"

   print str</lang>

Output:

prompt$ valac stringAppend.gs
prompt$ ./stringAppend
Hello, world

GlovePIE

<lang glovepie>var.string="This is " var.string+="Sparta!" debug=var.string</lang>

Go

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. <lang go> package main

import (

 "fmt"
 "strings"

)

func main() {

 var s strings.Builder
 s.WriteString("foo")
 s.WriteString("bar")
 fmt.Print(s.String())

} </lang>

Output:

foobar

Gosu

<lang 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}")</lang>

Output:

abc
abc
abc

Groovy

<lang Groovy> class Append{ static void main(String[] args){ def c="Hello "; def d="world"; def e=c+d; println(e); } } </lang>

Output:

Hello world

Haskell

<lang haskell> main = putStrLn ("Hello" ++ "World") </lang>

Icon and Unicon

In both languages you can:

<lang unicon> procedure main()

   s := "foo"
   s ||:= "bar"
   write(s)

end </lang>

Outputs:

->ss
foobar
->

J

<lang j> s=: 'new'

new

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

new value</lang>

Java

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

StringBuilder ba = new StringBuilder(); ba.append("Hello"); ba.append(", World!"); System.out.println(ba.toString());</lang>

Output:

Hello, World!
Hello, World!

JavaScript

Works with: Rhino

Works with: SpiderMonkey

<lang JavaScript>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!"));</lang>

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:<lang jq>"Hello" | . += ", world!"

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

{ "greeting": "Hello"} | .greeting += ", world!" | .greeting</lang> However the += operator cannot be used with jq variables in the conventional manner. One could nevertheless use the technique illustrated by the following:<lang jq>"Hello" as $a | $a | . += ", world!" as $a | $a</lang>

Jsish

From Javascript entry. <lang javascript>/* 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!

/</lang>

Output:

prompt$ jsish --U stringAppend.jsi
str += ', world' ==> Hello, world
s2.concat(', World!') ==> Goodbye, World!

Julia

<lang julia>s = "Hello" s *= ", world!"</lang>

Output:

"Hello, world!"

Kotlin

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

}</lang>

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. <lang Scheme> {def christian_name Albert} -> christian_name {def name de Jeumont-Schneidre} -> name

{christian_name} {name} -> Albert de Jeumont-Schneidre </lang>

langur

<lang langur>var .s = "no more " .s ~= "foo bars" writeln .s</lang>

Output:

no more foo bars

Lasso

<lang Lasso>local(x = 'Hello')

x->append(', World!')
x</lang>

Output:

Hello, World!

Lingo

<lang lingo>str = "Hello" put " world!" after str put str -- "Hello world!"</lang>

LiveCode

Livecode has an "after" keyword for this <lang LiveCode>local str="live" put "code" after str</lang> Output is "livecode"

Lua

Not possible as strings are immutable. We can demonstrate their immutability using 'self': <lang Lua>function string:show ()

   print(self)

end

function string:append (s)

   self = self .. s

end

x = "Hi " x:show() x:append("there!") x:show()</lang>

Output:

Hi 
Hi

You can of course concatentate them and store the result in the original variable name but that requires a double reference: <lang Lua>x = "Hi " x = x .. "there!" print(x)</lang>

Output:

Hi there!

M2000 Interpreter

Documents in M2000 are objects with paragraphs.

<lang M2000 Interpreter> a$="ok" a$+="(one)" Print a$

Document b$ b$="ok" b$="(one)" Print b$ </lang>

Output:

ok(one)
ok(one)

Maple

<lang maple>a := "Hello"; b := cat(a, " World"); c := `||`(a, " World");</lang>

Output:

                            "Hello"
                         "Hello World"
                         "Hello World"

Mathematica/Wolfram Language

<lang Mathematica>(* mutable strings are not supported *) s1 = "testing"; s1 = s1 <> " 123"; s1</lang>

Output:

"testing 123"

min

Works with: min version 0.19.6

<lang min>(quote cons "" join) :str-append

"foo" "bar" str-append puts!</lang>

Output:

foobar

MontiLang

Nanoquery

<lang Nanoquery>s1 = "this is" s1 += " a test"

println s1</lang>

Output:

this is a test

Neko

The plus operator +, concats strings.

<lang ActionScript>/**

<doc>

String append in Neko</doc>

- /

var str = "Hello" str += ", world" $print(str, "\n")</lang>

Output:

prompt$ nekoc string-append.neko
prompt$ neko ./string-append.n
Hello, world

NetRexx

<lang NetRexx>s_ = 'Hello' s_ = s_', world!' say s_</lang>

Output:

Hello, world!

NewLISP

<lang NewLISP>(setq str "foo")

(push "bar" str -1)

or as an alternative introduced in v.10.1

(extend str "bar")

(println str) </lang>

Nim

<lang nim>var str = "123456" str.add("78") # Using procedure "add". str &= "9!" # Using operator "&=". echo str </lang>

Output:

123456789!

NS-HUBASIC

<lang NS-HUBASIC>10 S$ = "HELLO" 20 S$ = S$ + " WORLD!" 30 PRINT S$</lang>

Objeck

<lang objeck> class Append {

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

} </lang>

OCaml

<lang 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)</lang>

Output:

Bonjour tout le monde!

Oforth

<lang Oforth>StringBuffer new "Hello, " << "World!" << println</lang>

PARI/GP

Not supported in GP. <lang parigp>s = "Hello"; s = Str(s, ", world!")</lang>

Output:

%1 = "Hello, world!"

Pascal

Works with: Free Pascal version 2.6.2

<lang Pascal>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.</lang> Output:

Hello  World !

Perl

<lang perl>my $str = 'Foo'; $str .= 'bar'; print $str;</lang>

Output:

Foobar

Phix

Library: Phix/basics

string s = "this string"        ?s
s &= " is now longer"           ?s

Output:

"this string"
"this string is now longer"

PicoLisp

<lang picolisp>(setq Str1 "12345678") (setq Str1 (pack Str1 "9!")) (println Str1)</lang>

Output:

"123456789!"

Pike

<lang Pike> string msg = "hello"; msg += " world"; write(msg +"\n"); </lang>

Output:

hello world

PL/I

<lang PL/I>Cat: procedure options (main);

  declare s character (100) varying;
  s = 'dust ';
  s ||= 'bowl';
  put (s);

end Cat;</lang>

dust bowl

Plain English

<lang plainenglish>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.</lang>

Output:

abc123

Plain $T e X$

Works with any TeX engine <lang tex>\def\addtomacro#1#2{\expandafter\def\expandafter#1\expandafter{#1#2}} \def\foo{Hello} Initial: \foo

\addtomacro\foo{ world!} Appended: \foo \bye</lang>

pdf or dvi output:

Initial: Hello
Appended: Hello world!

PowerShell

<lang PowerShell> $str = "Hello, " $str += "World!" $str </lang>

Hello, World!

PureBasic

<lang 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</lang> Sample output:

Hello World!

Python

File: String_append.py<lang python>#!/usr/bin/env python

-*- coding: utf-8 -*- #

str = "12345678"; str += "9!"; print(str)</lang>

Output:

123456789!

QB64

<lang qbasic>s$ = "String" s$ = s$ + " append" Print s$</lang>

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.

<lang Quackery> [ 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$ </lang>

Output:

L'homme qui attend de voir un canard roti voler dans sa bouche doit attendre tres, tres longtemps.

Racket

<lang 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)</lang>

Output:

foo bar
foo bar

Raku

(formerly Perl 6) <lang perl6>my $str = "foo"; $str ~= "bar"; say $str;</lang>

Output:

foobar

Relation

<lang Relation> set a = "Hello" set b = " World" set c = a.b echo c </lang>

REXX

using abutment

<lang rexx>s='he' s=s'llo world!' Say s</lang> output

hello world!

using concatenation

<lang rexx>s="He" s=s || 'llo, World!' /*same as: s=s||'llo, World!' */ say s</lang> output

Hello, World!

Ring

<lang ring> aString1 = "Welcome to the " aString2 = "Ring Programming Language" aString3 = aString1 + aString2 see aString3 </lang>

Robotic

<lang robotic> set "$str1" to "Hello " inc "$str1" by "world!"

"&$str1&"

end </lang>

Ruby

<lang ruby>s = "Hello wo" s += "rld" # new string object s << "!" # mutates in place, same object puts s</lang>

Output:

Hello world!

Rust

<lang rust> use std::ops::Add;

fn main(){

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

}</lang>

Output:

Hello world!!!!

Real append

The first solution doesn't append to the string variable. This solution really appends to the existing variable. <lang rust> fn main(){

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

} </lang>

Output:

Hello world!!!!

Scala

An evaluation in Scala worksheet. <lang scala> 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 !</lang>

Seed7

<lang seed7>$ include "seed7_05.s7i";

const proc: main is func

 local
   var string: str is "12345678";
 begin
   str &:= "9!";
   writeln(str);
 end func;</lang>

Output:

123456789!

Sidef

Output:

Foobar

SNOBOL4

<lang SNOBOL4> s = "Hello"

    s = s ", World!"
    OUTPUT = s

END</lang>

Output:

Hello, World!

Stata

<lang stata>sca s="Ars Longa" sca s=s+" Vita Brevis" di s

Ars Longa Vita Brevis</lang>

Swift

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

Tcl

String concatenation is a fundamental feature of the Tcl language, and there is also an append that makes concatenation even simpler: <lang tcl>set s "he" set s "${s}llo wo"; # The braces distinguish varname from text to concatenate append s "rld" puts $s</lang>

Output:

hello world

Ursa

<lang ursa>decl string str set str "hello "

append "world" to str

set str (+ str "world")

outputs "hello world"

out str endl console</lang>

Vala

<lang vala>void main() {

 string x = "foo";
 x += "bar\n";
 print(x);

}</lang>

VBA

<lang VB>Function StringAppend() Dim s As String s = "foo" s = s & "bar" Debug.Print s End Function</lang>

VBScript

<lang vb>s = "Rosetta" s = s & " Code" WScript.StdOut.Write s</lang>

Output:

Rosetta Code

Wart

Wren

<lang javascript>var s = "Hello, " s = s + "world!" System.print(s)</lang>

Output:

Hello, world!

zkl

zkl strings are immutable, but byte blobs are mutable. <lang zkl>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"</lang>