String concatenation
You are encouraged to solve this task according to the task description, using any language you may know.
Create a string variable equal to any text value. Create another string variable whose value is the original variable concatenated with another string literal.
To illustrate the operation, show the content of the variables.
ActionScript
<lang actionscript>package {
public class Str { public static function main():void { var s:String = "hello"; trace(s + " literal"); var s2:String = s + " literal"; trace(s2); } }
}</lang>
Ada
<lang ada>with Ada.Text_IO; use Ada.Text_IO;
procedure String_Concatenation is
S : String := "Hello";
begin
Put_Line (S & " literal"); declare S1 : String := S & " literal"; begin Put_Line (S1); end;
end String_Concatenation;</lang> Sample output:
Hello literal Hello literal
AutoHotkey
<lang AutoHotkey>s := "hello" Msgbox, %s% s1 := s . " literal" ;the . is optional Msgbox, %s1%</lang>
AWK
The AWK concatenation operator is just a space. <lang awk>BEGIN {
s = "hello" print s " literal" s1 = s " literal" print s1
}</lang>
ALGOL 68
<lang algol68>STRING s := "hello"; print ((s + " literal", new line)); STRING s1 := s + " literal"; print ((s1, new line))</lang> Output:
hello literal hello literal
BASIC
<lang qbasic>s$ = "hello" print s$;" literal" 'or s$ + " literal" s2$ = s$ + " literal" print s2$</lang> Output:
hello literal hello literal
Batch File
<lang dos>set string=Hello echo %string% World set string2=%string% World</lang>
C
<lang c>#include <stdio.h>
- include <stdlib.h>
- include <string.h>
char *sconcat(const char *s1, const char *s2) {
char *s0 = (char *)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);
}</lang>
C++
<lang cpp>#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;
}</lang> Output:
hello literal hello literal
C#
<lang csharp>using System;
class Program {
static void Main(string[] args) { string s = "hello"; Console.Write(s); Console.WriteLine(" literal"); string s2 = String.Concat(s, " literal"); Console.WriteLine(s2); }
}</lang>
Clojure
<lang lisp>(def a-str "abcd") (println (apply str (concat a-str "efgh"))) (def a-new-str (apply str (concat a-str "efgh"))) (println a-new-str)</lang>
Common Lisp
<lang lisp>(let ((s "hello"))
(format t "~a there!~%" s) (let* ((s2 " there!") (s (concatenate 'string s s2))) (format t "~a~%" s)))</lang>
<lang lisp>(defparameter *s* "hello") (print (concatenate 'string *s* " literal")) (defparameter *s1* (concatenate 'string *s* " literal")) (print *s1*)</lang>
D
<lang d>string s = "hello"; writefln(s ~ " world"); auto s2 = s ~ " world"; writefln(s2);</lang>
E
<lang e>def a := "rose" println(a + "bud") def b := a + "tte" println(b)</lang>
Factor
<lang factor>"wake up" [ " sheeple" append print ] [ ", you sheep" append ] bi print</lang>
Forth
<lang forth>s" hello" pad place pad count type s" there!" pad +place \ +place is called "append" on some Forths pad count type</lang>
Fortran
<lang fortran>program StringConcatenation
integer, parameter :: maxstringlength = 64 character (*), parameter :: s = "hello" character (maxstringlength) :: s1
print *,s // " literal" s1 = s // " literal" print *,s1
end program</lang>
Go
<lang go>package main import "fmt" func main() {
s := "hello" fmt.Printf("%s literal\n", s) s2 := s + " literal" fmt.Printf("%s\n", s2)
}</lang>
Golfscript
<lang golfscript>"Greetings ":s; s"Earthlings"+puts s"Earthlings"+:s1; s1 puts</lang>
Groovy
<lang groovy>def s = "Greetings " println s + "Earthlings"
def s1 = s + "Earthlings" println s1</lang>
Output:
Greetings Earthlings Greetings Earthlings
Haskell
<lang haskell>import System.IO s = "hello" s1 = s ++ " literal" main = do putStrLn (s ++ " literal")
putStrLn s1</lang>
HicEst
<lang HicEst>CHARACTER s = "hello", sl*100
WRITE() s // " literal" sl = s // " literal" WRITE() sl</lang>
Icon and Unicon
Icon
<lang Icon>procedure main() s1 := "hello" write(s2 := s1 || " there.") # capture the reuslt for write(s2) # ... the 2nd write end</lang>
Unicon
This Icon solution works in Unicon.
IDL
<lang idl> s1='Hello' print, s1 + ' literal' s2=s1 + ' literal' print, s2 </lang>
J
<lang J> s1 =. 'Some '
]s1, 'text '
Some text
]s2 =. s1 , 'more text!'
Some more text!</lang> For more info see:
- http://www.jsoftware.com/help/dictionary/d320.htm on
,
- http://www.jsoftware.com/help/dictionary/d500.htm on
]
Java
<lang java5>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); }
}</lang> Output:
hello literal hello literal
JavaScript
<lang javascript>var s = "hello" print(s + " there!")</lang>
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.
Liberty BASIC
See BASIC
Lisaac
<lang Lisaac>Section Header
+ name := STRING_CONCATENATION;
Section Public
- main <- (
+ sc : STRING_CONSTANT; + sv : STRING;
sc := "Hello"; (sc + " literal").print; '\n'.print; sv := sc + " literal"; sv.print; '\n'.print;
);</lang>
Logo
<lang logo>make "s "hello print word :s "| there!|</lang>
lua
<lang lua> a = "hello " print(a .. "world") c = a .. "world" print(c)</lang>
MATLAB
<lang MATLAB>>> string1 = '1 Fish'
string1 =
1 Fish
>> string2 = [string1 ', 2 Fish, Red Fish, Blue Fish']
string2 =
1 Fish, 2 Fish, Red Fish, Blue Fish</lang>
MUMPS
<lang MUMPS> STRCAT
SET S="STRING" WRITE !,S SET T=S_" LITERAL" WRITE !,T QUIT
</lang>
Output:
CACHE>D STRCAT^ROSETTA STRING STRING LITERAL
Objective-C
<lang objc>#import <Foundation/Foundation.h>
int main() {
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; 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]); [pool release]; return 0;
}</lang>
M4
M4 has macros rather than variables, but a macro expanded can work like a variable. <lang m4>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</lang>
MAXScript
<lang maxscript>s = "hello" print (s + " literal") s1 = s + " literal" print s1</lang>
Metafont
<lang metafont>string a, b; a := "String"; message a & " literal"; b := a & " literal"; message b;</lang>
Modula-3
Strings in Modula-3 are called TEXT
s. Concatenation can use &
, just like Ada.
<lang modula3>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.</lang>
Modula-3 also provides modules for dealing with TEXT
s, such as Text
.
<lang modula3>string1 := Text.Concat(string, " literal.\n");</lang>
Objeck
<lang objeck> bundle Default {
class Repeat { function : Main(args : String[]) ~ Nil { s := "hello"; s->PrintLine(); " literal"->PrintLine(); s->Append(" literal"); s->PrintLine(); } }
} </lang>
OCaml
<lang ocaml>let s = "hello" let s1 = s ^ " literal" let () =
print_endline (s ^ " literal"); (* or Printf.printf "%s literal\n" s; *) print_endline s1</lang>
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".
<lang oz>declare S = "hello" {System.showInfo S#" literal"} %% virtual strings are constructed with "#" S1 = {Append S " literal"} {System.showInfo S1} </lang>
Pascal
<lang 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.</lang>
Perl
<lang perl>my $s = 'hello'; print $s . ' literal', "\n"; my $s1 = $s . ' literal'; print $s1, "\n";</lang>
An example of destructive concatenation:
<lang perl>$s .= ' literal'; print $s, "\n";</lang>
Perl 6
<lang perl6>my $s = 'hello'; say $s ~ ' literal'; my $s1 = $s ~ ' literal'; say $s1;</lang>
An example of mutating concatenation:
<lang perl6>$s ~= ' literal'; say $s;</lang>
Note also that most concatenation in Perl is done implicitly via interpolation.
PL/I
<lang PL/I> declare (s, t) character (20) varying;
s = 'hello from me'; display (s || ' to you.' ); t = s; display (t || ' to you all.' ); </lang>
PowerShell
<lang powershell>$s = "Hello" Write-Host $s World.
- alternative, using variable expansion in strings
Write-Host "$s World."
$s2 = $s + " World." Write-Host $s2</lang>
PHP
<lang php><?php $s = "hello"; echo $s . " literal" . "\n"; $s1 = $s . " literal"; echo $s1 . "\n"; ?></lang>
PicoLisp
<lang PicoLisp>(let Str1 "First text"
(prinl Str1 " literal") (let Str2 (pack Str1 " literal") (prinl Str2) ) )</lang>
PureBasic
<lang PureBasic>If OpenConsole()
s$ = "hello" PrintN( s$ + " literal") s2$ = s$ + " literal" PrintN(s2$)
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit") Input() CloseConsole()
EndIf</lang>
Python
<lang python>s = "hello" print s + " literal" s1 = s + " literal" print s1</lang>
R
<lang 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"</lang>
REBOL
<lang REBOL>s: "hello" print s1: rejoin [s " literal"] print s1</lang>
REXX
<lang rexx> s = "hello" say s "literal" t = s "literal" say t
/* The above method works without spaces too */ genus='straw' say genus"berry" /* This outputs strawberry */
</lang>
Retro
<lang Retro>with strings' "hello" "literal" append puts</lang>
Ruby
<lang ruby>s = "hello" puts s + " literal" s1 = s + " literal" puts s1 s1 << " another" # append to s1</lang>
Sather
<lang sather>class MAIN is
main is s ::= "hello"; #OUT + s + " literal\n"; s2 ::= s + " literal"; #OUT + s2 + "\n"; end;
end;</lang>
Scheme
<lang scheme>(define s "hello") (display (string-append s " literal")) (newline) (define s1 (string-append s " literal")) (display s1) (newline)</lang>
Slate
<lang slate>define: #s -> 'hello'. inform: s ; ' literal'. define: #s1 -> (s ; ' literal'). inform: s1.</lang>
Smalltalk
<lang smalltalk>|s s1| s := 'hello'. (s,' literal') printNl. s1 := s,' literal'. s1 printNl.</lang>
SNOBOL4
<lang snobol> greet1 = "Hello, " output = greet1 greet2 = greet1 "World!" output = greet2 end</lang>
Standard ML
<lang sml>val s = "hello" val s1 = s ^ " literal\n" val () =
print (s ^ " literal\n"); print s1</lang>
Tcl
<lang tcl>set s hello puts "$s there!" append s " there!" puts $s</lang> You can also just group the strings to concatenate together at the point where they are used, using Tcl's built-in syntactic concatenation: <lang tcl>set s "Hello " set t "World" set u "!" puts $s$t$u ;# There is nothing special here about using puts; just an example</lang>
TI-89 BASIC
<lang ti89b>"aard" → sv Disp sv & "vark" sv & "wolf" → sv2</lang>
UNIX Shell
<lang sh>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
</lang>
UnixPipes
<lang bash>echo "hello"
| xargs -n1 -i echo {} literal</lang>
Visual Basic .NET
Platform: .NET
<lang vbnet>s = "Hello" Console.WriteLine(s & " literal") s1 = s + " literal" Console.WriteLine(s1)</lang>
Yorick
<lang yorick>var1 = "Hello"; var2 = var1 + ", world!"; write, var1; write, var2;</lang>
- Programming Tasks
- Basic language learning
- String manipulation
- ActionScript
- Ada
- AutoHotkey
- AWK
- ALGOL 68
- BASIC
- Batch File
- C
- C++
- C sharp
- Clojure
- Common Lisp
- D
- E
- Factor
- Forth
- Fortran
- Go
- Golfscript
- Groovy
- Haskell
- HicEst
- Icon
- Unicon
- IDL
- J
- Java
- JavaScript
- LabVIEW
- Liberty BASIC
- Lisaac
- Logo
- Lua
- MATLAB
- MUMPS
- Objective-C
- M4
- MAXScript
- Metafont
- Modula-3
- Objeck
- OCaml
- Oz
- Pascal
- Perl
- Perl 6
- PL/I
- PowerShell
- PHP
- PicoLisp
- PureBasic
- Python
- R
- REBOL
- REXX
- Retro
- Ruby
- Sather
- Scheme
- Slate
- Smalltalk
- SNOBOL4
- Standard ML
- Tcl
- TI-89 BASIC
- UNIX Shell
- UnixPipes
- Visual Basic .NET
- Yorick