Copy a string: Difference between revisions

 

=={{header|11l}}==

 

=={{header|360 Assembly}}==

To copy a string, we use an MVC (Move Character). To make a reference to a string, we use a LA (Load Address).

MVC A,=CL64'Hello' a='Hello'

MVC B,A b=a memory copy

A DS CL64 a

B DS CL64 b

 

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

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

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program copystr64.s */

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

.include "../includeARM64.inc"

 

=={{header|ABAP}}==

lv_string2 type string.

 

===Inline Declaration===

{{works with|ABAP|7.4 Or above only}}

 

 

=={{header|ActionScript}}==

Strings are immutable in ActionScript, and can safely be assigned with the assignment operator, much as they can in Java.[http://livedocs.adobe.com/flash/9.0/main/00000647.html]

 

=={{header|Ada}}==

 

===Fixed Length String Copying.===

Ada provides the ability to manipulate slices of strings.

Dest : String := Src(1..7); -- Assigns "Rosetta" to Dest

 

===Bounded Length String Copying===

package Flexible_String is new Ada.Strings.Bounded.Generic_Bounded_Length(80);

use Flexible_String;

 

Src : Bounded_String := To_Bounded_String("Hello");

Ada Bounded_String type provides a number of functions for dealing with slices.

 

=== Unbounded Length String Copying===

Src : Unbounded_String := To_Unbounded_String("Hello");

 

=={{header|Aime}}==

 

Copying an intrinsic string:

t = "Rosetta";

Data of the non intrinsic byte array type can be referred more than once.

Copying a binary array of bytes:

# Copy -t- into -s-

b_copy(s, t);

# or:

s = t;

 

=={{header|ALGOL 68}}==

In ALGOL 68 strings are simply flexible length arrays of CHAR;

 

STRING src:="Hello", dest;

dest:=src

 

=={{header|ALGOL W}}==

% strings are (fixed length) values in algol W. Assignment makes a copy %

string(10) a, copyOfA;

a := "new value";

write( a, copyOfA )

{{out}}

<pre>

=={{header|Apex}}==

In Apex, Strings are a primitive data type

String cloned = original;

//"original == cloned" is true

 

cloned += ' more';

 

=={{header|AppleScript}}==

 

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program copystr.s */

 

 

 

=={{header|Arturo}}==

 

b: a ; reference the same string

 

'd ++ "World"

print d

 

{{out}}

HelloWorld

Hello</pre>

 

=={{header|AutoHotkey}}==

 

 

=={{header|AutoIt}}==

 

 

=={{header|AWK}}==

 

a = "a string"

b = a

sub(/a/, "X", a) # modify a

print b # b is a copy, not a reference to...

 

=={{header|Axe}}==

r₁→S

While {r₂}

0→{r₁}

S

 

=={{header|Babel}}==

To copy a string in Babel is the same as copying any other object. Use the cp operator to make a deep-copy.

 

babel> << <<

Yello, world

Hello, world

 

=={{header|BASIC}}==

 

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

110 IF LEN(P$) > 1 THEN ON PEEK(I + 1) = 128 GOTO 130 : IF MID$(P$, 2, 1) <> CHR$(PEEK(I + 1) - 128) GOTO 130

120 POKE I + 4, P / 256 : POKE I + 3, P - PEEK(I + 4) * 256 : RETURN

 

 

?S$

 

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

When using string variables by value:

 

b$ = a$

a$ = "Hello world..."

 

This will print "Hello world...I am here". The variables point to their individual memory areas so they contain different strings. Now consider the following code:

 

LOCAL b TYPE STRING

b = a$

a$ = "Goodbye..."

 

This will print "Goodbye...Goodbye..." because the variable 'b' points to the same memory area as 'a$'.

 

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

20 REM COPY CONTENTS OF A$ TO B$

30 B$ = A$

50 A$ = "HI"

60 REM DISPLAY CONTENTS

Commodore BASIC can't do pointers or 'reference to'

 

==={{header|Sinclair ZX81 BASIC}}===

Creating a new reference to an existing string is not possible, or at least not easy. (You could probably do it with <code>PEEK</code>s and <code>POKE</code>s.) This program demonstrates that an assignment statement copies a string, by showing that the two strings can afterwards be independently modified.

20 LET B$=A$

30 LET A$=A$( TO 21)

50 PRINT A$

60 LET B$=A$+B$(22 TO 29)

{{out}}

<pre>BECAUSE I DO NOT HOPE TO TURN AGAIN

Since the only variables are environment variables,

creating a string copy is fairly straightforward:

 

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

{{works with|BBC BASIC for Windows}}

REM Copy the contents of a string:

?(^same$+4) = ?(^source$+4)

?(^same$+5) = ?(^source$+5)

 

=={{header|Bracmat}}==

Still, you won't be able to test whether you got the original or a copy other than by looking at overall memory usage of the Bracmat program at the OS-level or by closely timing comparison operations.

You obtain a new reference to a string or a copy of the string by simple assignment using the <code>=</code> or the <code>:</code> operator:

!a:?b;

 

!a:!b { variables a and b are the same and probably referencing the same string }

!a:!d { variables a and d are also the same but not referencing the same string }

 

=={{header|C}}==

#include <stdio.h> /* fputs(), perror(), printf() */

#include <string.h>

 

return 0;

 

==={{libheader|BSD libc}}===

#include <stdio.h> /* fputs(), printf() */

#include <string.h>

 

return 0;

 

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

 

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

#include <string>

 

original = "Now we change the original! ";

std::cout << "my_copy still is " << my_copy << std::endl;

 

=={{header|Clojure}}==

 

s1 s]

 

