String concatenation: Difference between revisions

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.

 

{{Template:Strings}}

 

=={{header|ABAP}}==

s2 TYPE string.

 

WRITE: / s1.

WRITE: / s2.

{{out}}

<pre>

</pre>

===Another way===

 

DATA(var1) = 'Hello'.

)->write( |{ var1 } world!|

)->display( ).

{{out}}

<pre>

Hello literal

Hello world!

</pre>

 

=={{header|ActionScript}}==

{

public class Str

}

}

 

=={{header|Ada}}==

 

procedure String_Concatenation is

Put_Line (S1);

Put_Line (S2);

{{out|Sample output}}

<pre>

 

=={{header|Aime}}==

 

s = "Hello";

{{out}}

<pre>Hello

Hello, World!</pre>

 

 

=={{header|Apex}}==

 

String s1 = 'Hello ';

String s2 = 'Salesforce Developer!';

 

// Print output

{{out}}

<pre>Hello Salesforce Developer!</pre>

 

=={{header|AppleScript}}==

set endMsg to "world!"

set totMsg to "Hello, " & endMsg

display dialog totMsg

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program strConcat.s */

bx lr @ return

 

 

=={{header|AutoHotkey}}==

Msgbox, %s%

s1 := s . " literal" ;the . is optional

 

=={{header|AWK}}==

The AWK concatenation operator is nothing.

s = "hello"

print s " literal"

s1 = s " literal"

print s1

 

=={{header|Axe}}==

Copy(r₁,L₁,length(r₁))

Copy(r₂,L₁+length(r₁),length(r₂)+1)

L₁

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

{{works with|Liberty BASIC}}

s2$ = s$ + " literal"

{{out}}

<pre>hello literal

hello literal</pre>

 

==={{header|Applesoft BASIC}}===

 

==={{header|BBC BASIC}}===

stringvar2$ = stringvar1$ + " world!"

