String append: Difference between revisions

{{trans|Python}}

s ‘’= ‘9!’

{{out}}

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program appendstr64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

{{Output}}

<pre>

=={{header|Action!}}==

CHAR ARRAY S1,S2

Print(S1)

Return

{{out}}

<pre>

=={{header|Ada}}==

with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;

with Ada.Text_IO.Unbounded_Io; use Ada.Text_IO.Unbounded_IO;

Put_Line(Str);

end String_Append;

{{out}}

<pre>

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-2.7 algol68g-2.7].}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards).}}

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

STRING str := "12345678";

str +:= "9!";

{{out}}

<pre>

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program appendstr.s */

=={{header|AppleScript}}==

set {a, b} to {"Apple", "Script"}

set a to a & b

return a as string

{{out}}

=={{header|APL}}==

s,'world'

=={{header|Arturo}}==

a: new "Hello"

c: "Hello"

{{out}}

=={{header|Asymptote}}==

s = s + " Wo";

s += "rld!";

=={{header|AutoHotkey}}==

s .= "world."

{{out}}<pre>Hello, world.</pre>

Avail's normal strings are immutable, however string ''variables'' can leverage tuple's appending-assignment method, <code>_↑++=_</code>.

str ++= "beer";

Note that one can define methods similar to this, thanks to the ''variable occurrence'' message pattern, <code>_↑</code>, whose slot accepts a variable usage and then passes the variable container itself as the corresponding argument. Consider the source for the append used above:

[

var : read tuple/write ⊥,

|

var ?= eject var ++ t;

(<code>eject</code> and <code>?=</code> are methods used for unassign-retrieving and assigning to a variable, respectively, only needed when dealing with the containers themselves.)

=={{header|AWK}}==

# syntax: GAWK -f STRING_APPEND.AWK

BEGIN {

exit(0)

}

{{out}}

<pre>

=={{header|Axe}}==

Copy(r₂,r₁+length(r₁),length(r₂)+1)

r₁

=={{header|BASIC}}==

==={{header|Applesoft BASIC}}===

S$ = S$ + " World!"

==={{header|BaCon}}===

A$ = "Hello"

A$ = A$ & " World!"

PRINT A$

==={{header|BBC BASIC}}===

S$+=" World!"

PRINT S$

{{out}}

<pre>Hello World!</pre>

==={{header|Commodore BASIC}}===

20 S$ = S$ + " WORLD!"

30 PRINT S$

{{out}}

<pre>HELLO WORLD!</pre>

==={{header|IS-BASIC}}===

110 LET S$=S$&" World!"

==={{header|BASIC256}}===

a$ = a$ & "llo"

a$ = a$ + " Wo"

a$ += "rld"

a$ &= "!"

==={{header|Liberty BASIC}}===

a$ = a$ + " World"

a$ = a$ ; "!"

==={{header|QBasic}}===

{{works with|Run BASIC}}

{{works with|Yabasic}}

a$ = a$ + " World!"

==={{header|Run BASIC}}===

{{works with|QBasic}}

{{works with|Yabasic}}

a$ = a$ + " World!"

==={{header|True BASIC}}===

LET a$ = a$ & " World!"

PRINT a$

==={{header|Yabasic}}===

{{works with|QBasic}}

{{works with|Run BASIC}}

a$ = a$ + " World!"

=={{header|Bracmat}}==

str$(!str " World!"):?str;

{{out}}

<pre>Hello World!</pre>

=={{header|C}}==

#include<string.h>

}

return 0;

{{out}}

<pre>Good Morning to all !!!</pre>

