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.

 

 

{{Template:Strings}}

 

=={{header|ABAP}}==

s2 TYPE string.

 

WRITE: / s1.

WRITE: / s2.

{{out}}

<pre>

Hello

Hello literal

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

Variable 2 is "Hello, world!"</pre>

 

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

 

=={{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|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|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|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|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),

 

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

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