String concatenation: Difference between revisions

Content added Content deleted

Inline

Revision as of 18:36, 17 April 2021

Task

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.

Other tasks related to string operations:

Metrics

Counting

Remove/replace

Anagrams/Derangements/shuffling

Find/Search/Determine

Formatting

Song lyrics/poems/Mad Libs/phrases

Tokenize

Sequences

11l

Translation of: Python

<lang 11l>V s1 = ‘hello’ print(s1‘ world’) V s2 = s1‘ world’ print(s2)</lang>

Output:

hello world
hello world

AArch64 Assembly

Works with: as version Raspberry Pi 3B version Buster 64 bits

<lang AArch64 Assembly> /* ARM assembly AARCH64 Raspberry PI 3B */ /* program concatStr64.s */

/*******************************************/ /* Constantes file */ /*******************************************/ /* for this file see task include a file in language AArch64 assembly*/ .include "../includeConstantesARM64.inc" /*******************************************/ /* Initialized data */ /*******************************************/ .data szMessFinal: .asciz "The final string is \n"

szString: .asciz "Hello " szString1: .asciz " the world. \n" /*******************************************/ /* UnInitialized data */ /*******************************************/ .bss szFinalString: .skip 255 /*******************************************/ /* code section */ /*******************************************/ .text .global main main:

                                  // load string 
   ldr x1,qAdrszString
   ldr x2,qAdrszFinalString
   mov x4,0

1:

   ldrb w0,[x1,x4]                // load byte of string
   strb w0,[x2,x4]
   cmp x0,0                       // compar with zero ?
   add x3,x4,1
   csel x4,x3,x4,ne               // if x0 <> 0 x4 = x4 +1 sinon x4
   bne 1b
   ldr x1,qAdrszString1
   mov x3,0

2:

   ldrb w0,[x1,x3]                // load byte of string 1
   strb w0,[x2,x4]
   cmp x0,0                       // compar with zero ?
   add x5,x4,1
   csel x4,x5,x4,ne
   add x5,x3,1
   csel x3,x5,x3,ne
   bne 2b
   mov x0,x2                      // display final string
   bl affichageMess

100: // standard end of the program */

   mov x0,0                       // return code
   mov x8,EXIT                    // request to exit program
   svc 0                          // perform the system call

qAdrszString: .quad szString qAdrszString1: .quad szString1 qAdrszFinalString: .quad szFinalString qAdrszMessFinal: .quad szMessFinal /********************************************************/ /* File Include fonctions */ /********************************************************/ /* for this file see task include a file in language AArch64 assembly */ .include "../includeARM64.inc" </lang>

Output:

Hello  the world.

ABAP

<lang ABAP>DATA: s1 TYPE string,

     s2 TYPE string.

s1 = 'Hello'. CONCATENATE s1 ' literal' INTO s2 RESPECTING BLANKS. WRITE: / s1. WRITE: / s2. </lang>

Output:

Hello
Hello literal

Another way

<lang ABAP>REPORT string_concatenation.

DATA(var1) = 'Hello'. DATA(var2) = 'Literal'.

cl_demo_output=>new(

         )->begin_section( 'String concatenation using |{ }|'
         )->write( 'Statement: |{ var1 } { var2 }|'
         )->write( |{ var1 } { var2 }|
         )->begin_section( 'String concatenation with new string'
         )->write( 'Statement: |{ var1 } world!|'
         )->write( |{ var1 } world!|
         )->display( ).

</lang>

Output:

Hello literal
Hello world!

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

  S1 : constant String := "Hello";
  S2 : constant String := S1 & " literal";

begin

  Put_Line (S1);
  Put_Line (S2);

end String_Concatenation;</lang>

Sample output:

Hello
Hello literal

Aime

<lang aime>text s, v;

s = "Hello"; o_(s, "\n"); v = s + ", World!"; o_(v, "\n");</lang>

Output:

Hello
Hello, World!

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

<lang algol68>STRING s := "hello"; print ((s + " literal", new line)); STRING s1 := s + " literal"; print ((s1, new line))</lang>

Output:

hello literal
hello literal

Apex

<lang apex> String s1 = 'Hello '; String s2 = 'Salesforce Developer!';

String s3 = s1+s2;

// Print output System.debug(s3);</lang>

Output:

Hello Salesforce Developer!

AppleScript

<lang applescript>try

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

end try</lang>

ARM Assembly

Works with: as version Raspberry Pi

<lang ARM Assembly> /* ARM assembly Raspberry PI */ /* program strConcat.s */

/* Constantes */ .equ STDOUT, 1 @ Linux output console .equ EXIT, 1 @ Linux syscall .equ WRITE, 4 @ Linux syscall /* Initialized data */ .data szMessFinal: .asciz "The final string is \n"

szString: .asciz "Hello " szString1: .asciz " the world. \n"

/* UnInitialized data */ .bss szFinalString: .skip 255

/* code section */ .text .global main main:

                                        @ load string 
   ldr r1,iAdrszString

ldr r2,iAdrszFinalString

   mov r4,#0

1:

   ldrb r0,[r1,r4]                      @ load byte of string
   strb r0,[r2,r4]
   cmp r0,#0                            @ compar with zero ?
   addne r4,#1
   bne 1b
   ldr r1,iAdrszString1
   mov r3,#0

2:

   ldrb r0,[r1,r3]                      @ load byte of string 1
   strb r0,[r2,r4]
   cmp r0,#0                            @ compar with zero ?
   addne r4,#1
   addne r3,#1
   bne 2b
   mov r0,r2                            @ display final string
   bl affichageMess

100: @ standard end of the program */

   mov r0, #0                           @ return code
   mov r7, #EXIT                        @ request to exit program
   svc 0                                @ perform the system call

iAdrszString: .int szString iAdrszString1: .int szString1 iAdrszFinalString: .int szFinalString iAdrszMessFinal: .int szMessFinal

/******************************************************************/ /* display text with size calculation */ /******************************************************************/ /* r0 contains the address of the message */ affichageMess:

   push {r0,r1,r2,r7,lr}                       @ save  registers 
   mov r2,#0                                   @ counter length */

1: @ loop length calculation

   ldrb r1,[r0,r2]                             @ read octet start position + index 
   cmp r1,#0                                   @ if 0 its over
   addne r2,r2,#1                              @ else add 1 in the length
   bne 1b                                      @ and loop 
                                               @ so here r2 contains the length of the message 
   mov r1,r0                                   @ address message in r1 
   mov r0,#STDOUT                              @ code to write to the standard output Linux
   mov r7, #WRITE                              @ code call system "write" 
   svc #0                                      @ call systeme
   pop {r0,r1,r2,r7,lr}                        @ restaur des  2 registres
   bx lr                                       @ return

</lang>

Arturo

<lang rebol>str1: "Hello " str2: "World"

print str1 ++ str2 ++ "!"</lang>

Output:

Hello World!

AutoHotkey

<lang AutoHotkey>s := "hello" Msgbox, %s% s1 := s . " literal" ;the . is optional Msgbox, %s1%</lang>

AWK

The AWK concatenation operator is nothing. <lang awk>BEGIN {

  s = "hello"
  print s " literal"
  s1 = s " literal"
  print s1

}</lang>

Axe

<lang axe>Lbl CONCAT Copy(r₁,L₁,length(r₁)) Copy(r₂,L₁+length(r₁),length(r₂)+1) L₁ Return</lang>

BASIC

Works with: QuickBasic version 4.5

Works with: Liberty BASIC

<lang qbasic>s$ = "hello" print s$ + " literal" s2$ = s$ + " literal" print s$ print s2$</lang>

Output:

hello literal
hello
hello literal

Applesoft BASIC

A semicolon (;) is not the same as a concatenate operator (+), it is an instruction that works only on the PRINT statement to suppress newlines at the end of a literal or series of literals. For example, the instruction S$="HELLO";"LITERAL" would result in a syntax error.

<lang ApplesoftBasic>10 S$ = "HELLO" 20 PRINT S$ + " LITERAL" 30 PRINT S$ 40 S2$ = S$ + " LITERAL" 50 PRINT S2$</lang>

Output:

HELLO LITERAL
HELLO
HELLO LITERAL

BaCon

<lang freebasic> A$ = "hello" PRINT A$," World"

A2$ = A$ & " using & to concat World" PRINT A2$ </lang>

BBC BASIC