=={{header|C sharp|C#}}==

{

static void Main(string[] args)

System.Console.WriteLine(x);

}

=={{header|C++}}==

#include <string>

std::cout << greeting << std::endl ;

return 0 ;

{{out}}

<pre>Hello , world!</pre>

=={{header|Clojure}}==

Using global vars.

#'user/s

user=> s

#'user/s

user=> s

Using local bindings.

user=> (let [s "ap", s (str s "pend")] s)

=={{header|COBOL}}==

{{works with|GnuCOBOL}}

program-id. string-append.

goback.

end program string-append.

{{out}}

<pre>$ cobc -xj string-append.cob

=={{header|CoffeeScript}}==

{{works with|Node.js}}

b = "World!"

c = a + b

Or with concat:

{{out}}

<pre>Hello, World!</pre>

=={{header|Common Lisp}}==

Similar to the [[String append#Racket| Racket]] solution, a macro is necessary to append in-place:

"Append additional strings to the first string in-place."

`(setf ,s (concatenate 'string ,s ,@strs)))

(format T "~a~%" *str*)

(concatenatef *str* "baz" "abc" "def")

Output:

=={{header|D}}==

void main() {

s ~= " world!";

writeln(s);

{{out}}

<pre>Hello world!</pre>

=={{header|DBL}}==

STR='Hello'

STR(%TRIM(STR)+2:5)='world'

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

program String_append;

writeln(h);

readln;

{{out}}

<pre>Hello World

=={{header|Dyalect}}==

str += str

=={{header|EasyLang}}==

a$ &= " world"

=={{header|EchoLisp}}==

;; Solution from Common Lisp and Racket

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

name

→ "Albert de Jeumont-Schneidre"

=={{header|Elena}}==

ELENA 4.x :

import extensions'text;

console.printLine:s.readChar()

=={{header|Elixir}}==

"Hello"

iex(61)> s <> " World!"

=={{header|Emacs Lisp}}==

While strings in Emacs Lisp are mutable, they're fixed size. Therefore the <code>concat</code> function creates a new string and the existing string must be referenced twice:

(setq str (concat str "bar"))

This can be hidden by using a macro such as <code>cl-callf</code> which expands into the above code:

{{libheader|cl-lib}}

(defvar str "foo")

(cl-callf concat str "bar")

Buffers can be thought of as expandable strings:

(with-current-buffer buf

(insert "foo"))

(insert "bar")

(buffer-string)))

=={{header|Erlang}}==

=={{header|Euphoria}}==

sequence string = "String"

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

{{out}}

<pre>

=={{header|F_Sharp|F#}}==

Strings are immutable in .NET. To append (to the same variable) the variable has to be declared mutable.

x <- x + "bar"

=={{header|Factor}}==

{{out}}

<pre>

=={{header|Falcon}}==

/* Added by Aykayayciti Earl Lamont Montgomery

April 10th, 2018 */

> s1 + " World"

printl(s2 + " bar")

{{out}}

<pre>

=={{header|Forth}}==

create astring 256 allot \ create a "string"

s" Hello " astring PLACE \ initialize the string

Test at the console

s" Hello " astring place ok

s" World!" astring +place ok

astring count type Hello World! ok

=={{header|Fortran}}==

'''Using deferred length character strings:'''

program main

end program main

{{out}}

'''Using pre-allocated character strings:'''

program str_append

implicit none

end program str_append

{{out}}

=={{header|FreeBASIC}}==

Var s = "String"

s += " append"

Print s

{{out}}

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=0b17e205d56985c8cd1ff108c6fc9ca4 Click this link to run this code]'''

Dim sString As String = "Hello "

Print sString

Output:

<pre>

=={{header|Genie}}==

/* String append, in Genie */

init

str += ", world"

{{out}}

<pre>prompt$ valac stringAppend.gs

=={{header|GlovePIE}}==

var.string+="Sparta!"

=={{header|Go}}==

=== String Builder ===

The first solution redefines the string variable every time. It might be short in code but it uses much CPU cycles. A better way is to use `string.Builder` but it is not a string. It is more like a buffer which can produce a string. And it really appends the string to the existing variable.

package main

fmt.Print(s.String())

}

{{out}}

foobar

=={{header|Gosu}}==

var s = "a"

s += "b"

var b = "b"

var c = "c"

{{out}}

<pre>

=={{header|Groovy}}==

class Append{

static void main(String[] args){

}

}

{{out}}

<pre>

=={{header|Haskell}}==

main = putStrLn ("Hello" ++ "World")

=={{header|Icon}} and {{header|Unicon}}==

In both languages you can:

procedure main()

s := "foo"

write(s)

end

Outputs:

=={{header|J}}==

s

new

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

s

=={{header|Java}}==

sa += ", World!";

System.out.println(sa);

ba.append("Hello");

ba.append(", World!");

{{out}}

<pre>

{{works with|Rhino}}

{{works with|SpiderMonkey}}

s1 += ", World!";

print(s1);

// concat() returns the strings together, but doesn't edit existing string

// concat can also have multiple parameters

{{out}}

<pre>

=={{header|jq}}==

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

=={{header|Jsish}}==

From Javascript entry.

var str = 'Hello';

;str += ', world';

s2.concat(', World!') ==> Goodbye, World!

=!EXPECTEND!=

{{out}}

=={{header|Julia}}==

{{out}}

<pre>"Hello, world!"</pre>

=={{header|Kotlin}}==

var s = "a"

s += "b"

val c = "c"

println("$a$b$c")

{{out}}

<pre>abc

=={{header|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.

{def christian_name Albert}

-> christian_name

{christian_name} {name}

-> Albert de Jeumont-Schneidre

=={{header|langur}}==

.s ~= "foo bars"

{{out}}

=={{header|Lasso}}==

#x->append(', World!')

{{out}}

<pre>Hello, World!</pre>

=={{header|Lingo}}==

put " world!" after str

put str

=={{header|LiveCode}}==

Livecode has an "after" keyword for this

Output is "livecode"

=={{header|Lua}}==

Not possible as strings are immutable. We can demonstrate their immutability using 'self':

print(self)

end

x:show()

x:append("there!")

{{out}}

<pre>Hi

Hi </pre>

You can of course concatentate them and store the result in the original variable name but that requires a double reference:

x = x .. "there!"

{{out}}

<pre>Hi there!</pre>

Documents in M2000 are objects with paragraphs.

a$="ok"

a$+="(one)"

b$="(one)"

Print b$

{{out}}

<pre>ok(one)

=={{header|Maple}}==

b := cat(a, " World");

{{out}}

<pre>

=={{header|Mathematica}}/{{header|Wolfram Language}}==

s1 = "testing";

s1 = s1 <> " 123";

{{out}}

<pre>"testing 123"</pre>

=={{header|min}}==

{{works with|min|0.19.6}}

{{out}}

<pre>

=={{header|MontiLang}}==

|world!| var world .

=={{header|Nanoquery}}==

s1 += " a test"

{{out}}

The plus operator +, concats strings.

<doc><p>String append in Neko</pre></doc>

**/

var str = "Hello"

str += ", world"

{{out}}

<pre>prompt$ nekoc string-append.neko

=={{header|NetRexx}}==

s_ = s_', world!'

{{out}}

<pre>

=={{header|NewLISP}}==

(push "bar" str -1)

(println str)

=={{header|Nim}}==

str.add("78") # Using procedure "add".

str &= "9!" # Using operator "&=".

echo str

{{out}}

=={{header|NS-HUBASIC}}==

20 S$ = S$ + " WORLD!"

=={{header|Objeck}}==

class Append {

function : Main(args : String[]) ~ Nil {

}

}

=={{header|OCaml}}==

let s = Buffer.create 17 in

Buffer.add_string s "Bonjour";

Buffer.add_string s " tout le monde!";

{{out}}

<pre>Bonjour tout le monde!</pre>

=={{header|Oforth}}==

=={{header|PARI/GP}}==

Not supported in GP.

{{out}}

<pre>%1 = "Hello, world!"</pre>

{{works with|Free Pascal|2.6.2}}

{$mode objfpc}{$H+}

WriteLn(S);

ReadLn;

Output:

<pre>Hello World !</pre>

=={{header|Perl}}==

$str .= 'bar';

{{out}}

<pre>Foobar</pre>

=={{header|Phix}}==

{{libheader|Phix/basics}}

<span style="color: #004080;">string</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"this string"</span> <span style="color: #0000FF;">?</span><span style="color: #000000;">s</span>

<span style="color: #000000;">s</span> <span style="color: #0000FF;">&=</span> <span style="color: #008000;">" is now longer"</span> <span style="color: #0000FF;">?</span><span style="color: #000000;">s</span>

{{out}}

<pre>

=={{header|Picat}}==

S = "a string",

S := S + " that is longer",

{{out}}

=={{header|PicoLisp}}==

(setq Str1 (pack Str1 "9!"))

{{out}}

<pre>"123456789!"</pre>

=={{header|Pike}}==

string msg = "hello";

msg += " world";

write(msg +"\n");

{{Out}}

<pre>

=={{header|PL/I}}==

declare s character (100) varying;

s = 'dust ';

s ||= 'bowl';

put (s);

<pre>dust bowl</pre>

=={{header|Plain English}}==

Start up.

Put "abc" into a string.

Write the string to the console.

Wait for the escape key.

{{out}}

<pre>

=={{header|plainTeX}}==

Works with any TeX engine

\def\foo{Hello}

Initial: \foo

\addtomacro\foo{ world!}

Appended: \foo

pdf or dvi output:

=={{header|PowerShell}}==

$str = "Hello, "

$str += "World!"

$str

<pre>Hello, World!</pre>

=={{header|PureBasic}}==

S$ = S$ + " Wo" ;by referencing the string twice

S$ + "rld!" ;by referencing the string once

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

CloseConsole()

Sample output:

<pre>Hello World!</pre>

=={{header|Python}}==

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

str = "12345678";

str += "9!";

{{out}}

<pre>

=={{header|QB64}}==

s$ = s$ + " append"

{{out}}

<pre>String append</pre>

Quackery has no variables. The nearest equivalent is ''ancillary stacks''. The word <code>join</code> will return the concatenation of two nests on the stack, and hence two strings, as strings are a particular usage of nests. Here we define the word <code>append</code> to join a nest on the stack to a nest on an ancillary stack, and then demonstrate its use with a Jules Renard quotation and the predefined ancillary stack <code>temp</code>.

$ "L'homme qui attend de voir un canard roti voler " temp put

$ "dans sa bouche doit attendre tres, tres longtemps." temp append

{{out}}

=={{header|Racket}}==

(define mystr "foo")

(set! mystr (string-append mystr " bar"))

(define mymacrostr "foo")

(set-append! mymacrostr " bar")

{{out}}

=={{header|Raku}}==

(formerly Perl 6)

$str ~= "bar";

{{out}}

<pre>foobar</pre>

=={{header|Relation}}==

set a = "Hello"

set b = " World"

set c = a.b

echo c

=={{header|REXX}}==

===using abutment===

s=s'llo world!'

'''output'''

<pre>

===using concatenation===

s=s || 'llo, World!' /*same as: s=s||'llo, World!' */

'''output'''

<pre>

=={{header|Ring}}==

aString1 = "Welcome to the "

aString2 = "Ring Programming Language"

aString3 = aString1 + aString2

see aString3

=={{header|Robotic}}==

set "$str1" to "Hello "

inc "$str1" by "world!"

* "&$str1&"

end

=={{header|Ruby}}==

s += "rld" # new string object

s << "!" # mutates in place, same object

{{out}}<pre>Hello world!</pre>

=={{header|Rust}}==

use std::ops::Add;

let hello = String::from("Hello world");

println!("{}", hello.add("!!!!"));

{{out}}

Hello world!!!!

=== Real append ===

The first solution doesn't append to the string variable. This solution really appends to the existing variable.

fn main(){

let mut hello = String::from("Hello world");

println!("{}", hello);

}

{{out}}

Hello world!!!!

=={{header|Scala}}==

An evaluation in Scala worksheet.

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

val f2 = () => " !" //Function assigned to variable

//> f2 : () => String = <function0>

=={{header|Seed7}}==

const proc: main is func

str &:= "9!";

writeln(str);

{{out}}

=={{header|Sidef}}==