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.

Ada

<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; </ada> Sample output:

Hello literal
Hello literal

AWK

BEGIN {
   s = "hello";
   print s, " literal";
   s1 = s + " literal";
   print s1;
}

ALGOL 68

STRING s := "hello";
print ((s + " literal", new line));
STRING s1 := s + " literal";
print ((s1, new line))

Output:

hello literal
hello literal

BASIC

Works with: QuickBasic version 4.5

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

hello literal
hello literal

C

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

}</c>

C++

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

}</cpp> Output:

hello literal
hello literal

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

Fortran

program StringConcatenation

integer, parameter          :: maxstringlength = 64
character (*), parameter    :: s = "hello"
character (maxstringlength) :: s1

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

end program

Haskell

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

Java

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

}</java> Output:

hello literal
hello literal

JavaScript

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

Logo

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

Objective-C

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

int main() {

 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 NSString *s = @"hello";
 printf("%s%s\n", [s UTF8String], " literal");
 
 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;

}</objc>

OCaml

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

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

Pascal

<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.</pascal>

Perl

<perl>#! /usr/bin/perl my $s = "hello"; print $s . " literal" . "\n"; my $s1 = $s . " literal"; print $s1 . "\n";</perl>

PHP

Python

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

Ruby

s = "hello" puts s + " literal" s1 = s + " literal" puts s1

Scheme

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

Smalltalk

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

Tcl

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

UNIX Shell

s="hello"
echo "$s literal"
s1="$s literal"
echo $s1