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.

ALGOL 68[edit]

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!

AutoHotkey[edit]

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

AWK[edit]

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

Axe[edit]

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

BASIC[edit]

Applesoft BASIC[edit]

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

BBC BASIC[edit]

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

Bracmat[edit]

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

C[edit]

#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++[edit]

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

C#[edit]

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

Clojure[edit]

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[edit]

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[edit]

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[edit]

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[edit]

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

EchoLisp[edit]

 
;; 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[edit]

program =
[
var s := String new:"Hello".
s += " World".
 
console writeLine:s readChar.
].

Elixir[edit]

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

Emacs Lisp[edit]

version 1[edit]

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

version 2[edit]

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

Eval:

 
(setq str "Hello, ")
(setq str (glue str "World!") )
(insert str)
 

Output:

Hello, World!


Erlang[edit]

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


Euphoria[edit]

 
sequence string = "String"
 
printf(1,"%s\n",{string})
 
string &= " is now longer\n"
 
printf(1,"%s",{string})
 
Output:
String
String is now longer

F#[edit]

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


Forth[edit]

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[edit]

Using deferred length character strings:

 
program main
 
character(len=:),allocatable :: str
 
str = 'hello'
str = str//' world'
 
write(*,*) str
 
end program main
 

FreeBASIC[edit]

' FB 1.05.0 Win64
 
Var s = "String"
s += " append"
Print s
Sleep
Output:
String append

Go[edit]

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

Gosu[edit]

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

Icon and Unicon[edit]

In both languages you can:

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

Outputs:

->ss
foobar
->

Groovy[edit]

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

Haskell[edit]

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

J[edit]

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

Java[edit]

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[edit]

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[edit]

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

Julia[edit]

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

Kotlin[edit]

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

Lasso[edit]

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

Lingo[edit]

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

LiveCode[edit]

Livecode has an "after" keyword for this

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

Output is "livecode"

Lua[edit]

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!

Maple[edit]

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

Mathematica[edit]

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

NetRexx[edit]

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

NewLISP[edit]

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

Nim[edit]

var str = "123456"
str.add("78") # two ways
str &= "9!" # to append

Objeck[edit]

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

OCaml[edit]

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[edit]

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

PARI/GP[edit]

Not supported in GP.

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

Pascal[edit]

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 !

Perl[edit]

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

Perl 6[edit]

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

Phix[edit]

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

PicoLisp[edit]

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

PL/I[edit]

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


Plain TeX[edit]

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[edit]

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

PureBasic[edit]

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[edit]

File: String_append.py
#!/usr/bin/env python
# -*- coding: utf-8 -*- #
 
str = "12345678";
str += "9!";
print(str)
Output:
123456789!

Racket[edit]

;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

REXX[edit]

using abutment[edit]

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

output

hello world!

using concatenation[edit]

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

output

Hello, World!

Ring[edit]

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

Ruby[edit]

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

Scala[edit]

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 !

Seed7[edit]

$ 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[edit]

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

SNOBOL4[edit]

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

Swift[edit]

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

Tcl[edit]

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

Ursa[edit]

decl string str
set str "hello "
 
# append "world" to str
set str (+ str "world")
 
# outputs "hello world"
out str endl console

VBA[edit]

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

VBScript[edit]

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

Wart[edit]

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

zkl[edit]

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"