PRINT "Variable 1 is """ stringvar1$ """"

{{out}}

<pre>Variable 1 is "Hello,"

 

==={{header|IS-BASIC}}===

110 LET S$=S$&" world!"

 

==={{header|ZX Spectrum Basic}}===

20 LET s$=s$+" World!"

 

=={{header|Batch File}}==

echo %string% World

set string2=%string% World

 

=={{header|Bracmat}}==

& "World":?var2

& str$(!var1 !var2):?var12

{{out}}

<pre>var1= Hello , var2= World , var12= Hello World</pre>

 

=={{header|Burlesque}}==

 

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

puts(s2);

free(s2);

 

=={{header|C++}}==

#include <iostream>

 

std::cout << s2 << std::endl;

return 0;

{{out}}

<pre>hello literal

hello literal</pre>

 

 

=={{header|Clojure}}==

(println (str a-str "efgh"))

 

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

 

=={{header|COBOL}}==

With the <code>STRING</code> verb:

PROGRAM-ID. Concat.

 

 

GOBACK

Alternate method using the <code>CONCATENATE</code> intrinsic function:

PROCEDURE DIVISION.

DISPLAY "Str : " Str

 

GOBACK

 

String literals can also be concatenated in the follwing ways:

01 Long-Str-Val PIC X(200) VALUE "Lorem ipsum dolor sit "

& "amet, consectetuer adipiscing elit, sed diam nonummy "

01 Another-Long-Str PIC X(200) VALUE " Ut wisi enim ad minim

- "veniam, quis nostrud exerci tation ullamcorper suscipit

 

=={{header|Common Lisp}}==

(format t "~a there!~%" s)

(let* ((s2 " there!")

(s (concatenate 'string s s2)))

(print (concatenate 'string *s* " literal"))

(defparameter *s1* (concatenate 'string *s* " literal"))

 

=={{header|Component Pascal}}==

BlackBox Component Builder

MODULE StringConcatenation;

IMPORT StdLog;

 

END StringConcatenation.

Execute: ^Q StringConcatenation.Do<br/>

{{out}}

:> Hello world

</pre>

=={{header|D}}==

void main() {

auto s2 = s ~ " world";

writeln(s2);

=={{header|DCL}}==

$ string2 = string1 + " world"

{{out}}

<pre> STRING1 = "hello"

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

WriteLn(s1);

WriteLn(s2);

 

=={{header|DWScript}}==

var s2 := s1 + ' World';

 

PrintLn(s1);

 

=={{header|Dylan.NET}}==

//to be compiled using dylan.NET v. 11.5.1.2 or later.

#refstdasm mscorlib.dll

end method

 

=={{header|Ela}}==

Strings in Ela support a polymorphic concatenation operator (++):

hello'world = hello ++ ", " ++ "world"

{{out}}

<pre>("Hello", "Hello, world!")</pre>

a large number of concatenations. Therefore one can use an alternate technique (a pure StringBuilder

type defined in standard prelude). The resulting code would look like so:

The (+>) token is a type constructor. Therefore the result of its application is an instance of type

StringBuilder. In order to produce a string one should call a polymorphic toString function at the end

 

=={{header|Elena}}==

{

var s := "Hello";

var s2 := s + " literal";

console.readChar()

{{out}}

<pre>

Hello

Hello literal

</pre>

 

=={{header|Elixir}}==

s = "hello"

t = s <> " literal"

IO.puts s

IO.puts t

{{out}}

<pre>

 

=={{header|Emacs Lisp}}==

 

=={{header|Erlang}}==

S1 = S ++ " literal",

io:format ("~s literal~n",[S]),

{{out|Sample output}}

<pre>

 

=={{header|ERRE}}==

..........

S$="HELLO"

PRINT(S2$)

..........

 

=={{header|Euphoria}}==

s = "hello"

puts(1, s & " literal")

s1 = s & " literal"

print (1, s1))

{{out}}

hello literal

hello literal

 

=={{header|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

 

=={{header|F_Sharp|F#}}==

{{trans|C#}}

 

[<EntryPoint>]

let s2 = s + " literal"

Console.WriteLine(s2)

 

=={{header|Factor}}==

 

=={{header|Falcon}}==

'''VBA/Python programmer's approach. I'm just a junior Falconeer but this code seems falconic''

/* created by Aykayayciti Earl Lamont Montgomery

April 9th, 2018 */

s2 = s + " literal"

> s2

{{out}}

<pre>

=={{header|Fantom}}==

Illustrating in <tt>fansh</tt>:

abc

fansh> b := a + "def"

abc

fansh> b

 

=={{header|Forth}}==

{{works with|GNU Forth}}

pad count type

s" there!" pad +place \ +place is called "append" on some Forths

 

=={{header|Fortran}}==

 

integer, parameter :: maxstringlength = 64

print *,s1

 

 

=={{header|FreeBASIC}}==

 

Var s1 = "String"

Print s1

Print s2

 

{{out}}

 

=={{header|Frink}}==

a = "Frink"

b = a + " rules!"

println[b]

 

=={{header|Gambas}}==

 

'''[https://gambas-playground.proko.eu/?gist=098450adbbe0e284f0b9cdac67d74dda Click this link to run this code]'''

DIM bestclub AS String

DIM myconcat AS String

Print myconcat

 

 

=={{header|GlovePIE}}==

 

=={{header|Go}}==

 

import "fmt"

// output second string variable

fmt.Println(s2)

{{out}}

<pre>

 

=={{header|Golfscript}}==

s"Earthlings"+puts

s"Earthlings"+:s1;

 

=={{header|Groovy}}==

println s + "Earthlings"

 

def s1 = s + "Earthlings"

{{out}}

<pre>Greetings Earthlings

=={{header|Halon}}==

The dot (concatenation) operator may cast datatypes to strings.

 

=={{header|Haskell}}==

s = "hello"

s1 = s ++ " literal"

main = do putStrLn (s ++ " literal")

 

=={{header|HicEst}}==

 

WRITE() s // " literal"

sl = s // " literal"

 

=={{header|Icon}} and {{header|Unicon}}==

s1 := "hello"

write(s2 := s1 || " there.") # capture the reuslt for

write(s2) # ... the 2nd write

 

=={{header|IDL}}==

print, s1 + ' literal'

s2=s1 + ' literal'

 

=={{header|J}}==

]s1, 'text '

Some text

]s2 =. s1 , 'more text!'

For more info see:

* http://www.jsoftware.com/help/dictionary/d320.htm on <code>,</code>

 

=={{header|Java}}==

public static void main(String[] args){

String s = "hello";

System.out.println(s2);

}

{{out}}

<pre>hello literal

 

=={{header|JavaScript}}==

 

=={{header|jq}}==

{{Out}}

# Use the -r command-line option if you wish

# to suppress the string quotation marks

hello there!

=={{header|Julia}}==

 

=={{header|K}}==

Translation of <b>J</b> code:

s1: "Some "

s1, "text "

s2: s1 , "more text!"

{{out}}

<pre>

 

=={{header|Kotlin}}==

val s1 = "James"

val s2 = "Bond"

val s3 = s1 + " " + s2

println(s3)

{{Out}}

<pre>James

[[File:LV_strcat.png]]

 

 

 

=={{header|Lasso}}==

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

#x // Hello

 

=={{header|Liberty BASIC}}==

 

=={{header|Lingo}}==

b = a & " world!"

put b

 

=={{header|Lisaac}}==

 

+ name := STRING_CONCATENATION;

sv.println;

 

 

=={{header|LiveCode}}==

put str & "code" into str2

Output<pre>live livecode</pre>

 

=={{header|Logo}}==

 

=={{header|Lua}}==

print(a .. "world")

c = a .. "world"

 

=={{header|M2000 Interpreter}}==

A memory word is two bytes.

 

Module CheckString {

s$ = "hello"

}

CheckString

 

=={{header|Maple}}==

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

str;

{{out}}

<pre>

</pre>

 

 

=={{header|MATLAB}} / {{header|Octave}}==

 

string1 =

string2 =

 

 

=={{header|Maxima}}==

t: "jumps over the lazy dog";

sconcat(s, " ", t);

 

=={{header|Mercury}}==

:- interface.

 

S1 = S ++ " world",

io.write_string(S, !IO), io.nl(!IO),

 

=={{header|min}}==

{{works with|min|0.19.3}}

(a "scotch")=> "" join :b

a puts!

{{out}}

<pre>

</pre>

 

 

 

 

 

=={{header|Modula-3}}==

Strings in Modula-3 are called <code>TEXT</code>s. Concatenation can use <code>&</code>, just like [[Ada]].

 

IMPORT IO;

string1 := string & " literal.\n";

IO.Put(string1);

Modula-3 also provides modules for dealing with <code>TEXT</code>s, such as <code>Text</code>.

 

=={{header|Neko}}==

String concatenation, in Neko

Tectonics:

$print("addon: ", addon, "\n")

$print("c: ", c, "\n")

 

{{out}}

=={{header|Nemerle}}==

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

using System.Console;

using Nemerle.Utility.NString; // contains method Concat()

Write($"$cat1\n$cat2\n");

}

 

=={{header|NetRexx}}==

 

options replace format comments java crossref savelog symbols

say 's6:' s6

say 's7:' s7

{{out}}

<pre>

 

=={{header|NewLISP}}==

(println str1)

(let (str2 (string str1 "bar"))

 

=={{header|Nim}}==

Strings can be concatenated with <code>&</code>.

 

 

 

 

Strings can be combined using string formatting:

 

 

=={{header|Objeck}}==

class Repeat {

function : Main(args : String[]) ~ Nil {

}

}

 

=={{header|Objective-C}}==

 

int main()

}

return 0;

 

=={{header|OCaml}}==

let s1 = s ^ " literal"

let () =

print_endline (s ^ " literal");

 

=={{header|Oforth}}==

 

.s show the stack :

 

{{out}}

 

=={{header|Openscad}}==

b="berry";

c=str(a,b); /* Concatenate a and b */

 

=={{header|Oz}}==

Strings are lists and are concatenated with the "Append" function. However, often "virtual strings" are used instead. [http://www.mozart-oz.org/home/doc/base/virtualstring.html "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"].

S = "hello"

{System.showInfo S#" literal"} %% virtual strings are constructed with "#"

S1 = {Append S " literal"}

 

=={{header|PARI/GP}}==

s = Str(s, "world");

\\ Alternately, this could have been:

\\ s = concat(s, "world");

 

=={{header|Pascal}}==

Var

s, s1 : String;

{ s1 := s + ' literal'; works too, with FreePascal }

writeln(s1);

 

=={{header|Perl}}==

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

my $s1 = $s . ' literal';

An example of destructive concatenation:

 

=={{header|Phix}}==

{{out}}

<pre>

"The cat sat on the mat."

</pre>

 

=={{header|PHL}}==

 

 

extern printf;

 

return 0;

 

=={{header|PHP}}==

$s = "hello";

echo $s . " literal" . "\n";

$s1 = $s . " literal";

echo $s1 . "\n";

 

=={{header|PicoLisp}}==

(prinl Str1 " literal")

(let Str2 (pack Str1 " literal")

 

=={{header|PL/I}}==

 

s = 'hello from me';

display (s || ' to you.' );

t = s || ' to you all';

 

=={{header|PowerShell}}==

Write-Host $s World.

 

 

$s2 = $s + " World."

 

=={{header|PureBasic}}==

s$ = "hello"

PrintN( s$ + " literal")

Input()

CloseConsole()

 

=={{header|Python}}==

print s1 + " world"

 

s2 = s1 + " world"

{{out}}

<pre>hello world

hello world</pre>

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.

print ", ".join([s1, "world", "mom"])

 

s2 = ", ".join([s1, "world", "mom"])

{{out}}

<pre>hello, world, mom

hello, world, mom</pre>

 

=={{header|R}}==

paste(hello, "literal") # "hello literal"

hl <- paste(hello, "literal") #saves concatenates string to a new variable

 

=={{header|Racket}}==

(define hello "hello")

(displayln hello)

;outputs:

; hello

 

=={{header|Raven}}==

"First string and " "second string" cat print

 

# Heredoc

" - NOT!!" as $x

{{out}}

<pre>First string and second string

 

=={{header|REBOL}}==

print s1: rejoin [s " literal"]

 

=={{header|Red}}==

>>str2: append str1 " World"

>> print str2

Hello World

>> print str1

 

=={{header|REXX}}==

say s "literal"

say t

 

 

=={{header|Ring}}==

aString = "Welcome to the "

bString = "Ring Programming Language"

 

see astring + bString + nl

 

=={{header|Ruby}}==

 

s = "hello"

 

=={{header|Rust}}==

let s = "hello".to_owned();

println!("{}", s);

let s1 = s + " world";

println!("{}", s1);

 

=={{header|SAS}}==

a="Hello,";

b="World!";

c=catx (" ", a, b);

put c;

 

=={{header|Sather}}==

main is

s ::= "hello";

#OUT + s2 + "\n";

end;

 

=={{header|Scala}}==

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

val s2 = s + " world" //> s2 : String = hello world

val f2 = () => " !" //> f2 : () => String = <function0>

 

 

=={{header|Scheme}}==

(display (string-append s " literal"))

(newline)

(define s1 (string-append s " literal"))

(display s1)

 

=={{header|Scilab}}==

s1+" world!"

s2=s1+" world"

s2

{{out}}

<pre style="height:20ex> --> s1="Hello"

Hello world! </pre>

 

 

=={{header|Seed7}}==

const proc: main is func

s2 := s & " world";

writeln(s2);

{{out}}

<pre>

 

=={{header|Sidef}}==

say s+' literal';

var s1 = s+' literal';

An example of destructive concatenation:

=={{header|Simula}}==

TEXT head, tail;

BEGIN TEXT c;

another :- concatenate(stringVariable, "and tail");

OutText("stringVariable: """); OutText(stringVariable);

 

