String concatenation

From Rosetta Code
Jump to: navigation, search
Task
String concatenation
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

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.

Contents

[edit] ActionScript

package
{
public class Str
{
public static function main():void
{
var s:String = "hello";
trace(s + " literal");
var s2:String = s + " literal";
trace(s2);
}
}
}

[edit] 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;
Sample output:
Hello literal
Hello literal

[edit] Aime

text s, v;
 
s = "Hello";
o_text(s);
o_newline();
v = cat(s, ", World!");
o_text(v);
o_newline();
Output:
Hello
Hello, World!

[edit] AppleScript

try
set endMsg to "world!"
set totMsg to "Hello, " & endMsg
display dialog totMsg
end try

[edit] AutoHotkey

s := "hello"
Msgbox, %s%
s1 := s . " literal" ;the . is optional
Msgbox, %s1%

[edit] AWK

The AWK concatenation operator is nothing.

BEGIN {
s = "hello"
print s " literal"
s1 = s " literal"
print s1
}

[edit] ALGOL 68

Works with: ALGOL 68 version Revision 1 - no extensions to language used
Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny
Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8-8d
STRING s := "hello";
print ((s + " literal", new line));
STRING s1 := s + " literal";
print ((s1, new line))
Output:
hello literal
hello literal

[edit] BASIC

Works with: QuickBasic version 4.5
Works with: Liberty BASIC
s$ = "hello"
PRINT s$;" literal" 'or s$ + " literal"
s2$ = s$ + " literal"
PRINT s2$
Output:
hello literal
hello literal

[edit] Applesoft BASIC

S$ = "HELLO"
PRINT S$;" LITERAL" :REM OR S$ + " LITERAL"
S2$ = S$ + " LITERAL"
PRINT S2$

[edit] BBC BASIC

      stringvar1$ = "Hello,"
