String append: Difference between revisions

Content added Content deleted

Inline

Revision as of 15:32, 29 May 2015

Most languages provide a way to concatenate two string values, but some languages also provide a convenient way to append in-place to an existing string variable without referring to the variable twice. For this task, create a string variable equal to any text value. Append the string variable with another string literal in the most idiomatic way, without double reference if your language supports it.

Show the contents of the variable after the append operation.

ALGOL 68

Works with: ALGOL 68 version Revision 1.

Works with: ALGOL 68G version Any - tested with release algol68g-2.7.

Works with: ELLA ALGOL 68 version Any (with appropriate job cards).

File: String_append.a68<lang algol68>#!/usr/bin/a68g --script #

-*- coding: utf-8 -*- #

STRING str := "12345678"; str +:= "9!"; print(str)</lang>

Output:

123456789!

AutoHotkey

<lang autohotkey>s := "Hello, " s .= "world." MsgBox % s</lang>

Output:

Hello, world.

AWK

syntax: GAWK -f STRING_APPEND.AWK

BEGIN {

   s = "foo"
   s = s "bar"
   print(s)
   exit(0)

} </lang>

Output:

foobar

BASIC

Applesoft BASIC

<lang BASIC>S$ = "Hello" S$ = S$ + " World!" PRINT S$</lang>

BBC BASIC

<lang BBC BASIC> S$="Hello"

     S$+=" World!"
     PRINT S$
     END</lang>

Output:

Hello World!

C

<lang c>#include<stdio.h>

include<string.h>

int main() {

   char str[24]="Good Morning";
   char *cstr=" to all";
   char *cstr2=" !!!";
   int x=0;
   //failure when space allocated to str is insufficient.

   if(sizeof(str)>strlen(str)+strlen(cstr)+strlen(cstr2))
           {
               /* 1st method*/
               strcat(str,cstr);

               /*2nd method*/
               x=strlen(str);
               sprintf(&str[x],"%s",cstr2);

               printf("%s\n",str);

           }
   return 0;

}</lang>

Output:

Good Morning to all !!!

C++

<lang cpp>#include <iostream>

include <string>

int main( ) {

  std::string greeting( "Hello" ) ;
  greeting.append( " , world!" ) ;
  std::cout << greeting << std::endl ;
  return 0 ;

}</lang>

Output:

Hello , world!

C#

<lang csharp>class Program {

   static void Main(string[] args)
   {
       string x = "foo";
       x += "bar";
       System.Console.WriteLine(x);
   }

}</lang>

Clojure

Using global vars. <lang clojure>user=> (def s "app")

'user/s

user=> s "app" user=> (def s (str s "end"))

'user/s

user=> s "append"</lang>

Using local bindings. <lang clojure> user=> (let [s "ap", s (str s "pend")] s) "append"</lang>

Common Lisp