=={{header|Slate}}==

inform: s ; ' literal'.

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

 

=={{header|Smalltalk}}==

(s,' literal') printNl.

s1 := s,' literal'.

 

=={{header|SNOBOL4}}==

output = greet1

greet2 = greet1 "World!"

output = greet2

 

=={{header|Sparkling}}==

let s2 = " world!";

 

=={{header|Standard ML}}==

val s1 = s ^ " literal\n"

val () =

print (s ^ " literal\n");

 

=={{header|Stata}}==

=== Stata string scalars ===

sca b = "bar"

sca c = a+b

di c

 

=== Mata ===

b = "bar"

c = a+b

c

 

=={{header|Swift}}==

println(s + " literal")

let s1 = s + " literal"

 

=={{header|Tcl}}==

puts "$s there!"

append s " there!"

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 t "World"

set u "!"

 

=={{header|TI-83 BASIC}}==

{{out}}

<pre>HELLO WORLD!</pre>

 

=={{header|TI-89 BASIC}}==

Disp sv & "vark"

 

=={{header|TorqueScript}}==

echo(%string);

%other = " world!";

echo(%other);

 

=={{header|TUSCRIPT}}==

s = "Hello "

print s, "literal"

 

s1 = CONCAT (s,"literal")

{{out}}

<pre>