stringvar2$ = stringvar1$ + " world!"
PRINT "Variable 1 is """ stringvar1$ """"
PRINT "Variable 2 is """ stringvar2$ """"
Output:
Variable 1 is "Hello,"
Variable 2 is "Hello, world!"

[edit] ZX Spectrum Basic

10 LET s$="Hello"
20 LET s$=s$+" World!"
30 PRINT s$

[edit] Batch File

set string=Hello
echo %string% World
set string2=%string% World
echo %string2%

[edit] Bracmat

"Hello ":?var1 
& "World":?var2
& str$(!var1 !var2):?var12
& put$("var1=" !var1 ", var2=" !var2 ", var12=" !var12 "\n")
Output:
var1= Hello  , var2= World , var12= Hello World

[edit] Burlesque

blsq ) "Hello, ""world!"?+
"Hello, world!"

[edit] C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
char *sconcat(const char *s1, const char *s2)
{
char *s0 = malloc(strlen(s1)+strlen(s2)+1);
strcpy(s0, s1);
strcat(s0, s2);
return s0;
}
 
int main()
{
const char *s = "hello";
char *s2;
 
printf("%s literal\n", s);
/* or */
printf("%s%s\n", s, " literal");
 
s2 = sconcat(s, " literal");
puts(s2);
free(s2);
}

[edit] C++

#include <string>
#include <iostream>
 
int main() {
std::string s = "hello";
std::cout << s << " literal" << std::endl;
std::string s2 = s + " literal";
std::cout << s2 << std::endl;
return 0;
}
Output:
hello literal
hello literal

[edit] C#

using System;
 
class Program {
static void Main(string[] args) {
var s = "hello";
Console.Write(s);
Console.WriteLine(" literal");
var s2 = s + " literal";
Console.WriteLine(s2);
}
}

[edit] Clojure

(def a-str "abcd")
(println (str a-str "efgh"))
 
(def a-new-str (str a-str "efgh"))
(println a-new-str)

[edit] COBOL

With the STRING verb:

       IDENTIFICATION DIVISION.
PROGRAM-ID. Concat.
 
DATA DIVISION.
WORKING-STORAGE SECTION.
01 Str PIC X(7) VALUE "Hello, ".
01 Str2 PIC X(15).
 
PROCEDURE DIVISION.
DISPLAY "Str  : " Str
STRING Str " World!" DELIMITED BY SIZE INTO Str2
DISPLAY "Str2 : " Str2
 
GOBACK
.

Alternate method using the CONCATENATE intrinsic function:

       ...
PROCEDURE DIVISION.
DISPLAY "Str  : " Str
MOVE FUNCTION CONCATENATE(Str, " World!") TO Str2
DISPLAY "Str2 : " Str2
 
GOBACK
.

String literals can also be concatenated in the follwing ways:

*      *> Using a '&'.
01 Long-Str-Val PIC X(200) VALUE "Lorem ipsum dolor sit "
& "amet, consectetuer adipiscing elit, sed diam nonummy "
& "nibh euismod tincidunt ut laoreet dolore magna aliquam "
& "erat volutpat.".
 
* *> Using a '-' in column 7. Note the first two literals have no
* *> closing quotes.
01 Another-Long-Str PIC X(200) VALUE " Ut wisi enim ad minim
- "
veniam, quis nostrud exerci tation ullamcorper suscipit
- "lobortis nisl ut aliquip ex ea commodo consequat".

[edit] Common Lisp

(let ((s "hello"))
(format t "~a there!~%" s)
(let* ((s2 " there!")
(s (concatenate 'string s s2)))
(format t "~a~%" s)))
(defparameter *s* "hello")
(print (concatenate 'string *s* " literal"))
(defparameter *s1* (concatenate 'string *s* " literal"))
(print *s1*)

[edit] Component Pascal

BlackBox Component Builder

 
MODULE StringConcatenation;
IMPORT StdLog;
 
PROCEDURE Do*;
VAR
str1,str2: ARRAY 128 OF CHAR;
BEGIN
str1 := "Hello";
str2 := str1 + " world";
StdLog.String(":> " + str2);StdLog.Ln
END Do;
 
END StringConcatenation.
 

Execute: ^Q StringConcatenation.Do
Output:

:> Hello world

[edit] D

import std.stdio;
 
void main() {
string s = "hello";
writeln(s ~ " world");
auto s2 = s ~ " world";
writeln(s2);
}

[edit] Delphi

program Concat;
 
{$APPTYPE CONSOLE}
 
var
s1, s2: string;
begin
s1 := 'Hello';
s2 := s1 + ' literal';
WriteLn(s1);
WriteLn(s2);
end.

[edit] Déjà Vu

local :s1 "hello"
local :s2 concat( s1 ", world" )
!print s2
Output:
hello, world

[edit] DWScript

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

[edit] Dylan.NET

 
//to be compiled using dylan.NET v. 11.3.1.3 or later.
#refstdasm mscorlib.dll
 
import System
 
assembly concatex exe
ver 1.3.0.0
 
class public auto ansi Module1
 
method public static void main()
var s as string = "hello"
Console::Write(s)
Console::WriteLine(" literal")
var s2 as string = s + " literal"
Console::WriteLine(s2)
end method
 
end class

[edit] Elixir

 
s = "hello"
t = s <> " literal"
 
IO.puts s
IO.puts t
 

Output:

hello
hello literal

[edit] Erlang

S = "hello",
S1 = S ++ " literal",
io:format ("~s literal~n",[S]),
io:format ("~s~n",[S1])
Sample output:
hello literal
hello literal

[edit] Euphoria

sequence s, s1
s = "hello"
puts(1, s & " literal")
puts(1,'\n')
s1 = s & " literal"
print (1, s1))
puts(1,'\n')
Output:
hello literal
hello literal


[edit] Excel

Take three cells, say A1,B1 and C1. In C1, type in :

 
 
=CONCATENATE(A1;" ";B1)
 
 

As the text in A1 and/or B1 is changed, C1 will be updated.

 
Hello World Hello World
 


[edit] F#

Translation of: C#
open System
 
[<EntryPoint>]
let main args =
let s = "hello"
Console.Write(s)
Console.WriteLine(" literal")
let s2 = s + " literal"
Console.WriteLine(s2)
0

[edit] Factor

"wake up" [ " sheeple" append print ] [ ", you sheep" append ] bi print

[edit] Fantom

Illustrating in fansh:

fansh> a := "abc"
abc
fansh> b := a + "def"
abcdef
fansh> a
abc
fansh> b
abcdef

[edit] Forth

Works with: GNU Forth
s" hello" pad place
pad count type
s" there!" pad +place \ +place is called "append" on some Forths
pad count type

[edit] Fortran

program StringConcatenation
 
integer, parameter :: maxstringlength = 64
character (maxstringlength) :: s1, s = "hello"
 
print *,s // " literal"
s1 = trim(s) // " literal"
print *,s1
 
end program

[edit] Frink

 
a = "Frink"
b = a + " rules!"
println[b]
 

[edit] Gambas

In gambas, the ampersand symbol is used as a concatenation operator:

DIM bestclub AS String
DIM myconcat AS String
bestclub = "Liverpool"
myconcat = bestclub & " Football Club"

[edit] Go

package main
 
import "fmt"
 
func main() {
// text assigned to a string variable
s := "hello"
 
// output string variable
fmt.Println(s)
 
// this output requested by original task descrption, although
// not really required by current wording of task description.
fmt.Println(s + " literal")
 
// concatenate variable and literal, assign result to another string variable
s2 := s + " literal"
 
// output second string variable
fmt.Println(s2)
}
Output:
hello
hello literal
hello literal

[edit] Golfscript

"Greetings ":s;
s"Earthlings"+puts
s"Earthlings"+:s1;
s1 puts

[edit] Groovy

def s = "Greetings "
println s + "Earthlings"
 
def s1 = s + "Earthlings"
println s1
Output:
Greetings Earthlings
Greetings Earthlings

[edit] Haskell

import System.IO
s = "hello"
s1 = s ++ " literal"
main = do putStrLn (s ++ " literal")
putStrLn s1

[edit] HicEst

CHARACTER s = "hello", sl*100
 
WRITE() s // " literal"
sl = s // " literal"
WRITE() sl

[edit] Icon and Unicon

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

[edit] IDL

s1='Hello'
print, s1 + ' literal'
s2=s1 + ' literal'
print, s2

[edit] J

   s1 =. 'Some '
]s1, 'text '
Some text
]s2 =. s1 , 'more text!'
Some more text!

For more info see:

[edit] Java

public class Str{
public static void main(String[] args){
String s = "hello";
System.out.println(s + " literal");
String s2 = s + " literal";
System.out.println(s2);
}
}
Output:
hello literal
hello literal

[edit] JavaScript

var s = "hello"
print(s + " there!")

[edit] jq

"hello" as $s | $s + " there!"
Output:
# Use the -r command-line option if you wish 
# to suppress the string quotation marks
hello there!

[edit] Julia

s = "hello"
println(s * " there!")

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

LV strcat.png

[edit] Lang5

: concat  2 compress "" join ;
'hello " literal" concat


[edit] Lasso

local(x = 'Hello')
local(y = #x + ', World!')
#x // Hello
#y // Hello, World!

[edit] Liberty BASIC

See BASIC.

[edit] Lisaac

Section Header
 
+ name := STRING_CONCATENATION;
 
Section Public
 
- main <- (
+ sc : STRING_CONSTANT;
+ sv : STRING;
 
sc := "Hello";
(sc + " literal").println;
 
sv := sc + " literal";
sv.println;
 
);

[edit]

make "s "hello
print word :s "| there!|

[edit] lua

a = "hello "
print(a .. "world")
c = a .. "world"
print(c)

[edit] Maple

str := "Hello":
newstr := cat(str,", world!"):
str;
newstr;

Output:

                            "Hello"
                        "Hello, world!"

[edit] Mathematica

str= "Hello ";
str<>"Literal"

[edit] MATLAB / Octave

>> string1 = '1 Fish'
 
string1 =
 
1 Fish
 
>> string2 = [string1 ', 2 Fish, Red Fish, Blue Fish']
 
string2 =
 
1 Fish, 2 Fish, Red Fish, Blue Fish

[edit] Maxima

s: "the quick brown fox";
t: "jumps over the lazy dog";
sconcat(s, " ", t);
/* "the quick brown fox jumps over the lazy dog" */

[edit] Mercury

:- module string_concat.
:- interface.
 
:- import_module io.
:- pred main(io::di, io::uo) is det.
 
:- implementation.
:- import_module string.
 
main(!IO) :-
S = "hello",
S1 = S ++ " world",
io.write_string(S, !IO), io.nl(!IO),
io.write_string(S1, !IO), io.nl(!IO).

[edit] MUMPS

STRCAT
SET S="STRING"
WRITE !,S
SET T=S_" LITERAL"
WRITE !,T
QUIT
Output:
CACHE>D STRCAT^ROSETTA
 
STRING
STRING LITERAL

[edit] M4

M4 has macros rather than variables, but a macro expanded can work like a variable.

define(`concat',`$1$2')dnl
define(`A',`any text value')dnl
concat(`A',` concatenated with string literal')
define(`B',`concat(`A',` and string literal')')dnl
B

[edit] MAXScript

s = "hello"
print (s + " literal")
s1 = s + " literal"
print s1

[edit] Metafont

string a, b;
a := "String";
message a & " literal";
b := a & " literal";
message b;

[edit] Modula-3

Strings in Modula-3 are called TEXTs. Concatenation can use &, just like Ada.

MODULE Concat EXPORTS Main;
 
IMPORT IO;
 
VAR string: TEXT := "String";
string1: TEXT;
 
BEGIN
IO.Put(string & " literal.\n");
string1 := string & " literal.\n";
IO.Put(string1);
END Concat.

Modula-3 also provides modules for dealing with TEXTs, such as Text.

string1 := Text.Concat(string, " literal.\n");

[edit] Nemerle

Can be done with Concat() method or + operator:

using System;
using System.Console;
using Nemerle.Utility.NString; // contains method Concat()
 
module Stringcat
{
Main() : void
{
def text1 = "This string has";
def cat1 = Concat( " ", [text, "been concatenated"]);
def cat2 = text1 + " also been concatenated";
Write($"$cat1\n$cat2\n");
}
}

[edit] NetRexx

/* NetRexx */
 
options replace format comments java crossref savelog symbols
 
s1 = 'any text value'
s2 = 'another string literal'
s3 = s1 s2 -- concatenate variables with blank space (note that only one blank space is added)
s4 = s1 || s2 -- concatenate variables with abuttal (here, no blank spaces are added)
s5 = s1 'another string literal' -- concatenate a variable and a literal with blank space
s6 = s1'another string literal' -- concatenate a variable and a literal using abuttal
s7 = s1 || 'another string literal' -- ditto
 
say 's1:' s1 -- concatenation with blank space is employed here too
say 's2:' s2
say 's3:' s3
say 's4:' s4
say 's5:' s5
say 's6:' s6
say 's7:' s7
 
Output:
s1: any text value
s2: another string literal
s3: any text value another string literal
s4: any text valueanother string literal
s5: any text value another string literal
s6: any text valueanother string literal
s7: any text valueanother string literal

[edit] Nimrod

Strings can be concatenated with &.

var str, str1 = "String"
echo(str & " literal.")
str1 = str1 & " literal."
echo(str1)
 
# -> String literal.

Strings can be concatenated as arrays and joined with a separating characters:

var str1 = "String"
echo(join([str1, " literal.", "HelloWorld!"], "~~"))
 
# -> String~~ literal.~~HelloWorld!

Strings can be combined using string formatting:

var str1 = "String"
echo "$# $# $#" % [str1, "literal.", "HelloWorld!"]
 
# -> String literal. HelloWorld!

[edit] Objeck

bundle Default {
class Repeat {
function : Main(args : String[]) ~ Nil {
s := "hello";
s->PrintLine();
" literal"->PrintLine();
s->Append(" literal");
s->PrintLine();
}
}
}

[edit] Objective-C

#import <Foundation/Foundation.h>
 
int main()
{
@autoreleasepool {
 
NSString *s = @"hello";
printf("%s%s\n", [s UTF8String], " literal");
 
NSString *s2 = [s stringByAppendingString:@" literal"];
// or, NSString *s2 = [NSString stringWithFormat:@"%@%@", s, @" literal"];
puts([s2 UTF8String]);
/* or */
NSMutableString *s3 = [NSMutableString stringWithString: s];
[s3 appendString: @" literal"];
puts([s3 UTF8String]);
 
}
return 0;
}

[edit] OCaml

let s = "hello"
let s1 = s ^ " literal"
let () =
print_endline (s ^ " literal");
(* or Printf.printf "%s literal\n" s; *)
print_endline s1

[edit] Openscad

a="straw";
b="berry";
c=str(a,b); /* Concatenate a and b */
echo (c);

[edit] Oz

Strings are lists and are concatenated with the "Append" function. However, often "virtual strings" are used instead. "Virtual string are designed as a convenient way to combine strings, byte strings, atoms, integers and floats to compound strings without explicit concatenation and conversion".

declare
S = "hello"
{System.showInfo S#" literal"} %% virtual strings are constructed with "#"
S1 = {Append S " literal"}
{System.showInfo S1}

[edit] PARI/GP

s = "Hello ";
s = Str(s, "world");
\\ Alternately, this could have been:
\\ s = concat(s, "world");
print(s);

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

[edit] Perl

my $s = 'hello';
print $s . ' literal', "\n";
my $s1 = $s . ' literal';
print $s1, "\n";

An example of destructive concatenation:

$s .= ' literal';
print $s, "\n";

[edit] Perl 6

Works with: Rakudo version #22 "Thousand Oaks"
my $s = 'hello';
say $s ~ ' literal';
my $s1 = $s ~ ' literal';
say $s1;

An example of mutating concatenation:

$s ~= ' literal';
say $s;

Note also that most concatenation in Perl is done implicitly via interpolation.

[edit] PHL

module stringcat;
 
extern printf;
 
@Integer main [
var a = "hello";
var b = a + " literal";
printf("%s\n", b);
 
return 0;
]

[edit] PHP

<?php
$s = "hello";
echo $s . " literal" . "\n";
$s1 = $s . " literal";
echo $s1 . "\n";
?>

[edit] PicoLisp

(let Str1 "First text"
(prinl Str1 " literal")
(let Str2 (pack Str1 " literal")
(prinl Str2) ) )

[edit] PL/I

declare (s, t) character (30) varying;
 
s = 'hello from me';
display (s || ' to you.' );
t = s || ' to you all';
display (t);

[edit] PowerShell

$s = "Hello"
Write-Host $s World.
 
# alternative, using variable expansion in strings
Write-Host "$s World."
 
$s2 = $s + " World."
Write-Host $s2

[edit] PureBasic

If OpenConsole()
 
s$ = "hello"
PrintN( s$ + " literal")
s2$ = s$ + " literal"
PrintN(s2$)
 
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit")
Input()
CloseConsole()
EndIf

[edit] Python

s1 = "hello"
print s1 + " world"
 
s2 = s1 + " world"
print s2
Output:
hello world
hello world

When concatenating many strings, it is more efficient to use the join method of a string object, which takes a list of strings to be joined. The string on which join is called is used as a separator.

s1 = "hello"
print ", ".join([s1, "world", "mom"])
 
s2 = ", ".join([s1, "world", "mom"])
print s2
Output:
hello, world
hello, world

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

[edit] Racket

#lang racket
(define hello "hello")
(displayln hello)
 
(define world (string-append hello " " "world" "!"))
(displayln world)
 
;outputs:
; hello
; hello world!

[edit] Raven

# Cat strings
"First string and " "second string" cat print
 
# Join
[ "First string" "second string" "third string" ] " and " join print
 
# print
[ "First string" "second string" "third string" ] each print
 
# Formatted print
"\n" "Third string" "Second string" "First string" "%s %s %s %s" print
 
# Heredoc
" - NOT!!" as $x
"This is the only way to do it%($x)s" print
Output:
First string and second string
First string and second string and third string
First stringsecond stringthird string
First string Second string Third string 

This is the only way to do it - NOT!!

[edit] REBOL

s: "hello"
print s1: rejoin [s " literal"]
print s1

[edit] REXX

s = "hello"
say s "literal"
t = s "literal" /* Whitespace between the two strings causes a space in the output */
say t
 
/* The above method works without spaces too */
genus="straw"
say genus"berry" /* This outputs strawberry */
say genus || "berry" /* Concatenation using a doublepipe does not cause spaces */

[edit] Retro

with strings'
"hello" "literal" append puts

[edit] Ruby

s = "hello"
p s + " literal" #=> "hello literal"
s1 = s + " literal"
p s1 #=> "hello literal"
s1 << " another" # append to s1
p s1 #=> "hello literal another"
 
s = "hello"
p s.concat(" literal") #=> "hello literal"
p s #=> "hello literal"

[edit] Rust

/*
* String concatenation in Rust.
* Copyright by Shlomi Fish, 2013.
* Released under the MIT/X11 License
* ( http://en.wikipedia.org/wiki/MIT_License ).
* */
 
// rust 0.8
 
fn main() {
let s = ~"hello";
println!("s={}", s + " world");
 
let s1 = s + " world";
println!("s1={}", s1);
 
let mut mutable_s = ~"hello";
mutable_s.push_str(" world");
println!("mutable_s={}", mutable_s);
}

[edit] SAS

data _null_;
a="Hello,";
b="World!";
c=a !! " " !! b;
put c;
*Alternative using the catx function;
c=catx (" ", a, b);
put c;
run;

[edit] Sather

class MAIN is
main is
s ::= "hello";
#OUT + s + " literal\n";
s2 ::= s + " literal";
#OUT + s2 + "\n";
end;
end;

[edit] Scala

Evaluation in a Scala worksheet, to val f2 is an anonymous function assigned.

  val s = "hello"                                 //> s  : String = hello
val s2 = s + " world" //> s2  : String = hello world
val f2 = () => " !" //> f2  : () => String = <function0>
 
println(s2 + f2()) //> hello world !

[edit] Scheme

(define s "hello")
(display (string-append s " literal"))
(newline)
(define s1 (string-append s " literal"))
(display s1)
(newline)

[edit] Seed7

$ include "seed7_05.s7i";
 
const proc: main is func
local
var string: s is "hello";
var string: s2 is "";
begin
writeln(s <& " world");
s2 := s & " world";
writeln(s2);
end func;
Output:
hello world
hello world

[edit] Slate

define: #s -> 'hello'.
inform: s ; ' literal'.
define: #s1 -> (s ; ' literal').
inform: s1.

[edit] Smalltalk

|s s1| s := 'hello'.
(s,' literal') printNl.
s1 := s,' literal'.
s1 printNl.

[edit] SNOBOL4

	greet1 = "Hello, "
output = greet1
greet2 = greet1 "World!"
output = greet2
end

[edit] Sparkling

let s1 = "Hello";
let s2 = " world!";
print(s1 .. s2); // prints "Hello world!"

[edit] Standard ML

val s = "hello"
val s1 = s ^ " literal\n"
val () =
print (s ^ " literal\n");
print s1

[edit] Swift

let s = "hello"
println(s + " literal")
let s1 = s + " literal"
println(s1)

[edit] Tcl

set s hello
puts "$s there!"
append s " there!"
puts $s

You can also just group the strings to concatenate together at the point where they are used, using Tcl's built-in syntactic concatenation:

set s "Hello "
set t "World"
set u "!"
puts $s$t$u ;# There is nothing special here about using puts; just an example

[edit] TI-89 BASIC

"aard" → sv
Disp sv & "vark"
sv & "wolf" → sv2

[edit] TorqueScript

%string = "Hello";
echo(%string);
%other = " world!";
echo(%other);
echo(%string @ %other);

[edit] TUSCRIPT

$$ MODE TUSCRIPT
s = "Hello "
print s, "literal"
 
s1 = CONCAT (s,"literal")
print s1
Output:
Hello literal
Hello literal 

[edit] UNIX Shell

Works with: Bourne Shell
Works with: bash
s="hello"
echo "$s literal"
s1="$s literal" # This method only works with a space between the strings
echo $s1
 
# To concatenate without the space we need squiggly brackets:
genus='straw'
fruit=${genus}berry # This outputs the word strawberry
echo $fruit

[edit] UnixPipes

echo "hello" 
| xargs -n1 -i echo {} literal

[edit] Visual Basic .NET

Platform: .NET

Works with: Visual Basic .NET version 9.0+
s = "Hello"
Console.WriteLine(s & " literal")
s1 = s + " literal"
Console.WriteLine(s1)

[edit] XPL0

func Concat(S1, S2, S3);        \Concatenate strings: S3:= S1 + S2
char S1, S2, S3;
int C, I, J;
[I:= 0;
repeat C:= S1(I);
S3(I):= C & $7F; \remove MSb terminator from first string
I:= I+1;
until C >= $80;
J:= 0;
repeat C:= S2(J);
S3(I+J):= C;
J:= J+1;
until C >= $80;
return S3;
];
 
code Text=12;
char A, B, C(80);
[A:= "Hello";
B:= " World!";
Concat(A, B, C);
Text(0, C);
]

[edit] Yorick

var1 = "Hello";
var2 = var1 + ", world!";
write, var1;
write, var2;

[edit] zkl

var s="Hello";
s2:=s+", world!"; s2.println(); //-->Hello, world!
s3:=String(s," ",s2); s3.println(); //-->Hello Hello, world!
Personal tools
Namespaces

Variants
Actions
Community
Explore
Misc
Toolbox