Similar to the Racket solution, a macro is necessary to append in-place: <lang lisp>(defmacro concatenatef (s &rest strs)

 "Append additional strings to the first string in-place."
 `(setf ,s (concatenate 'string ,s ,@strs)))

(defvar *str* "foo") (concatenatef *str* "bar") (format T "~a~%" *str*) (concatenatef *str* "baz" "abc" "def") (format T "~a~%" *str*)</lang>

Output:

foobar
foobarbazabcdef

D

<lang d>import std.stdio;

void main() {

   string s = "Hello";
   s ~= " world!"; 
   writeln(s);

}</lang>

Output:

Hello world!

Elixir

<lang elixir>iex(60)> s = "Hello" "Hello" iex(61)> s <> " World!" "Hello World!"</lang>

Erlang

Output:

1> S = "Hello".
"Hello"
2> S ++ " world".
"Hello world"

Euphoria

<lang euphoria> sequence string = "String"

printf(1,"%s\n",{string})

string &= " is now longer\n"

printf(1,"%s",{string}) </lang>

Output:

String
String is now longer

F#

Strings are immutable in .NET. To append (to the same variable) the variable has to be declared mutable. <lang fsharp>let mutable x = "foo" x <- x + "bar" printfn "%s" x</lang>

Forth

<lang Forth>Strings in Forth are simply named memory locations

create astring 256 allot \ create a "string"

s" Hello " astring PLACE \ initialize the string

s" World!" astring +PLACE \ append with "+place"

</lang>

Test at the console

<lang> ok s" Hello " astring place ok s" World!" astring +place ok astring count type Hello World! ok </lang>

Go

Icon and Unicon

In both languages you can:

<lang unicon> procedure main()

   s := "foo"
   s ||:= "bar"
   write(s)

end </lang>

Outputs:

->ss
foobar
->

Haskell

<lang haskell> main = putStrLn ("Hello" ++ "World") </lang>

J

<lang j> s=: 'new'

new

  s=: s,' value'   NB. append is in-place
  s

new value</lang>

Java

<lang Java>String sa = "Hello"; sa += ", World!"; System.out.println(sa);

StringBuilder ba = new StringBuilder(); ba.append("Hello"); ba.append(", World!"); System.out.println(ba.toString());</lang>

Output:

Hello, World!
Hello, World!

JavaScript

Works with: Rhino

Works with: SpiderMonkey

<lang JavaScript>var s1 = "Hello"; s1 += ", World!"; print(s1);

var s2 = "Goodbye"; // concat() returns the strings together, but doesn't edit existing string // concat can also have multiple parameters print(s2.concat(", World!"));</lang>

Output:

"Hello, World!"
"Goodbye, World!"

jq

jq's + operator can be used to append two strings, and under certain circumstances the += operator can be used as an abbreviation for appending a string to an existing string. For example, all three of the following produce the same output:<lang jq>"Hello" | . += ", world!"

["Hello"] | .[0] += ", world!" | .[0]

{ "greeting": "Hello"} | .greeting += ", world!" | .greeting</lang> However the += operator cannot be used with jq variables in the conventional manner. One could nevertheless use the technique illustrated by the following:<lang jq>"Hello" as $a | $a | . += ", world!" as $a | $a</lang>

Julia

<lang julia>s = "Hello" s *= ", world!"</lang>

Output:

"Hello, world!"

Lasso

<lang Lasso>local(x = 'Hello')

x->append(', World!')
x</lang>

Output:

Hello, World!

LiveCode

Livecode has an "after" keyword for this <lang LiveCode>local str="live" put "code" after str</lang> Output is "livecode"

Mathematica

<lang Mathematica> (* mutable strings are not supported *) s1 = "testing"; s1 = s1 <> " 123"; s1</lang>

Output:

"testing 123"

NetRexx

<lang NetRexx>s_ = 'Hello' s_ = s_', world!' say s_</lang>

Output:

Hello, world!

NewLISP

<lang NewLISP>(setq str "foo") (push "bar" str -1)

or as an alternative

(setq str "foo") (extend str "bar")

(println str) </lang>

Nim

<lang nim>var str = "123456" str.add("78") # two ways str &= "9!" # to append</lang>

Objeck

<lang objeck> class Append {

 function : Main(args : String[]) ~ Nil {
   x := "foo";
   x->Append("bar");
   x->PrintLine();
 }

} </lang>

OCaml

<lang ocaml>let () =

 let s = Buffer.create 17 in
 Buffer.add_string s "Bonjour";
 Buffer.add_string s " tout le monde!";
 print_endline (Buffer.contents s)</lang>

Output:

Bonjour tout le monde!

Oforth

<lang Oforth>StringBuffer new "Hello, " << "World!" << println</lang>

PARI/GP

Not supported in GP. <lang parigp>s = "Hello"; s = Str(s, ", world!")</lang>

Output:

%1 = "Hello, world!"

Pascal

Works with: Free Pascal version 2.6.2

<lang Pascal>program StringAppend; {$mode objfpc}{$H+}

uses

 {$IFDEF UNIX}{$IFDEF UseCThreads}
 cthreads,
 {$ENDIF}{$ENDIF}
 Classes
 { you can add units after this };

var

   s: String = 'Hello';

begin

 s += ' World !';
 WriteLn(S);
 ReadLn;

end.</lang> Output:

Hello  World !

Perl

<lang perl>my $str = 'Foo'; $str .= 'bar'; print $str;</lang>

Output:

Foobar

Perl 6

Output:

foobar

PicoLisp

<lang picolisp>(setq Str1 "12345678") (setq Str1 (pack Str1 "9!")) (println Str1)</lang>

Output:

"123456789!"

PL/I

<lang PL/I>Cat: procedure options (main);

  declare s character (100) varying;
  s = 'dust ';
  s ||= 'bowl';
  put (s);

end Cat;</lang>

dust bowl

PureBasic

<lang purebasic>S$ = "Hello" S$ = S$ + " Wo" ;by referencing the string twice S$ + "rld!" ;by referencing the string once If OpenConsole()

 PrintN(S$)

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

EndIf</lang> Sample output:

Hello World!

Python

File: String_append.py<lang python>#!/usr/bin/env python

-*- coding: utf-8 -*- #

str = "12345678"; str += "9!"; print(str)</lang>

Output:

123456789!

Racket

<lang racket>;there is no built-in way to set! append in racket (define mystr "foo") (set! mystr (string-append mystr " bar")) (displayln mystr)

but you can create a quick macro to solve that problem

(define-syntax-rule (set-append! str value)

 (set! str (string-append str value)))

(define mymacrostr "foo") (set-append! mymacrostr " bar") (displayln mystr)</lang>

Output:

foo bar
foo bar

REXX

using abutment

<lang rexx>s='he' s=s'llo world!' Say s</lang> output

hello world!

using concatenation

<lang rexx>s="He" s=s || 'llo, World!' /*same as: s=s||'llo, World!' */ say s</lang> output

Hello, World!

Ruby

<lang ruby>s = "Hello wo" s += "rld" # new string object s << "!" # mutates in place, same object puts s</lang>

Output:

Hello world!

Scala

An evaluation in Scala worksheet. <lang scala> var d = "Hello" // Mutables are discouraged //> d : String = Hello

 d += ", World!" // var contains a totally new re-instantiationed String

 val s = "Hello" // Immutables are recommended   //> s  : String = Hello
 val s1 = s + s                                  //> s1  : String = HelloHello
 val f2 = () => " !" //Function assigned to variable
                                                 //> f2  : () => String = <function0>
 println(s1 + f2());                             //> HelloHello !</lang>

Seed7

<lang seed7>$ include "seed7_05.s7i";

const proc: main is func

 local
   var string: str is "12345678";
 begin
   str &:= "9!";
   writeln(str);
 end func;</lang>

Output:

123456789!

Sidef

Output:

Foobar

Swift

<lang swift>var s = "foo" // "foo" s += "bar" // "foobar" println(s) // "foobar" s.extend("baz") // "foobarbaz" println(s) // "foobarbaz"</lang>

Tcl

String concatenation is a fundamental feature of the Tcl language, and there is also an append that makes concatenation even simpler: <lang tcl>set s "he" set s "${s}llo wo"; # The braces distinguish varname from text to concatenate append s "rld" puts $s</lang>

Output:

hello world

VBA

<lang VB>Function StringAppend() Dim s As String s = "foo" s = s & "bar" Debug.Print s End Function</lang>

VBScript

<lang vb>s = "Rosetta" s = s & " Code" WScript.StdOut.Write s</lang>

Output:

Rosetta Code

Wart

zkl

zkl strings are immutable, but byte blobs are mutable. <lang zkl>var s="foo"; s+="bar"; //-->new string "foobar" s.append("bar"); //-->new string "foobar", same as above

s=Data(Void,"foo"); s.append("bar"); // or s+="bar" s.text; //-->"foobar"</lang>