=={{header|COBOL}}==

{{trans|C#}}

 

=={{header|ColdFusion}}==

Hence, any string copy operations are by value.

 

 

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

 

(s1-ref s1) ; another variable with the same value

(s2 (copy-seq s1))) ; s2 has a distinct string object with the same contents

(fill s2 #\!) ; overwrite s2

(princ s1)

 

=={{header|Component Pascal}}==

VAR

str1: ARRAY 128 OF CHAR;

str2: ARRAY 32 OF CHAR;

str3: ARRAY 25 OF CHAR;

...

str1 := "abcdefghijklmnopqrstuvwxyz";

str3 := str1; (* don't compile, incompatible assignement *)

str3 := str1$; (* runtime error, string too long *)

str2 := str1$; (* OK *)

 

=={{header|Computer/zero Assembly}}==

Assuming a string to be a zero-terminated array of bytes, this program takes a string beginning at address <tt>src</tt> and makes a copy of it beginning at address <tt>dest</tt>. As an example, we copy the string "Rosetta".

stdest: STA dest

BRZ done ; 0-terminated

0

 

 

=={{header|Crystal}}==

 

=={{header|D}}==

 

string src = "This is a string";

 

// copy just the fat reference of the string

auto dest3 = src;

 

=={{header|dc}}==

d # duplicate the top value

 

{{Out}}

Delphi strings are reference counted with [[wp:Copy-on-write|copy on write]] semantics.

 

 

{$APPTYPE CONSOLE}

Writeln(s1);

Writeln(s2);

 

{{out}}

Strings in Dyalect are immutable:

 

 

=={{header|Déjà Vu}}==

However, one can still create a copy of a string

by concatenating it with an empty string.

local :scopy concat( original "" )

{{out}}

<pre>"this is the original"</pre>

=={{header|EasyLang}}==

 

 

=={{header|EchoLisp}}==

Strings are immutable. A copy will return the same object.

(define-syntax-rule (string-copy s) (string-append s)) ;; copy = append nothing

→ #syntax:string-copy

t → "abc"

(eq? s t) → #t ;; same reference, same object

 

=={{header|EDSAC order code}}==

Expects the final character of a string to be marked with a 1 in the least significant bit, as in [[Hello world/Line printer#EDSAC order code]]. The source string should be loaded at <i>θ</i>+34; it is copied into storage tank 6. The copy is then printed out.

=============

 

ED

 

{{out}}

<pre>ROSETTA CODE</pre>

 

=={{header|Elena}}==

var src := "Hello";

var dst := src; // copying the reference

var copy := src.clone(); // copying the content

 

=={{header|Elixir}}==

 

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

 

=={{header|Erlang}}==

 

=={{header|Euphoria}}==

Euphoria will complain at the time your code does the assignment.

 

 

=={{header|F Sharp|F#}}==

.NET strings are immutable, so it is usually not useful to make a deep copy.

However if needed, it is possible using a static method of the <code>System.String</code> type:

let additionalReference = str

let deepCopy = System.String.Copy( str )

 

printfn "%b" <| System.Object.ReferenceEquals( str, additionalReference ) // prints true

 

=={{header|Factor}}==

Strings will be immutable in a future release.

 

"Let's make a deal!" dup clone ! copy

"New" " string" append . ! new string

 

Factor string buffers (sbufs) are mutable and growable.

 

 

Convert a string buffer to a string.

 

 

=={{header|Forth}}==

Thus the way you copy a string depends on where the source string comes from:

 

create stringa 256 allot

create stringb 256 allot

 

\ Copy the contents of one string buffer into another

 

=={{header|Fortran}}==

 

 

Because Fortran uses fixed length character strings if str1 is shorter than str2 then str2 is padded out with trailing spaces.

 

=={{header|FreeBASIC}}==

 

Dim s As String = "This is a string"

Print

Print *u, StrPtr(*u)

 

{{out}}

=={{header|Frink}}==

Strings are immutable after construction, so "copying" a string just creates a new reference to a string. All string manipulation routines return a new string.

a = "Monkey"

b = a

 

=={{header|FutureBasic}}==

 

 

Output:

<pre>

</pre>

 

 

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

Dim src As String

Dim dst As String

Print src

Print dst

 

=={{header|GAP}}==

a := "more";

b := a;

b{[1..4]} := "less";

a;

 

=={{header|GML}}==

 

=={{header|Go}}==

Just use assignment:

Strings in Go are immutable. Because of this, there is no need to distinguish between copying the contents and making an additional reference.

Technically, Go strings are immutable byte slices.

but the language does not specify this behavior or make any guarantees about it.

 

 

import "fmt"

// creature string

fmt.Println("creature =", creature) // creature = jellyfish

 

=={{header|Groovy}}==

 

Example and counter-example:

def stringRef = string // assigns another variable reference to the same object

 

Test Program:

assert string.is(stringRef) // they are references to the same objext (like Java ==)

assert string == stringCopy // they have equal values

 

'''Caveat Lector''': Strings are immutable objects in Groovy, so it is wasteful and utterly unnecessary to ever make copies of them within a Groovy program.

=={{header|GUISS}}==

 

Type:Hello world[pling],Highlight:Hello world[pling],

 

=={{header|Haskell}}==

 

=={{header|HicEst}}==

 

=={{header|i}}==

software {

a = "Hello World"

print(b)

}

 

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

Strings in Icon are immutable.

a := "qwerty"

b := a

b[2+:4] := "uarterl"

write(a," -> ",b)

 

Under the covers 'b' is created as a reference to the same string as 'a';

 

=={{header|J}}==

 

J has copy-on-write semantics.

=={{header|Java}}==

In Java, Strings are immutable, so it doesn't make that much difference to copy it.

String newAlias = src;

String strCopy = new String(src);

//"newAlias == src" is true

//"strCopy == src" is false

 

Instead, maybe you want to create a <code>StringBuffer</code> (mutable string) from an existing String or StringBuffer:

 

=={{header|JavaScript}}==

Objects can be copied in JavaScript via simple reassignment.

Changes to the properties of one will be reflected in the other:

var containerCopy = container; // Now both identifiers refer to the same object

 

 

If you copy property values with reassignment, such as properties of the global object (<code>window</code> in browsers), only the value will be copied and not the reference

var b = a; // Same as saying window.b = window.a

 

 

=={{header|Joy}}==

 

Strings are immutable.

jq is a functional language and all data types, including strings, are immutable. If a string were to be copied (e.g. by exploding and imploding it), the resultant string would be equal in all respects to the original, and from the jq programmer's perspective, the two would be identical.

 

"abc" as $s # assignment of a string to a variable

| $s as $t # $t points to the same string as $s

 

demo

{{Out}}

"abc"

=={{header|Julia}}==

Strings are immutable in Julia. Assignment of one string valued variable to another is effectively a copy, as subsequent changes to either variable have no effect on the other.

s = "Rosetta Code"

t = s

 

println("s = \"", s, "\" and, after this change, t = \"", t, "\"")

 

{{out}}

 

=={{header|KonsolScript}}==

 

=={{header|Kotlin}}==

val alias = s // alias === s

 

=={{header|LabVIEW}}==

In LabVIEW, one can simply wire an input to more than one output.<br/>

{{VI snippet}}<br/>[[File:LabVIEW_Copy_a_string.png]]

 

=={{header|Lang5}}==

 

=={{header|Lasso}}==

While other datatypes like arrays require ->asCopy & ->asCopyDeep methods,

assigning strings creates a copy, not a reference, as is seen below.

local(y = #x)

 

#x //I saw one too

'\r'

 

=={{header|Latitude}}==

Strings are immutable in Latitude, so it is seldom necessary to explicitly copy one. However, a copy can be distinguished from the original using <code>===</code>

b := a.

c := a clone.

println: a == c. ; True

println: a === b. ; True

 

=={{header|LC3 Assembly}}==

Copying a string is the same as copying any other zero-terminated array. This program copies the string at <tt>SRC</tt> to <tt>COPY</tt>, then prints the copy to show it has worked.

 

LEA R1,SRC

COPY .BLKW 128

 

{{out}}

<pre>What, has this thing appeared again tonight?</pre>

=={{header|LFE}}==

 

(b a))

 

{{out}}

One can also use <code>set</code> to copy a sting when one is in the LFE REPL:

 

"data"

> a

"data"

> b

 

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

dest$ = src$

print src$

print dest$

 

=={{header|Lingo}}==

 

Syntax-wise strings are not immuatable in Lingo. You can alter an existing string without new assignment:

 

put "X" after str

put "X" into char 6 of str

put str

 

But memory-wise they are immutable: Lingo internally stores references to strings, and as soon as a string is altered, a new copy is created on the fly, so other references to the original string are not affected by the change.

 

=={{header|Lisaac}}==

+ svar : STRING;

 

svar.append "!\n";

 

STRING_CONSTANT is immutable, STRING is not.

 

=={{header|Little}}==

string b = a;

a =~ s/$/\./;

puts(a);

 

=={{header|LiveCode}}==

put bar into baz

 

Copies are nearly always made, on function calls parameters may be passed by reference (pointer) by prepending @ to a parameter in the function definition, however this is the only case where it is usually performed.

=={{header|Logo}}==

As a functional language, words are normally treated as symbols and cannot be modified. The EQUAL? predicate compares contents instead of identity. In [[UCB Logo]] the .EQ predicate tests for "thing" identity.

make "b "foo

print .eq :a :b ; true, identical symbols are reused

make "c word :b "|| ; force a copy of the contents of a word by appending the empty word

print equal? :b :c ; true

 

=={{header|Lua}}==

Lua strings are immutable, so only one reference to each string exists.

a = "string"

b = a

print(a == b) -->true

 

=={{header|Maple}}==

In Maple, you cannot really copy a string in the sense that there can be two copies of the string in memory. As soon as you create a second copy of a string that already exists, it get turned into a reference to the first copy. However, you can copy a reference to a string by a simple assignment statement.

> s := "some string";

s := "some string"

 

> u := t: # copy reference

 

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

 

=={{header|MATLAB}}==

 

=={{header|Maxima}}==

Also, the result is "Lisp character", which cannot be used by other Maxima functions except cunlisp. The usual

way to access characters is charat, returning a "Maxima character" (actually a one characte string). With the latter,

 

c;

 

=={{header|MAXScript}}==

 

=={{header|Metafont}}==

Metafont will always copy a string (does not make references).

 

s := "hello";

a := s;

message s; % writes "hello world"

message a; % writes "hello"

 

=={{header|MiniScript}}==

copy = phrase

print phrase

 

=={{header|MIPS Assembly}}==

This does a full copy of the string, not just copying the pointer to the string's contents.

.text

addi $sp, $sp, 4

jr $ra

 

=={{header|Mirah}}==

new_alias = src

 

puts 'non-interned strings are not equal' if str_copy != src

puts 'compare strings with equals()' if str_copy.equals(src)

 

=={{header|Modula-3}}==

Strings in Modula-3 have the type <code>TEXT</code>.

 

=={{header|MUMPS}}==

 

=={{header|Nanoquery}}==

 

=={{header|Neko}}==

 

=={{header|Nemerle}}==

Nemerle gives you the option of declaring a variable - even a string - as mutable, so the caveats of languages with only immutable strings don't necessarily apply. However, Nemerle binds the value of the string to the new name when copying; to sort of emulate copying a reference you can use lazy evaluation.

using System.Console;

using Nemerle;

// I am not changed

}

 

=={{header|NetRexx}}==

In addition to the string capabilities provided by the Java String libraries (see [[#Java|Java]] for some examples) NetRexx provides comprehensive string capabilities through the built-in Rexx type. Rexx strings can be copied by simple assignment; as follows:

options replace format comments java crossref symbols nobinary

 

 

say s1

In this example a string is created, the string is copied then the copy is modified with the <tt>changestr</tt> built-in function. Finally both strings are displayed to confirm that the original string wasn't modified by the call to <tt>changestr</tt>.

 

 

=={{header|NewLISP}}==

 

(setq s "Greetings!" c (copy s))

true

 

 

=={{header|Nim}}==

c = "This is a string"

 

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

20 B$ = A$

30 A$ = "HI"

 

=={{header|Oberon-2}}==

TYPE

String = ARRAY 128 OF CHAR;

a := "plain string";

COPY(a,b);

 

=={{header|Objeck}}==

 

=={{header|Objective-C}}==

Note that both <code>copy</code> and <code>initWithString:</code>/<code>stringWithString:</code> are optimized to return the original string object (possibly retained) if it is immutable.

 

NSString *new = [original copy];

NSString *anotherNew = [NSString stringWithString:original];

 

Mutable strings - you can get either new mutable (if you use <code>mutableCopy</code>) or immutable (if you use <code>copy</code>) string:

 

NSString *immutable = [original copy];

NSString *anotherImmutable = [NSString stringWithString:original];

 

Copying a CString into an NSString:

 

 

Copying from data, possibly not null terminated:

 

 

And of course, if a C string is needed, you can use standard functions like strcpy.

 

=={{header|OCaml}}==

<br/>

Before OCaml 4.02 (2014), strings were mutable and explicit deep copying was needed:

<br/>

Between 4.02 and 4.06 (2017), immutable strings were optionally enabled via a flag: <code>-safe-string</code>. A <code>Bytes</code> module was added to provide safe and unsafe mutable views on strings. The two modules were synonymous unless the aforementioned flag was added.

let dst1 : string = Bytes.copy (src : bytes)

let dst2 : bytes = Bytes.copy (src : string)

<br/>

After 4.06, immutable strings became the default, <code>Bytes</code> still exists, but its type is now distinct. The only way to get mutable strings and type synonymy back is at configure-time on the compiler itself.<br/>

<code>String.copy</code> issues a deprecation warning, and a (shallow) copy would simply be an assignment by default:

To get a mutable deep-copy still, just convert the string to bytes via <code>Bytes.of_string</code>, which copies for safety, or <code>String.sub/map/init/..</code> for an immutable copy.

<br/>

 

=={{header|Octave}}==

 

=={{header|Oforth}}==

To make a copy of the reference, just dup the string

 

There is no need to copy a string content as strings are immutable. If really needed :

 

=={{header|ooRexx}}==

* 16.05.2013 Walter Pachl

**********************************************************************/

Say 's2='s2

i1=s1~identityhash; Say 's1~identityhash='i1

{{out}}

<pre>s1=This is a Rexx string

 

=={{header|OxygenBasic}}==

string s, t="hello"

s=t

 

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

Assignment in GP always copies.

 

In PARI, strings can be copied and references can be made.

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

To copy a string, just use ordinary assignment:

 

my $new = $original;

$new = 'Goodbye.';

 

To create a reference to an existing string, so that modifying the referent changes the original string, use a backslash:

 

my $ref = \$original;

$$ref = 'Goodbye.';

 

If you want a new name for the same string, so that you can modify it without dereferencing a reference, assign a reference to a typeglob:

 

our $alias;

local *alias = \$original;

$alias = 'Good evening.';

 

Note that <tt>our $alias</tt>, though in most cases a no-op, is necessary under stricture. Beware that <tt>local</tt> binds dynamically, so any subroutines called in this scope will see (and possibly modify!) the value of <tt>$alias</tt> assigned here.

 

To make a lexical variable that is an alias of some other variable, the [http://search.cpan.org/perldoc?Lexical::Alias Lexical::Alias] module can be used:

my $original = 'Hello.';

my $alias;

alias $alias, $original;

$alias = 'Good evening.';

 

=={{header|Phix}}==

{{libheader|Phix/basics}}

Use of strings is utterly intuitive with no unexpected side effects. For example

<span style="color: #004080;">string</span> <span style="color: #000000;">one</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"feed"</span>

<span style="color: #004080;">string</span> <span style="color: #000000;">two</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">one</span> <span style="color: #000080;font-style:italic;">-- (two becomes "feed", one remains "feed")</span>

<span style="color: #000000;">one<span style="color: #0000FF;">[<span style="color: #000000;">1<span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">'n'</span> <span style="color: #000080;font-style:italic;">-- (two remains "food", one becomes "need")</span>

<span style="color: #0000FF;">?<span style="color: #0000FF;">{<span style="color: #000000;">one<span style="color: #0000FF;">,<span style="color: #000000;">two<span style="color: #0000FF;">}

{{out}}

<pre>

=={{header|PHP}}==

 

 

=={{header|PicoLisp}}==

(setq Str2 Str1) # Create a reference to that symbol

 

=={{header|Pike}}==

string hi = "Hello World.";

string ih = hi;

 

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

s1 = 'now is the time';

 

=={{header|Pop11}}==

In Pop11 normal data are represented by references, so plain assignment will copy references. To copy data one has to use copy procedure:

 

'Hello' -> src;

 

One can also combine assignment (initialization) with variable declarations:

 

 

=={{header|PostScript}}==

In PostScript,

 

=={{header|PowerShell}}==

Since PowerShell uses .NET behind the scenes and .NET strings are immutable you can simply assign the same string to another variable without breaking anything:

To actually create a copy the <code>Clone()</code> method can be used:

 

=={{header|ProDOS}}==

editvar /newvar /value=b /userinput=1 /title=Enter current directory of the string:

editvar /newvar /value=c /userinput=1 /title=Enter file to copy to:

 

=={{header|Prolog}}==

Values in Prolog are immutable so unifying with a variable that already has the value of a string will effectively copy that string.

You cannot reassign a value once it has been unified, it is not logical to have a value equal more than one thing.

 

=={{header|PureBasic}}==

 

=={{header|Python}}==

Since strings are immutable, all copy operations return the same string, with the reference count increased as appropriate

 

>>> a = src

>>> b = src[:]

>>> d = copy.deepcopy(src)

>>> src is a is b is c is d

 

To actually copy a string:

 

>>> b = ''.join(a)

>>> a == b

True

>>> b is a ### Might be True ... depends on "interning" implementation details!

 

As a result of object "interning" some strings such as the empty string and single character strings like 'a' may be references to the same object regardless of copying. This can potentially happen with any Python immutable object and should be of no consequence to any proper code.

<br>

Strings are immutable.

 

=={{header|R}}==

Copy a string by value:

 

=={{header|Racket}}==

#lang racket

 

(string-fill! s3 #\!)

(printf "~a~a~a~a\n" s1 s2 s3 s4)) ; outputs "HeyHey!!!!!!"

 

=={{header|Raku}}==

 

There is no special handling needed to copy a string; just assign it to a new variable:

my $copy = $original;

say $copy; # prints "Hello."

$copy = 'Goodbye.';

say $copy; # prints "Goodbye."

 

You can also bind a new variable to an existing one so that each refers to, and can modify the same string.

my $bound := $original;

say $bound; # prints "Hello."

$bound = 'Goodbye.';

say $bound; # prints "Goodbye."

 

<!-- SqrtNegInf 2016-01-16 This is NYI, so until such time as it is, leaving this section commented

You can also create a read-only binding which will allow read access to the string but prevent modification except through the original variable.

#my $bound-ro ::= $original;

#say $bound-ro; # prints "Hello."

say $bound-ro; # prints "Hello."

$original = 'Goodbye.';

-->

 

Copy a string by reference:

 

 

Copy a string by value:

 

 

=={{header|REBOL}}==

Title: "String Copy"

URL: http://rosettacode.org/wiki/Copy_a_string

 

y: copy/part skip x 2 3

 

{{out}}

 

=={{header|Red}}==

Red[]

originalString: "hello wordl"

; OR

copiedString2: copy originalString

 

=={{header|Retro}}==

 

=={{header|REXX}}==

Also note that &nbsp; ''all'' &nbsp; REXX values (variables) are

stored as (varying length) &nbsp; ''character strings''.

 

=={{header|Ring}}==

cStr1 = "Hello!" # create original string

cStr2 = cStr1 # make new string from original

 

=={{header|RLaB}}==

A string

>> s2 = s1

 

=={{header|Robotic}}==

set "$string1" to "This is a string"

set "$string2" to "$string1"

* "&$string2&"

 

=={{header|Ruby}}==

In Ruby, String are mutable.

reference = original # copies reference

copy1 = original.dup # instance of original.class

p reference #=> "hello world!"

p copy1 #=> "hello"

 

There is a method of Object#clone, too, in the copy of the object.

copy1 = original.dup # copies contents (without status)

copy2 = original.clone # copies contents (with status)

p copy1 << " world!" #=> "hello world!"

p copy2.frozen? #=> true

 

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

 

=={{header|Rust}}==

let s1 = "A String";

let mut s2 = s1;

 

println!("s1 = {}, s2 = {}", s1, s2);

 

 

=={{header|Sather}}==

main is

s ::= "a string";

-- s1 is a copy

end;

 

=={{header|Scala}}==

// Its actually not a copy but a reference

// That is not a problem because String is immutable

assert((src eq cop)) // Still no copyed image

val copy = src.reverse.reverse // Finally double reverse makes a copy

 

=={{header|Scheme}}==

 

 

 

 

=={{header|SenseTalk}}==

 

put "glorious" into myWord

put "myRef: " & myRef

put "another: " & another

{{out}}

<pre>

 

=={{header|Shiny}}==

 

=={{header|Sidef}}==

var reference = original; # points at the original object

var copy1 = String.new(original); # creates a new String object

=={{header|Simula}}==

TEXT ORIGINAL, REFERENCE, COPY1;

 

OUTTEXT(COPY1);

OUTIMAGE;

{{out}}

<pre>

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

 

"bind the var s1 to the object string on the right"

s1 := 'i am a string'.

s2 := s1.

"bind s2 to a copy of the object bound to s1"

 

=={{header|SNOBOL4}}==

* copy a to b

b = a = "test"

b "t" = "T"

output = b

 

{{out}}

 

Instead, maybe you want to create a <code>CharArray.array</code> (mutable string) from an existing <code>string</code>:

val srcCopy = CharArray.array (size src, #"x"); (* 'x' is just dummy character *)

CharArray.copyVec {src = src, dst = srcCopy, di = 0};

 

or from another <code>CharArray.array</code>:

 

=={{header|Swift}}==

Just use assignment:

Strings in Swift are value types, so assigning copies the string.

 

=={{header|Tcl}}==

Tcl copies strings internally when needed.

To be exact, it uses a basic value model based on simple objects that are immutable when shared (i.e., when they have more than one effective reference to them); when unshared, they can be changed because the only holder of a reference has to be the code requesting the change.

 

=={{header|TI-83 BASIC}}==

 

=={{header|TI-89 BASIC}}==

 

=={{header|Toka}}==

 

=={{header|Trith}}==

Strings are immutable character sequences,

so copying a string just means duplicating the reference at the top of the stack:

 

=={{header|TUSCRIPT}}==

str="Hello"

 

=={{header|UNIX Shell}}==

 

 

=={{header|Ursa}}==

set a "hello"

 

=={{header|V}}==

so the string is immutable.

 

 

=={{header|VBA}}==

This program copies string in variable a to variable b. Mutating variable a subsequently doesn't alter variable b. Variable b is not a reference.

a = "Hello World!"

b = a

Debug.Print b

Debug.Print a

<pre>Hello World!

I'm gone</pre>

 

=={{header|Vim Script}}==

let str2 = str1

let str1 = "new string"

 

echo "String 1:" str1

 

{{Out}}

 

{{works with|Visual Basic .NET|9.0+}}

Dim a = "Test string"

Dim b = a 'reference to same string

Dim x As New Text.StringBuilder("Test string")

Dim y = x 'reference

 

Alternatively, you can use, with all versions of the .NET framework:

 

=={{header|Wren}}==

 

Although technically a reference type, this means there is no need to distinguish between copying the contents of a string and making an additional reference. We can therefore just use assignment to copy a string.

var t = s

 

{{out}}

{{works with|nasm}}

creating a second 0 terminated string with the same content:

section .data

string db "Hello World", 0

xor eax, eax

ret

 

creating a second string; first byte signals length of string

section .data

string db 11,"Hello World"

xor eax, eax

ret

 

=={{header|X86-64 Assembly}}==

option casemap:none

option literals:on

jne _getsize ;; nope, jump back and check again

 

lea rsi, s ;; Copy the address of s into the source index(rsi)

lea rdi, d ;; Copy the address of d into the destination index(rdi)

mov dp, rax ;; Copy it from RAX to dp

invoke printf, CSTR("-> s (0x%x) = %s",10), rsi, addr s

invoke printf, CSTR("-> d (0x%x) = %s",10), rbx, addr d

 

end

<pre>

-> s (0x40303f) = Goodbye, World!

-> dp (0x4030a4) = Goodbye, World!

-> bytes copied: 15

</pre>

 

The string copy routine from the standard library is shown.

 

char A, B; \Strings: B must already have enough space "Reserved"

int I; \Beware if strings overlap

S2:= S1; \S2 now also points to the string

StrCopy(S1, S3); \S3 points to a separate copy of the string

 

=={{header|Zig}}==

 

const debug = std.debug;

debug.assert(mem.eql(u8, dest1[0..], "A string."));

debug.assert(mem.eql(u8, dest2[0..], "A string."));

 

=={{header|zkl}}==

Strings are immutable so copy is just return the string:

 

=={{header|zonnon}}==

module Main;

var

copy(c,r);writeln(r);

end Main.

 

=={{header|Zoomscript}}==

For typing:

var b

a = "World"

b = a

a = "Hello"

For importing:

 

=={{header|ZX Spectrum Basic}}==