<lang bbcbasic> stringvar1$ = "Hello,"

     stringvar2$ = stringvar1$ + " world!"
     PRINT "Variable 1 is """ stringvar1$ """"
     PRINT "Variable 2 is """ stringvar2$ """"</lang>

Output:

Variable 1 is "Hello,"
Variable 2 is "Hello, world!"

IS-BASIC

<lang IS-BASIC>100 LET S$="Hello" 110 LET S$=S$&" world!" 120 PRINT S$</lang>

ZX Spectrum Basic

<lang zxbasic>10 LET s$="Hello" 20 LET s$=s$+" World!" 30 PRINT s$</lang>

Batch File

<lang dos>set string=Hello echo %string% World set string2=%string% World echo %string2%</lang>

Bracmat

<lang bracmat>"Hello ":?var1 & "World":?var2 & str$(!var1 !var2):?var12 & put$("var1=" !var1 ", var2=" !var2 ", var12=" !var12 "\n")</lang>

Output:

var1= Hello  , var2= World , var12= Hello World

Burlesque

<lang burlesque>blsq ) "Hello, ""world!"?+ "Hello, world!"</lang>

C

<lang 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);

}</lang>

C#

<lang csharp>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);
   }

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

ChucK

<lang> "Hello" => string A; A + " World!" => string B; <<< B >>>; </lang>

Output:

"Hello World!"

Clojure

<lang lisp>(def a-str "abcd") (println (str a-str "efgh"))

(def a-new-str (str a-str "efgh")) (println a-new-str)</lang>

COBOL

With the STRING verb: <lang cobol> 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
          .</lang>

Alternate method using the CONCATENATE intrinsic function: <lang cobol> ...

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

          GOBACK
          .</lang>

String literals can also be concatenated in the follwing ways: <lang cobol>* *> 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".</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>

Component Pascal

BlackBox Component Builder <lang oberon2> 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. </lang> Execute: ^Q StringConcatenation.Do

Output:

:> Hello world

D

<lang d>import std.stdio;

void main() {

   string s = "hello";
   writeln(s ~ " world");
   auto s2 = s ~ " world";
   writeln(s2);

}</lang>

DCL

<lang DCL>$ string1 = "hello" $ string2 = string1 + " world" $ show symbol string*</lang>

Output:

  STRING1 = "hello"
  STRING2 = "hello world"

Delphi

<lang delphi>program Concat;

{$APPTYPE CONSOLE}

var

 s1, s2: string;

begin

 s1 := 'Hello';
 s2 := s1 + ' literal';
 WriteLn(s1);
 WriteLn(s2);

end.</lang>

DWScript

<lang delphi>var s1 := 'Hello'; var s2 := s1 + ' World';

PrintLn(s1); PrintLn(s2);</lang>

Dyalect

Translation of: Swift

<lang Dyalect>var s = "hello" print(s + " literal") var s1 = s + " literal" print(s1)</lang>

Dylan.NET

<lang Dylan.NET> //to be compiled using dylan.NET v. 11.5.1.2 or later.

refstdasm mscorlib.dll

import System

assembly concatex exe ver 1.3.0.0

class public Program

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

Déjà Vu

<lang dejavu>local :s1 "hello" local :s2 concat( s1 ", world" ) !print s2</lang>

Output:

hello, world

EasyLang

<lang>a$ = "hello" b$ = a$ & " world" print b$</lang>

Ela

Strings in Ela support a polymorphic concatenation operator (++): <lang ela>hello = "Hello" hello'world = hello ++ ", " ++ "world" (hello, hello'world)</lang>

Output:

("Hello", "Hello, world!")

However, as long as strings in Ela are indexed arrays, this operator is not very effective for 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: <lang ela>toString $ "Hello" +> ", " +> "world"</lang> 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 as shown above.

Elena

ELENA 4.x: <lang elena>public program() {

   var s := "Hello";
   var s2 := s + " literal";

   console.writeLine:s;
   console.writeLine:s2;
   console.readChar()

}</lang>

Output:

Hello
Hello literal

Elixir

<lang elixir> s = "hello" t = s <> " literal"

IO.puts s IO.puts t </lang>

Output:

hello
hello literal

Emacs Lisp

version 1

<lang Emacs Lisp> (defun glue (str1 str2)

 (concat str1 str2) )

</lang>

version 2

<lang Emacs Lisp> (defun glue (str1 str2)

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

</lang> Eval: <lang Emacs Lisp> (setq str1 "Hello, ") (setq str2 "World!") (insert (glue str1 str2) ) </lang> Output:

Hello, World!

Erlang

<lang Erlang>S = "hello", S1 = S ++ " literal", io:format ("~s literal~n",[S]), io:format ("~s~n",[S1])</lang>

Sample output:

hello literal
hello literal

ERRE

 ..........
 S$="HELLO"
 PRINT(S$;" LITERAL") ! or S$+" LITERAL"
 S2$=S$+" LITERAL"
 PRINT(S2$)
 ..........

</lang>

Euphoria

<lang Euphoria>sequence s, s1 s = "hello" puts(1, s & " literal") puts(1,'\n') s1 = s & " literal" print (1, s1)) puts(1,'\n')</lang>

Output:

hello literal
hello literal

Excel

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

=CONCATENATE(A1;" ";B1)

</lang>

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

<lang> Hello World Hello World </lang>

F#

Translation of: C#

<lang fsharp>open System

[<EntryPoint>] let main args =

   let s = "hello"
   Console.Write(s)
   Console.WriteLine(" literal")
   let s2 = s + " literal"
   Console.WriteLine(s2)
   0</lang>

Factor

<lang factor>"wake up" [ " sheeple" append print ] [ ", you sheep" append ] bi print</lang>

Falcon

'VBA/Python programmer's approach. I'm just a junior Falconeer but this code seems falconic <lang falcon> /* created by Aykayayciti Earl Lamont Montgomery April 9th, 2018 */

s = "critical" > s + " literal" s2 = s + " literal" > s2 </lang>

Output:

critical literal
critical literal
[Finished in 0.2s]

Fantom

Illustrating in fansh: <lang fantom>fansh> a := "abc" abc fansh> b := a + "def" abcdef fansh> a abc fansh> b abcdef</lang>

Forth

Works with: GNU 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 (maxstringlength) :: s1, s = "hello"

print *,s // " literal" s1 = trim(s) // " literal" print *,s1

end program</lang>

FreeBASIC

<lang freebasic>' FB 1.05.0 Win64

Var s1 = "String" Var s2 = s1 + " concatenation" Print s1 Print s2 Sleep</lang>

Output:

String
String concatenation

Frink

<lang frink> a = "Frink" b = a + " rules!" println[b] </lang>

Gambas

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

Click this link to run this code <lang gambas>Public sub main() DIM bestclub AS String DIM myconcat AS String

bestclub = "Liverpool" myconcat = bestclub & " Football Club"

Print myconcat

End</lang>

GlovePIE

<lang glovepie>var.text1="Hello, " debug=var.text1+"world!"</lang>

Go

<lang 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)

}</lang>

Output:

hello
hello literal
hello literal

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

Halon

The dot (concatenation) operator may cast datatypes to strings. <lang halon>echo "Hello" . "World " . 123;</lang>

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

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

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:

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>

jq

<lang jq>"hello" as $s | $s + " there!"</lang>

Output:

# Use the -r command-line option if you wish 
# to suppress the string quotation marks
hello there!

Julia

<lang julia>s = "hello" println(s * " there!")</lang>

K

Translation of J code: <lang K> s1: "Some " s1, "text " s2: s1 , "more text!" </lang>

Output:

"Some "
"Some text"
"Some more text!"

Kotlin

<lang scala>fun main(args: Array<String>) {

   val s1 = "James"
   val s2 = "Bond"
   println(s1)
   println(s2)
   val s3 = s1 + " " + s2
   println(s3)

}</lang>

Output:

James
Bond
James Bond

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.

Lambdatalk

In Lambdatalk writing {def name a sequence of words} replaces the sequence of words by the given name in the code string. The name is a word and is not evaluated. Bracketing a name between two curly braces returns its related value. And concatenating named strings is simply done by writing names between curly braces and separated by spaces. <lang Scheme> {def christian_name Albert} -> christian_name {def name de Jeumont-Schneidre} -> name

{christian_name} {name} -> Albert de Jeumont-Schneidre </lang>

Lang5

<lang lang5>: concat 2 compress "" join ; 'hello " literal" concat</lang>

Lasso

<lang Lasso>local(x = 'Hello') local(y = #x + ', World!')

x // Hello
y // Hello, World!</lang>

Liberty BASIC

See BASIC.

Lingo

<lang lingo>a = "Hello" b = a & " world!" put b -- "Hello world!"</lang>

Lisaac

<lang Lisaac>Section Header

+ name := STRING_CONCATENATION;

Section Public

- main <- (

 + sc : STRING_CONSTANT;
 + sv : STRING;

 sc := "Hello";
 (sc + " literal").println;

 sv := sc + " literal";
 sv.println;

);</lang>

LiveCode

<lang LiveCode>local str="live" put str & "code" into str2 put str && str2</lang>

Output

live livecode

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>

M2000 Interpreter

M2000 Environment is an application written in Visual Basic 6, so can use strings UTF16LE (max 2GByte), and Ansi strings. So here is an example which add two Ansi strings. To print them to console we have to convert to UTF16LE. We can use ansi strings for files and for buffers (memory blocks). Conversion use Locale (so Locale 1032 can be used for Greek Ansi codepage)

A memory word is two bytes.

<lang M2000 Interpreter> Module CheckString {

     s$ = "hello"
     PRINT s$;" literal" 'or s$ + " literal"
     s2$ = s$ + " literal"
     PRINT s2$
     Print Len(s2$)=13
     \\ get an ansi string
     k$=Str$("Hello")
     Print Len(k$)=2.5  ' 2.5 words or 5 bytes
     Print Chr$(k$)
     k2$=k$+Str$(" literal")
     Print Len(k2$)=6.5  ' 13 bytes
     Print Chr$(k2$)
     Print Len(Chr$(k2$))=13 ' words

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

Maple

<lang Maple>str := "Hello": newstr := cat(str,", world!"): str; newstr;</lang>

Output:

                            "Hello"
                        "Hello, world!"

Mathcad

Uses Mathcad's built-in concat function to join the contents of a (string) variable to a string literal. Both equations and text are typed directly onto, and evaluated on, a Mathcad worksheet.

[1]

Define (:=) and display (=) the (string) variable Carpenter

   Carpenter := "Gort. " (Carpenter = "Gort. ")

Define (:=) and display (=) the (string) variable Helen concatenated with a string literal.

   Helen := concat(Carpenter,"Klaatu barada nikto."
   Helen = "Gort. Klaatu barada nikto."

Mathematica

<lang Mathematica>str= "Hello "; str<>"Literal"</lang>

MATLAB / Octave

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

Maxima

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

MAXScript

<lang maxscript>s = "hello" print (s + " literal") s1 = s + " literal" print s1</lang>

Mercury

<lang 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).</lang>

Metafont

<lang metafont>string a, b; a := "String"; message a & " literal"; b := a & " literal"; message b;</lang>

min

Works with: min version 0.19.3

<lang min>"butter" :a (a "scotch")=> "" join :b a puts! b puts!</lang>

Output:

butter
butterscotch

MiniScript

<lang MiniScript>s = "hello" print s + " world!"</lang>

Output:

hello world!

Modula-3

Strings in Modula-3 are called TEXTs. 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 TEXTs, such as Text. <lang modula3>string1 := Text.Concat(string, " literal.\n");</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

Nanoquery

<lang Nanoquery>s1 = "hello" println s1 + " world"

s2 = s1 + " world" println s2</lang>

Output:

hello world
hello world

Neko

<lang ActionScript>/**

String concatenation, in Neko
Tectonics:
   nekoc string-concatenation.neko
   neko string-concatenation [addon]

/

var arg = $loader.args[0] var addon if arg != null addon = $string(arg)

var s = "abc" $print("s: ", s, "\n")

var c = s + "def" $print("c: ", c, "\n")

if arg != null {

   c += addon
   $print("addon: ", addon, "\n")
   $print("c: ", c, "\n")

}</lang>

Output:

prompt$ nekoc string-concatenation.neko
prompt$ neko string-concatenation.n xyz
s: abc
c: abcdef
addon: xyz
c: abcdefxyz

Nemerle

Can be done with Concat() method or + operator: <lang Nemerle>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");
   }

}</lang>

NetRexx

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

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

NewLISP

<lang NewLISP>(let (str1 "foo")

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

(println str2)))</lang>

Nim

Strings can be concatenated with &. <lang nim>let str = "String" echo str & " literal."

-> String literal.</lang>

Strings can be concatenated as arrays and joined with separating characters: <lang nim>import strutils var str = "String" echo join([str, " literal.", "HelloWorld!"], "~~")

-> String~~ literal.~~HelloWorld!</lang>

Strings can be combined using string formatting: <lang nim>import strutils

var str = "String" echo "$# $# $#" % [str, "literal.", "HelloWorld!"]

-> String literal. HelloWorld!

Alternate form providing automatic conversion of arguments to strings.

echo "$# $# $#".format(str, 123, "HelloWorld!")

-> String 123 HelloWorld!</lang>

NS-HUBASIC

<lang NS-HUBASIC>10 STRING$="HELLO" 20 STRING$=STRING$+" WORLD!" 30 PRINT STRING$</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>

Objective-C

<lang objc>#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;

}</lang>

OCaml

<lang ocaml>let s = "hello" let s1 = s ^ " literal" let () =

 print_endline (s ^ " literal");
 print_endline s1</lang>

Oforth

.s show the stack : <lang Oforth>"Hello" dup " World!" + .s </lang>

Output:

[1] (String) Hello World!
[2] (String) Hello

Openscad

<lang openscad>a="straw"; b="berry"; c=str(a,b); /* Concatenate a and b */ echo (c);</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>

PARI/GP

<lang parigp>s = "Hello "; s = Str(s, "world"); \\ Alternately, this could have been: \\ s = concat(s, "world"); print(s);</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>

Phix

Library: Phix/basics

string s1 = "at"                                ?s1
string s2 = "c"&s1                              ?s2
string s3 = "s"&s1                              ?s3
string s4 = "m"&s1                              ?s4
string s5 = "The "&s2&" "&s3&" on the "&s4&"."  ?s5

Output:

"at"
"cat"
"sat"
"mat"
"The cat sat on the mat."

PHL

<lang>module stringcat;

extern printf;

@Integer main [

   var a = "hello";
   var b = a + " literal";
   printf("%s\n", b);

   return 0;

]</lang>

PHP

PicoLisp

<lang PicoLisp>(let Str1 "First text"

  (prinl Str1 " literal")
  (let Str2 (pack Str1 " literal")
     (prinl Str2) ) )</lang>

Pike

<lang Pike> string hello = "hello "; write(hello + "world" + "\n"); string all_of_it = hello + "world"; write(all_of_it + "\n"); </lang>

Output:

hello world
hello world

PL/I

<lang PL/I>declare (s, t) character (30) varying;

s = 'hello from me'; display (s || ' to you.' ); t = s || ' to you all'; display (t);</lang>

Plain English

Strings (and other values) can be concatenated to strings with then. <lang plainenglish>To run: Start up. Put "hello" into a string. Put the string then " world" into another string. Write the string to the console. Write the other string to the console. Wait for the escape key. Shut down.</lang>

Output:

hello
hello world

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>

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>s1 = "hello" print s1 + " world"

s2 = s1 + " world" print s2</lang>

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. <lang python>s1 = "hello" print ", ".join([s1, "world", "mom"])

s2 = ", ".join([s1, "world", "mom"]) print s2</lang>

Output:

hello, world, mom
hello, world, mom

QB64

<lang qbasic>s1$ = "String" s2$ = s1$ + " concatenation" Print s1$ Print s2$</lang>

Output:

String
String concatenation

Quackery

<lang Quackery> $ "A duck's quack"

 $ " has no echo."
 join 
 echo$</lang>

Output:

A duck's quack has no echo.

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>

Racket

<lang Racket>#lang racket (define hello "hello") (displayln hello)

(define world (string-append hello " " "world" "!")) (displayln world)

outputs
hello
hello world!</lang>

Raku

(formerly Perl 6)

Works with: Rakudo version #22 "Thousand Oaks"

<lang perl6>my $s = 'hello'; say $s ~ ' literal'; my $s1 = $s ~ ' literal'; say $s1;

or, using mutating concatenation:

$s ~= ' literal'; say $s;</lang> Note also that most concatenation in Raku is done implicitly via interpolation.

Raven

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

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

REBOL

<lang REBOL>s: "hello" print s1: rejoin [s " literal"] print s1</lang>

Red

<lang Red>>>str1: "Hello" >>str2: append str1 " World" >> print str2 Hello World >> print str1 Hello World</lang>

Retro

<lang Retro> 'hello_ 'literal s:append s:put</lang>

REXX

<lang 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 double-pipe does not cause spaces.*/</lang>

Ring

<lang ring> aString = "Welcome to the " bString = "Ring Programming Language"

see astring + bString + nl </lang>

Ruby

<lang ruby> s = "hello"

puts "#{s} template" #=> "hello template"

Variable s is intact

puts s #=> "hello"

puts s + " literal" #=> "hello literal"

Variable s is still the same

puts s #=> "hello"

Mutating s variable:

s += " literal" puts s #=> "hello literal" s << " another" # append to s, use only when string literals are not frozen puts s #=> "hello literal another"

s = "hello" puts s.concat(" literal") #=> "hello literal" puts s #=> "hello literal" puts s.prepend("Alice said: ") #=> "Alice said: hello literal" puts s #=> "Alice said: hello literal"

</lang>

Rust

<lang rust>fn main() {

   let s = "hello".to_owned();
   println!("{}", s);
   
   let s1 = s + " world";
   println!("{}", s1);

}</lang>

SAS

<lang sas>data _null_;

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

run;</lang>

Sather

<lang sather>class MAIN is

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

end;</lang>

Scala

Evaluation in a Scala worksheet, to val f2 is an anonymous function assigned. <lang scala> val s = "hello" //> s : String = hello

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

 println(s2 + f2())                              //> hello world !</lang>

Scheme

<lang scheme>(define s "hello") (display (string-append s " literal")) (newline) (define s1 (string-append s " literal")) (display s1) (newline)</lang>

Scilab

<lang>s1="Hello" s1+" world!" s2=s1+" world" s2 </lang>

Output:

 --> s1="Hello"
 s1  =
 Hello   
 -->s1+" world!"
 ans  =
 Hello world!   
 -->s2=s1+" world!"
 s2  =
 Hello world!   
 -->s2
 Hello world!

Seed7

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

Output:

hello world
hello world

Sidef

<lang ruby>var s = 'hello'; say s+' literal'; var s1 = s+' literal'; say s1;</lang> An example of destructive concatenation: <lang ruby>s += ' literal'; say s;</lang>

Simula

<lang Simula>TEXT PROCEDURE concatenate(head, tail);

   TEXT head, tail;

BEGIN TEXT c;

   c :- blanks(head.length + tail.length);
   c.sub(c.start, head.length) := head; ! putText(), anyone?;
   c.sub(c.start + head.length, tail.length) := tail;
   concatenate:- c;

END;

TEXT stringVariable, another; stringVariable :- "head "; another :- concatenate(stringVariable, "and tail"); OutText("stringVariable: """); OutText(stringVariable); OutText(""", another: "); OutText(another); Outimage;</lang>

Slate

<lang slate>define: #s -> 'hello'. inform: s ; ' literal'. define: #s1 -> (s ; ' literal'). inform: s1.</lang>

Smalltalk

In Smalltalk "," (comma) is a binary message (virtual function) implemented by Collection (and therefore also understood by strings):

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

Sparkling

<lang sparkling>let s1 = "Hello"; let s2 = " world!"; print(s1 .. s2); // prints "Hello world!"</lang>

Standard ML

<lang sml>val s = "hello" val s1 = s ^ " literal\n" val () =

 print (s ^ " literal\n");
 print s1</lang>

Stata

Stata string scalars

<lang stata>sca a = "foo" sca b = "bar" sca c = a+b di c

 foobar</lang>

Mata

<lang stata>a = "foo" b = "bar" c = a+b c

 foobar</lang>

Swift

<lang swift>let s = "hello" println(s + " literal") let s1 = s + " literal" println(s1)</lang>

Symsyn

<lang Symsyn> | concatenate a string

'The quick brown fox ' $s
+ 'jumped over the lazy moon.' $s
$s []

</lang>

Output:

The quick brown fox jumped over the lazy moon.

Tailspin

Tailspin has no operator for concatenating strings, you simply use interpolation instead <lang tailspin> def a: 'Hello'; '$a;, World!' -> !OUT::write </lang>

Output:

Hello, World!

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-83 BASIC

<lang ti83b>"HELLO"→Str0 Str0+" WORLD!"→Str0</lang>

Output:

HELLO WORLD!

TI-89 BASIC

TorqueScript

<lang Torque>%string = "Hello"; echo(%string); %other = " world!"; echo(%other); echo(%string @ %other);</lang>

TUSCRIPT

<lang tuscript>$$ MODE TUSCRIPT s = "Hello " print s, "literal"

s1 = CONCAT (s,"literal") print s1</lang>

Output:

Hello literal
Hello literal

UNIX Shell

Works with: Bourne Shell

Works with: bash

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

Ursa

<lang ursa>decl string s1 s2

make s1 contain "hello "

set s1 "hello "

set s2 to contain s1 and "world"

set s2 (+ s1 "world")

outputs "hello world"

out s2 endl console</lang>

Vala

<lang vala>void main() {

 var s = "hello";
 print(s);
 print(" literal\n");
 var s2 = s + " literal\n";
 print(s2);

}</lang>

VBA

<lang vb> Option Explicit

Sub String_Concatenation() Dim str1 As String, str2 As String

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

End Sub </lang>

Output:

Rosetta
Rosetta code!
Rosetta code... based on concatenation of : Rosetta and code...

VBScript

<lang vb> s1="Hello" s2=s1 & " World!" WScript.Echo s2 </lang>

Output:

Hello World!

Visual Basic

Works with: Visual Basic version VB6 Standard

works the same as in VBA, see String_concatenation#VBA

Visual Basic .NET

Platform: .NET

Works with: Visual Basic .NET version 9.0+

<lang vbnet>s = "Hello" Console.WriteLine(s & " literal") s1 = s + " literal" Console.WriteLine(s1)</lang>

Wee Basic

<lang Wee Basic>let string1$="Hello " let string2$="world!" print 1 string1$+string2$ end</lang>

Wren

<lang javascript>var s = "Hello, " var t = s + "world!" System.print(s) System.print(t)</lang>

Output:

Hello, 
Hello, world!

XPL0

<lang 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); ]</lang>

Yorick

<lang yorick>var1 = "Hello"; var2 = var1 + ", world!"; write, var1; write, var2;</lang>

Zig

<lang zig>const std = @import("std");

const debug = std.debug; const heap = std.heap; const mem = std.mem;

test "string concatenation" {

   const hello = "Hello,";

   debug.warn("\n{}{}\n", .{ hello, " world!" });

   // Method 1: Array concatenation
   //
   // This only works if the values are known at compile-time.
   const hello_world_at_comptime = hello ++ " world!";

   debug.warn("{}\n", .{hello_world_at_comptime});

   // Method 2: std.mem.concat
   var buf: [128]u8 = undefined;
   const allocator = &heap.FixedBufferAllocator.init(&buf).allocator;

   const hello_world_concatenated = try mem.concat(allocator, u8, &[_][]const u8{ hello, " world!" });

   debug.warn("{}\n", .{hello_world_concatenated});

   // Method 3: std.mem.join
   const hello_world_joined = try mem.join(allocator, " ", &[_][]const u8{ hello, "world!" });

   debug.warn("{}\n", .{hello_world_joined});

}</lang>

Output:

Test [1/1] test "string concatenation"...
Hello, world!
Hello, world!
Hello, world!
Hello, world!
All 1 tests passed.

zkl

<lang zkl>var s="Hello"; s2:=s+", world!"; s2.println(); //-->Hello, world! s3:=String(s," ",s2); s3.println(); //-->Hello Hello, world!</lang> https://en.wikipedia.org/wiki/Comparison_of_programming_languages_%28string_functions%29#ConcatenationProperty "Wikipedia" (as page type) with input value "https://en.wikipedia.org/wiki/Comparison_of_programming_languages_%28string_functions%29#Concatenation" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process.

Zoea

<lang Zoea> program: string_concat

 input: ['hello', 'literal']
 output: 'hello literal'

</lang>

@@ Line 1,342: / Line 1,342: @@
 # Alternate form providing automatic conversion of arguments to strings.
 echo "$# $# $#".format(str, 123, "HelloWorld!")
-# -> String 123 HelloWorld!</pre>
+# -> String 123 HelloWorld!</lang>
 =={{header|NS-HUBASIC}}==