String concatenation

Set a string variable equal to any text value. Print it to the console concatenated with a string literal. Create a new string variable whose value is the other variable concatenated with a string literal. Print this new variable.

ActionScript

<lang actionscript>package {

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

}</lang>

Ada

<lang ada>with Ada.Text_IO; use Ada.Text_IO;

procedure String_Concatenation is

  S : String := "Hello";

begin

  Put_Line (S & " literal");
  declare
     S1 : String := S & " literal";
  begin
     Put_Line (S1);
  end;

end String_Concatenation;</lang> Sample output:

Hello literal
Hello literal

AutoHotkey

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

AWK

The AWK concatenation operator is just a space. <lang awk>BEGIN {

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

}</lang>

ALGOL 68

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

BASIC

Works with: QuickBasic version 4.5

<lang qbasic>s$ = "hello" print s$;" literal" 'or s$ + " literal" s2$ = s$ + " literal" print s2$</lang> Output:

hello literal
hello literal

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 cpp>#include <string>

include <iostream>

int main() {

  std::string s = "hello";
  std::cout << s << " literal" << std::endl;
  std::string s2 = s + " literal";
  std::cout << s2 << std::endl;
  return 0;

}</lang> Output:

hello literal
hello literal

C#

<lang csharp>using System;

class Program {

   static void Main(string[] args) {
       string s = "hello";
       Console.WriteLine(s + " literal");
       string s2 = s + " literal";
       Console.WriteLine(s2);
   }

}</lang>

Clojure

<lang lisp>(def a-str "abcd") (println (apply str (concat a-str "efgh"))) (def a-new-str (apply str (concat a-str "efgh"))) (println a-new-str)</lang>

Common Lisp

<lang lisp>(let ((s "hello"))

   (format t "~a there!~%" s)
   (let* ((s2 " there!")
          (s (concatenate 'string s s2)))
       (format t "~a~%" s)))</lang>

<lang lisp>(defparameter *s* "hello") (print (concatenate 'string *s* " literal")) (defparameter *s1* (concatenate 'string *s* " literal")) (print *s1*)</lang>

D

<lang d>string s = "hello"; writefln(s ~ " world"); auto s2 = s ~ " world"; writefln(s2);</lang>

E

<lang e>def a := "rose" println(a + "bud") def b := a + "tte" println(b)</lang>

Factor

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

Forth

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 (*), parameter :: s = "hello" character (maxstringlength) :: s1

print *,s // " literal" s1 = s // " literal" print *,s1

end program</lang>

Groovy

<lang groovy>def s = "Greetings " println s + "Earthlings"

def s1 = s + "Earthlings" println s1</lang>

Output:

Greetings Earthlings
Greetings Earthlings

Haskell

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

         putStrLn s1</lang>

IDL

<lang idl> s1='Hello' print, s1 + ' literal' s2=s1 + ' literal' print, s2 </lang>

J

<lang J> s1 =. 'Some '

  ]s1, 'text '

Some text

  ]s2 =. s1 , 'more text!'

Some more text!</lang> For more info see: http://www.jsoftware.com/help/dictionary/d320.htm on , http://www.jsoftware.com/help/dictionary/d500.htm on ]

Java

<lang java5>public class Str{

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

}</lang> Output:

hello literal
hello literal

JavaScript

<lang javascript>var s = "hello" print(s + " there!")</lang>

Lisaac

<lang Lisaac>Section Header

+ name := STRING_CONCATENATION;

Section Public

- main <- (

 + sc : STRING_CONSTANT;
 + sv : STRING;

 sc := "Hello";
 (sc + " literal").print;
 '\n'.print;
 sv := sc + " literal";
 sv.print;
 '\n'.print;

);</lang>

Logo

<lang logo>make "s "hello print word :s "| there!|</lang>

lua

<lang lua> a, = "hello " print(a .. "world") c = a .. "world" print(c)</lang>

Objective-C

<lang objc>#import <Foundation/Foundation.h>

int main() {

 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 NSString *s = @"hello";
 printf("%s%s\n", [s UTF8String], " literal");
 
 NSString *s2 = [s stringByAppendingString:@" literal"];
 // or, NSString *s2 = [NSString stringWithFormat:@"%@%@", s, @" literal"];
 puts([s2 UTF8String]);
 /* or */
 NSMutableString *s3 = [NSMutableString stringWithString: s];
 [s3 appendString: @" literal"];
 puts([s3 UTF8String]);
 
 [pool release];
 return 0;

}</lang>

M4

M4 has macros rather than variables, but a macro expanded can work like a variable. <lang m4>define(`concat',`$1$2')dnl define(`A',`any text value')dnl concat(`A',` concatenated with string literal') define(`B',`concat(`A',` and string literal')')dnl B</lang>

MAXScript

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

Metafont

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

Modula-3

Strings in Modula-3 are called 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>

OCaml

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

 print_endline (s ^ " literal");
 (* or Printf.printf "%s literal\n" s; *)
 print_endline s1</lang>

Oz

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

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

Pascal

<lang pascal>Program StringConcat;

 Var
    s, s1   : String;

Begin

   s := 'hello';
   writeln(s + ' literal');
   s1 := concat(s, ' literal');
   { s1 := s + ' literal'; works too, with FreePascal }
   writeln(s1);

End.</lang>

Perl

<lang perl>my $s = 'hello'; print $s . ' literal', "\n"; my $s1 = $s . ' literal'; print $s1, "\n";</lang>

An example of destructive concatenation:

<lang perl>$s .= ' literal'; print $s, "\n";</lang>

Perl 6

Works with: Rakudo version #22 "Thousand Oaks"

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

An example of destructive concatenation:

<lang perl6>$s ~= ' literal'; say $s;</lang>

PL/I

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

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

PowerShell

<lang powershell>$s = "Hello" Write-Host $s World.

alternative, using variable expansion in strings

Write-Host "$s World."

$s2 = $s + " World." Write-Host $s2</lang>

PHP

PicoLisp

<lang PicoLisp>(let Str1 "First text"

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

PureBasic

<lang PureBasic>If OpenConsole()

 s$ = "hello"
 PrintN( s$ + " literal")
 s2$ = s$ + " literal"
 PrintN(s2$)

 Print(#CRLF$ + #CRLF$ + "Press ENTER to exit")
 Input()
 CloseConsole()

EndIf</lang>

Python

<lang python>s = "hello" print s + " literal" s1 = s + " literal" print s1</lang>

R

<lang R>hello <- "hello" paste(hello, "literal") # "hello literal" hl <- paste(hello, "literal") #saves concatenates string to a new variable paste("no", "spaces", "between", "words", sep="") # "nospacesbetweenwords"</lang>

REBOL

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

REXX

<lang rexx> s = "hello" say s "literal" t = s "literal" say t </lang>

Ruby

<lang ruby>s = "hello" puts s + " literal" s1 = s + " literal" puts s1 s1 << " another" # append to s1</lang>

Scheme

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

Slate

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

Smalltalk

<lang smalltalk>|s s1| s := 'hello'. (s,' literal') printNl. s1 := s,' literal'. s1 printNl.</lang>

Standard ML

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

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

Tcl

<lang tcl>set s hello puts "$s there!" append s " there!" puts $s</lang> You can also just group the strings to concatenate together at the point where they are used, using Tcl's built-in syntactic concatenation: <lang tcl>set s "Hello " set t "World" set u "!" puts $s$t$u ;# There is nothing special here about using puts; just an example</lang>

| xargs -n1 -i echo {} literal</lang>

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>