Hello literal

</pre>

 

=={{header|UNIX Shell}}==

{{works with|Bourne Shell}} {{works with|bash}}

echo "$s literal"

s1="$s literal" # This method only works with a space between the strings

genus='straw'

fruit=${genus}berry # This outputs the word strawberry

 

=={{header|UnixPipes}}==

 

=={{header|Ursa}}==

# make s1 contain "hello "

set s1 "hello "

 

# outputs "hello world"

 

 

 

=={{header|VBA}}==

 

Option Explicit

 

Debug.Print str2 & " based on concatenation of : " & str1 & " and code..."

End Sub

{{out}}

<pre>

Rosetta code!

Rosetta code... based on concatenation of : Rosetta and code...</pre>

 

=={{header|Wee Basic}}==

let string2$="world!"

print 1 string1$+string2$

 

=={{header|XPL0}}==

char S1, S2, S3;

int C, I, J;

Concat(A, B, C);

Text(0, C);

 

=={{header|Yorick}}==

var2 = var1 + ", world!";

write, var1;

 

=={{header|zkl}}==

s2:=s+", world!"; s2.println(); //-->Hello, world!

 

 

{{omit from|dc|No string operations in dc}}

[[Wikipedia::https://en.wikipedia.org/wiki/Comparison_of_programming_languages_%28string_functions%29#Concatenation]]