Copy a string: Difference between revisions
Content deleted Content added
Puppydrum64 (talk | contribs) No edit summary |
Added S-BASIC example |
||
(43 intermediate revisions by 27 users not shown) | |||
Line 17:
=={{header|11l}}==
<
V dst = copy(src)</
=={{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
Line 38:
A DS CL64 a
B DS CL64 b
REFA DS A @a</
=={{header|6502 Assembly}}==
<syntaxhighlight lang="6502asm">source equ $10 ;$10 was chosen arbitrarily
source_hi equ source+1 ;the high byte MUST be after the low byte, otherwise this will not work.
dest equ $12
dest_hi equ dest+1
LDA #<MyString ;get the low byte of &MyString
STA source
LDA #>MyString ;get the high byte
STA source_hi ;we just created a "shallow reference" to an existing string.
;As it turns out, this is a necessary step to do a deep copy.
LDA #<RamBuffer
STA dest
LDA #>RamBuffer
STA dest_hi
strcpy:
;assumes that RamBuffer is big enough to hold the source string, and that the memory ranges do not overlap.
;if you've ever wondered why C's strcpy is considered "unsafe", this is why.
LDY #0
.again:
LDA (source),y
STA (dest),y
BEQ .done
INY
BNE .again ;exit after 256 bytes copied or the null terminator is reached, whichever occurs first.
RTS
MyString:
byte "hello",0
RamBuffer:
byte 0,0,0,0,0,0</syntaxhighlight>
=={{header|68000 Assembly}}==
Making a reference to an existing string is simple. Just load its memory location into an address register.
<
EVEN
LEA myString,A3</
Copying a string involves a little more work:
<
myString: DC.B "HELLO WORLD",0
Line 57 ⟶ 94:
CopyString:
MOVE.B (A3)+,D0
MOVE.B D0,(A4)+ ;we could have
BEQ Terminated
BRA CopyString
Terminated: ;the null terminator is already stored along with the string itself, so we are done.
;program ends here.</syntaxhighlight>
=={{header|8086 Assembly}}==
The technique varies depending on whether you just want a new reference to the old string or to actually duplicate it in RAM. Strangely, this is one of the few things that's actually easier to do correctly in assembly than in high-level languages - it's very unlikely you'll do the wrong one by accident.
===Making a new reference===
This technique is useful if you wish to create a struct/record that needs to be able to retrieve a string quickly. All you need to do is get a pointer to the desired string and store it in RAM.
<syntaxhighlight lang="asm">.model small
.stack 1024
.data
myString byte "Hello World!",0 ; a null-terminated string
myStruct word 0
.code
mov ax,@data
mov ds,ax ;load data segment into DS
mov bx,offset myString ;get the pointer to myString
mov word ptr [ds:myStruct],bx
mov ax,4C00h
int 21h ;quit program and return to DOS</syntaxhighlight>
===Creating a "deep copy"===
This method will actually make a byte-for-byte copy somewhere else in RAM.
<syntaxhighlight lang="asm">.model small
.stack 1024
.data
myString byte "Hello World!",0 ; a null-terminated string
StringRam byte 256 dup (0) ;256 null bytes
.code
mov ax,@data
mov ds,ax ;load data segment into DS
mov es,ax ;also load it into ES
mov si,offset myString
mov di,offset StringRam
mov cx,12 ;length of myString
cld ;make MOVSB auto-increment rather than auto-decrement (I'm pretty sure DOS begins with
;the direction flag cleared but just to be safe)
rep movsb ;copies 12 bytes from [ds:si] to [es:di]
mov al,0 ;create a null terminator
stosb ;store at the end. (It's already there since we initialized StringRam to zeroes, but you may need to do this depending
;on what was previously stored in StringRam, if you've copied a string there already.
mov ax,4C00h
int 21h ;quit program and return to DOS</syntaxhighlight>
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<syntaxhighlight lang="aarch64 assembly">
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program copystr64.s */
Line 131 ⟶ 225:
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
</syntaxhighlight>
=={{header|ABAP}}==
<
lv_string2 type string.
lv_string2 = lv_string1.</
===Inline Declaration===
{{works with|ABAP|7.4 Or above only}}
<
DATA(string2) = string1.</
=={{header|Action!}}==
<syntaxhighlight lang="action!">PROC Main()
CHAR ARRAY str1,str2,str3(10)
str1="Atari"
str2=str1
SCopy(str3,str1)
PrintF(" base=%S%E",str1)
PrintF("alias=%S%E",str2)
PrintF(" copy=%S%E",str3)
PutE()
SCopy(str1,"Action!")
PrintF(" base=%S%E",str1)
PrintF("alias=%S%E",str2)
PrintF(" copy=%S%E",str3)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Copy_a_string.png Screenshot from Atari 8-bit computer]
<pre>
base=Atari
alias=Atari
copy=Atari
base=Action!
alias=Action!
copy=Atari
</pre>
=={{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]
<
var str2:String = str1;</
=={{header|Ada}}==
Line 157 ⟶ 282:
===Fixed Length String Copying.===
<
Dest : String := Src;</
Ada provides the ability to manipulate slices of strings.
<
Dest : String := Src(1..7); -- Assigns "Rosetta" to Dest
Dest2 : String := Src(9..13); -- Assigns "Stone" to Dest2</
===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");
Dest : Bounded_String := Src;</
Ada Bounded_String type provides a number of functions for dealing with slices.
=== Unbounded Length String Copying===
<
Src : Unbounded_String := To_Unbounded_String("Hello");
Dest : Unbounded_String := Src;</
=={{header|Aime}}==
Line 183 ⟶ 308:
Copying an intrinsic string:
<
t = "Rosetta";
s = t;</
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);
Line 195 ⟶ 320:
# or:
s = t;
</syntaxhighlight>
=={{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;
Line 214 ⟶ 339:
a := "new value";
write( a, copyOfA )
end.</
{{out}}
<pre>
Line 222 ⟶ 347:
=={{header|Apex}}==
In Apex, Strings are a primitive data type
<
String cloned = original;
//"original == cloned" is true
cloned += ' more';
//"original == cloned" is false</
=={{header|AppleScript}}==
<
set dst to src</
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
/* program copystr.s */
Line 314 ⟶ 439:
</syntaxhighlight>
=={{header|Arturo}}==
<
b: a ; reference the same string
Line 336 ⟶ 461:
'd ++ "World"
print d
print c</
{{out}}
Line 344 ⟶ 469:
HelloWorld
Hello</pre>
=={{header|Asymptote}}==
<syntaxhighlight lang="asymptote">string src, dst;
src = "Hello";
dst = src;
src = " world...";
write(dst, src);</syntaxhighlight>
=={{header|AutoHotkey}}==
<
dst := src</
=={{header|AutoIt}}==
<
$dest = $Src</
=={{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₂}
Line 374 ⟶ 506:
0→{r₁}
S
Return</
=={{header|Babel}}==
Line 380 ⟶ 512:
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
</syntaxhighlight>
=={{header|BASIC}}==
Line 393 ⟶ 525:
==={{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
130 NEXT I : STOP</
<
C$ = S$ : REM C$ IS THE COPY</
<
?S$
?C$</
==={{header|BaCon}}===
Line 414 ⟶ 546:
When using string variables by value:
<
b$ = a$
a$ = "Hello world..."
PRINT a$, b$</
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..."
PRINT a$, b</
This will print "Goodbye...Goodbye..." because the variable 'b' points to the same memory area as 'a$'.
==={{header|BASIC256}}===
<syntaxhighlight lang="freebasic">src$ = "Hello"
dst$ = src$
src$ = " world..."
print dst$; src$</syntaxhighlight>
==={{header|QBasic}}===
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
{{works with|PB|7.1}}
<syntaxhighlight lang="qbasic">src$ = "Hello" ' is the original string
dst$ = src$ ' is the copy
src$ = " world..."
PRINT dst$; src$</syntaxhighlight>
==={{header|SmallBASIC}}===
<syntaxhighlight lang="qbasic">
src = "Hello"
dst = src
src = " world..."
PRINT dst; src
</syntaxhighlight>
==={{header|True BASIC}}===
{{works with|QBasic}}
{{works with|BASIC256}}
{{works with|Yabasic}}
<syntaxhighlight lang="qbasic">LET src$ = "Hello"
LET dst$ = src$
LET src$ = " world..."
PRINT dst$; src$
END</syntaxhighlight>
==={{header|Yabasic}}===
<syntaxhighlight lang="yabasic">src$ = "Hello"
dst$ = src$
src$ = " world..."
print dst$, src$
end</syntaxhighlight>
==={{header|Commodore BASIC}}===
<
20 REM COPY CONTENTS OF A$ TO B$
30 B$ = A$
Line 436 ⟶ 609:
50 A$ = "HI"
60 REM DISPLAY CONTENTS
70 PRINT A$, B$</
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)
Line 447 ⟶ 620:
50 PRINT A$
60 LET B$=A$+B$(22 TO 29)
70 PRINT B$</
{{out}}
<pre>BECAUSE I DO NOT HOPE TO TURN AGAIN
Line 456 ⟶ 629:
Since the only variables are environment variables,
creating a string copy is fairly straightforward:
<
set dst=%src%</
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<
REM Copy the contents of a string:
Line 471 ⟶ 644:
?(^same$+4) = ?(^source$+4)
?(^same$+5) = ?(^source$+5)
PRINT same$</
=={{header|Binary Lambda Calculus}}==
In BLC, every value is immutable, including byte-strings. So one never needs to copy them; references are shared.
=={{header|BQN}}==
BQN strings are character arrays. Like all other types of arrays, they are immutable.
String copying in BQN is left to be defined by the implementation, but [[CBQN]] and [[mlochbaum/BQN]](main implementations) copy only the reference until the original source is modified.
<syntaxhighlight lang="bqn">a ← "Hello"
b ← a
•Show a‿b
a ↩ "hi"
•Show a‿b</syntaxhighlight><syntaxhighlight lang="bqn">⟨ "Hello" "Hello" ⟩
⟨ "hi" "Hello" ⟩</syntaxhighlight>
=={{header|Bracmat}}==
Line 480 ⟶ 668:
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;
Line 488 ⟶ 676:
!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 }
</syntaxhighlight>
=={{header|C}}==
<
#include <stdio.h> /* fputs(), perror(), printf() */
#include <string.h>
Line 550 ⟶ 738:
return 0;
}</
==={{libheader|BSD libc}}===
<
#include <stdio.h> /* fputs(), printf() */
#include <string.h>
Line 574 ⟶ 762:
return 0;
}</
==={{libheader|Gadget}}===
Versión 2, using Gadget library.
Link:
https://github.com/DanielStuardo/Gadget
<syntaxhighlight lang="c">
#include <gadget/gadget.h>
LIB_GADGET_START
Main
String v, w = "this message is a message";
Let( v, "Hello world!");
Print "v = %s\nw = %s\n\n", v,w;
Get_fn_let( v, Upper(w) );
Print "v = %s\nw = %s\n\n", v,w;
Stack{
Store ( v, Str_tran_last( Upper(w), "MESSAGE", "PROOF" ) );
}Stack_off;
Print "v = %s\nw = %s\n\n", v,w;
Free secure v, w;
End
</syntaxhighlight>
{{out}}
<pre>
v = Hello world!
w = this message is a message
v = THIS MESSAGE IS A MESSAGE
w = this message is a message
v = THIS MESSAGE IS A PROOF
w = this message is a message
</pre>
=={{header|C sharp|C#}}==
<
string dst = src;</
=={{header|C++}}==
<
#include <string>
Line 590 ⟶ 825:
original = "Now we change the original! ";
std::cout << "my_copy still is " << my_copy << std::endl;
}</
=={{header|Clojure}}==
<
s1 s]
(println s s1))</
=={{header|COBOL}}==
{{trans|C#}}
<
MOVE src TO dst</
=={{header|ColdFusion}}==
Line 608 ⟶ 843:
Hence, any string copy operations are by value.
<
<cfset stringCopy = stringOrig /></
=={{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
Line 622 ⟶ 857:
(fill s2 #\!) ; overwrite s2
(princ s1)
(princ s2)) ; will print "Hello!!!!!"</
=={{header|Component Pascal}}==
<
VAR
str1: ARRAY 128 OF CHAR;
str2: ARRAY 32 OF CHAR;
str3: ARRAY 25 OF CHAR;
</syntaxhighlight>
...
<
str1 := "abcdefghijklmnopqrstuvwxyz";
str3 := str1; (* don't compile, incompatible assignement *)
str3 := str1$; (* runtime error, string too long *)
str2 := str1$; (* OK *)
</syntaxhighlight>
=={{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
Line 668 ⟶ 903:
0
dest:</
=={{header|Crystal}}==
<
s2 = s1</
=={{header|D}}==
<
string src = "This is a string";
Line 687 ⟶ 922:
// copy just the fat reference of the string
auto dest3 = src;
}</
=={{header|dc}}==
<
d # duplicate the top value
f # show the current contents of the main stack</
{{Out}}
Line 702 ⟶ 937:
Delphi strings are reference counted with [[wp:Copy-on-write|copy on write]] semantics.
<
{$APPTYPE CONSOLE}
Line 716 ⟶ 951:
Writeln(s1);
Writeln(s2);
end.</
{{out}}
Line 735 ⟶ 970:
Strings in Dyalect are immutable:
<
var dst = src</
=={{header|Déjà Vu}}==
Line 744 ⟶ 979:
However, one can still create a copy of a string
by concatenating it with an empty string.
<
local :scopy concat( original "" )
!. scopy</
{{out}}
<pre>"this is the original"</pre>
Line 758 ⟶ 993:
=={{header|EasyLang}}==
<syntaxhighlight lang
b$ = a$
print b$
</syntaxhighlight>
=={{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
Line 770 ⟶ 1,008:
t → "abc"
(eq? s t) → #t ;; same reference, same object
</syntaxhighlight>
=={{header|Ed}}==
Copies the current buffer contents in its entirety.
<syntaxhighlight>
,t
</syntaxhighlight>
=={{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.
<
=============
Line 836 ⟶ 1,082:
ED
EZPF</
{{out}}
<pre>ROSETTA CODE</pre>
=={{header|Elena}}==
<
var src := "Hello";
var dst := src; // copying the reference
var copy := src.clone(); // copying the content
</syntaxhighlight>
=={{header|Elixir}}==
<
dst = src</
=={{header|Emacs Lisp}}==
<syntaxhighlight lang="lisp">(
(str2 (copy-sequence str1)))
(eq str1 str1-ref) ;=> t
(eq str1 str2) ;=> nil
(equal str1 str1-ref) ;=> t
(equal str1 str2)) ;=> t</syntaxhighlight>
=={{header|EMal}}==
in EMal strings are mutable
<syntaxhighlight lang="emal">
text original = "Yellow world"
text ref = original # copying the reference
text copied = *original # copying the content
original[0] = "H" # texts are indexable and mutable
original[5] = ","
ref.append("!") # texts are coercible and growable
copied += "?"
^|
| original == ref == "Hello, world!"
| copied == "Yellow world?"
|^
</syntaxhighlight>
=={{header|Erlang}}==
<
Dst = Src.</
=={{header|Euphoria}}==
Line 873 ⟶ 1,139:
Euphoria will complain at the time your code does the assignment.
<
sequence newOne = first</
=={{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
printfn "%b" <| System.Object.ReferenceEquals( str, deepCopy ) // prints false</
=={{header|Factor}}==
Line 891 ⟶ 1,157:
Strings will be immutable in a future release.
<
"Let's make a deal!" dup clone ! copy
"New" " string" append . ! new string
"New string"</
Factor string buffers (sbufs) are mutable and growable.
<
SBUF" Grow me! OK."</
Convert a string buffer to a string.
<
"I'll be a string someday."</
=={{header|Forth}}==
Line 913 ⟶ 1,179:
Thus the way you copy a string depends on where the source string comes from:
<
create stringa 256 allot
create stringb 256 allot
Line 921 ⟶ 1,187:
\ Copy the contents of one string buffer into another
stringa count stringb place</
=={{header|Fortran}}==
<
Because Fortran uses fixed length character strings if str1 is shorter than str2 then str2 is padded out with trailing spaces.
Line 931 ⟶ 1,197:
=={{header|FreeBASIC}}==
<
Dim s As String = "This is a string"
Line 942 ⟶ 1,208:
Print
Print *u, StrPtr(*u)
Sleep</
{{out}}
Line 954 ⟶ 1,220:
=={{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
</syntaxhighlight>
=={{header|FutureBasic}}==
<syntaxhighlight lang="text">
include "
CFStringRef original, copy
original = @"Hello!"
copy = fn StringWithString( original )
NSLog( @"%@", copy )
HandleEvents
</syntaxhighlight>
Output:
<pre>
</pre>
Line 979 ⟶ 1,249:
'''[https://gambas-playground.proko.eu/?gist=b88224f45b9b5be09eafdf069b059076 Click this link to run this code]'''
<
Dim src As String
Dim dst As String
Line 988 ⟶ 1,258:
Print src
Print dst
End</
=={{header|GAP}}==
<
a := "more";
b := a;
Line 1,003 ⟶ 1,273:
b{[1..4]} := "less";
a;
# "more"</
=={{header|GML}}==
<
dest = src;</
=={{header|Go}}==
Just use assignment:
<
dst := src</
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.
Line 1,020 ⟶ 1,290:
but the language does not specify this behavior or make any guarantees about it.
::<
import "fmt"
Line 1,041 ⟶ 1,311:
// creature string
fmt.Println("creature =", creature) // creature = jellyfish
}</
=={{header|Groovy}}==
Line 1,048 ⟶ 1,318:
Example and counter-example:
<
def stringRef = string // assigns another variable reference to the same object
def stringCopy = new String(string) // copies string value into a new object, and assigns to a third variable reference</
Test Program:
<
assert string.is(stringRef) // they are references to the same objext (like Java ==)
assert string == stringCopy // they have equal values
assert ! string.is(stringCopy) // they are references to different objects (like Java !=)</
'''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.
Line 1,062 ⟶ 1,332:
=={{header|GUISS}}==
<
Type:Hello world[pling],Highlight:Hello world[pling],
Menu,Edit,Copy,Menu,Edit,Paste</
=={{header|Harbour}}==
<syntaxhighlight lang="visualfoxpro">cSource := "Hello World"
cDestination := cSource</syntaxhighlight>
=={{header|Haskell}}==
Line 1,072 ⟶ 1,346:
=={{header|HicEst}}==
<
dst = src</
=={{header|i}}==
<
software {
a = "Hello World"
Line 1,086 ⟶ 1,360:
print(b)
}
</syntaxhighlight>
=={{header|Icon}} and {{header|Unicon}}==
Strings in Icon are immutable.
<
a := "qwerty"
b := a
b[2+:4] := "uarterl"
write(a," -> ",b)
end</
Under the covers 'b' is created as a reference to the same string as 'a';
Line 1,107 ⟶ 1,381:
=={{header|J}}==
<
dest =: src</
J has copy-on-write semantics.
Line 1,115 ⟶ 1,389:
=={{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);
Line 1,121 ⟶ 1,395:
//"newAlias == src" is true
//"strCopy == src" is false
//"strCopy.equals(src)" is true</
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
containerCopy.myString = "Goodbye"; // container.myString will also return "Goodbye"</
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
b = "Goodbye" // b contains a copy of a's value and a will still return "Hello"</
=={{header|Joy}}==
<
Strings are immutable.
Line 1,148 ⟶ 1,422:
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.
jq does however have a type of variable, though their values actually don't change -- they are just context-dependent. For example, consider the sequence of steps in the following function:<
"abc" as $s # assignment of a string to a variable
| $s as $t # $t points to the same string as $s
Line 1,156 ⟶ 1,430:
demo
</syntaxhighlight>
{{Out}}
"abc"
Line 1,162 ⟶ 1,436:
=={{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.
<syntaxhighlight lang="julia">
s = "Rosetta Code"
t = s
Line 1,171 ⟶ 1,445:
println("s = \"", s, "\" and, after this change, t = \"", t, "\"")
</syntaxhighlight>
{{out}}
Line 1,180 ⟶ 1,454:
=={{header|KonsolScript}}==
<
Var:String str2 = str1;</
=={{header|Kotlin}}==
<
val alias = s // alias === s
val copy = "" + s // copy !== 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|Lambdatalk}}==
<syntaxhighlight lang="scheme">
{def S1 hello world} // set S1 to "hello world"
-> S1
{S1} // get the value of S1
-> hello world
{def S2 S1} // define S2 as S1
-> S2
{S2} // the value of S2 is S1
-> S1
{{S2}} // get the value of the value of S2
-> hello world
{def S3 {S1}} // set S3 to the value of S1
-> S3
{S3} // get the value of S3
-> hello world
</syntaxhighlight>
=={{header|Lang5}}==
<syntaxhighlight lang
=={{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)
Line 1,215 ⟶ 1,509:
#x //I saw one too
'\r'
#y //it was grey.</
=={{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.
Line 1,225 ⟶ 1,519:
println: a == c. ; True
println: a === b. ; True
println: a === c. ; False</
=={{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
Line 1,250 ⟶ 1,544:
COPY .BLKW 128
.END</
{{out}}
<pre>What, has this thing appeared again tonight?</pre>
Line 1,256 ⟶ 1,550:
=={{header|LFE}}==
<
(b a))
(: io format '"Contents of 'b': ~s~n" (list b)))</
{{out}}
Line 1,267 ⟶ 1,561:
One can also use <code>set</code> to copy a sting when one is in the LFE REPL:
<
"data"
> a
Line 1,274 ⟶ 1,568:
"data"
> b
"data"</
=={{header|Liberty BASIC}}==
<
dest$ = src$
print src$
print dest$
</syntaxhighlight>
=={{header|Lingo}}==
<
str2 = str</
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
-- "XHellX world!X"</
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;
Line 1,306 ⟶ 1,600:
svar.append "!\n";
svar.print;</
STRING_CONSTANT is immutable, STRING is not.
=={{header|Little}}==
<
string b = a;
a =~ s/$/\./;
puts(a);
puts(b);</
=={{header|LiveCode}}==
<
put bar into baz
answer bar && 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.
Line 1,325 ⟶ 1,619:
=={{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
Line 1,334 ⟶ 1,628:
make "c word :b "|| ; force a copy of the contents of a word by appending the empty word
print equal? :b :c ; true
print .eq :b :c ; false</
=={{header|Lua}}==
Lua strings are immutable, so only one reference to each string exists.
<
a = "string"
b = a
print(a == b) -->true
print(b) -->string</
=={{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.
<syntaxhighlight lang="maple">
> s := "some string";
s := "some string"
Line 1,360 ⟶ 1,654:
> u := t: # copy reference
</syntaxhighlight>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
b=a</
=={{header|MATLAB}}==
<
string2 = string1;</
=={{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,
Line 1,389 ⟶ 1,683:
c;
"losers"</
=={{header|MAXScript}}==
<
str2 = copy str1</
=={{header|Metafont}}==
Line 1,399 ⟶ 1,693:
Metafont will always copy a string (does not make references).
<
s := "hello";
a := s;
Line 1,405 ⟶ 1,699:
message s; % writes "hello world"
message a; % writes "hello"
end</
=={{header|MiniScript}}==
<
copy = phrase
print phrase
print copy</
=={{header|MIPS Assembly}}==
This does a full copy of the string, not just copying the pointer to the string's contents.
<
.text
Line 1,437 ⟶ 1,731:
addi $sp, $sp, 4
jr $ra
</syntaxhighlight>
=={{header|Mirah}}==
<
new_alias = src
Line 1,448 ⟶ 1,742:
puts 'non-interned strings are not equal' if str_copy != src
puts 'compare strings with equals()' if str_copy.equals(src)
</syntaxhighlight>
=={{header|Modula-3}}==
Strings in Modula-3 have the type <code>TEXT</code>.
<
VAR dst: TEXT := src;</
=={{header|MUMPS}}==
<syntaxhighlight lang="text">SET S1="Greetings, Planet"
SET S2=S1</
=={{header|Nanoquery}}==
<
b = a</
=={{header|Neko}}==
<
var dst = src</
=={{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;
Line 1,486 ⟶ 1,780:
// 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
Line 1,499 ⟶ 1,793:
say s1
say s2</
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>.
Line 1,509 ⟶ 1,803:
=={{header|NewLISP}}==
<
(setq s "Greetings!" c (copy s))
Line 1,528 ⟶ 1,822:
true
</syntaxhighlight>
=={{header|Nim}}==
<
c = "This is a string"
d = c # Copy c into a new string</
=={{header|NS-HUBASIC}}==
<
20 B$ = A$
30 A$ = "HI"
40 PRINT A$, B$</
=={{header|Oberon-2}}==
<
TYPE
String = ARRAY 128 OF CHAR;
Line 1,551 ⟶ 1,845:
a := "plain string";
COPY(a,b);
END CopyString.</
=={{header|Objeck}}==
<
b := a;</
=={{header|Objective-C}}==
Line 1,562 ⟶ 1,856:
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];
NSString *newMutable = [original mutableCopy];</
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];
NSMutableString *mutable = [original mutableCopy];</
Copying a CString into an NSString:
<
NSString *string = [NSString stringWithUTF8String:cstring];</
Copying from data, possibly not null terminated:
<
NSString *string = [[NSString alloc] initWithBytes:bytes length:9 encoding:NSASCIIStringEncoding];</
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)
(* fails to compile with -safe-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/>
Line 1,607 ⟶ 1,901:
=={{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|Ol}}==
<syntaxhighlight lang="scheme">
(define a "The String.")
; copy the string
(define b (runes->string (string->runes a)))
(print "a: " a)
(print "b: " b)
(print "b is an a: " (eq? a b))
(print "b same as a: " (equal? a b))
; another way: marshal the string
(define c (fasl-decode (fasl-encode a) #f))
(print "a: " a)
(print "c: " c)
(print "c is an a: " (eq? a c))
(print "c same as a: " (equal? a c))
</syntaxhighlight>
{{Out}}
<pre>
a: The String.
b: The String.
b is an a: #false
b same as a: #true
a: The String.
c: The String.
c is an a: #false
c same as a: #true
</pre>
=={{header|ooRexx}}==
<
* 16.05.2013 Walter Pachl
**********************************************************************/
Line 1,634 ⟶ 1,958:
Say 's2='s2
i1=s1~identityhash; Say 's1~identityhash='i1
i2=s2~identityhash; Say 's2~identityhash='i2</
{{out}}
<pre>s1=This is a Rexx string
Line 1,646 ⟶ 1,970:
=={{header|OxygenBasic}}==
<
string s, t="hello"
s=t
</syntaxhighlight>
=={{header|PARI/GP}}==
Assignment in GP always copies.
<
In PARI, strings can be copied and references can be made.
<
GEN string_ref = string;</
=={{header|Pascal}}==
''See also: [[#Delphi|Delphi]]''
<syntaxhighlight lang="pascal" highlight="9,13,15">program copyAString;
var
{ The Extended Pascal `string` schema data type
is essentially a `packed array[1..capacity] of char`. }
source, destination: string(80);
begin
source := 'Hello world!';
{ In Pascal _whole_ array data type values can be copied by assignment. }
destination := source;
{ Provided `source` is a _non-empty_ string value
you can copy in Extended Pascal sub-ranges _of_ _string_ types, too.
Note, the sub-range notation is not permitted for a `bindable` data type. }
destination := source[1..length(source)];
{ You can also employ Extended Pascal’s `writeStr` routine: }
writeStr(destination, source);
end.</syntaxhighlight>
=={{header|PascalABC.NET}}==
Strings in PascalABC.NET are references.
<syntaxhighlight lang="pascal" highlight="9,13,15">
begin
var s: string := 'Hello';
var
end.
</syntaxhighlight>
=={{header|Perl}}==
Line 1,694 ⟶ 2,015:
To copy a string, just use ordinary assignment:
<
my $new = $original;
$new = 'Goodbye.';
print "$original\n"; # prints "Hello."</
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.';
print "$original\n"; # prints "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.';
print "$original\n"; # prints "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.';
print "$original\n"; # prints "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>
Line 1,733 ⟶ 2,054:
<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>
Line 1,742 ⟶ 2,063:
=={{header|PHP}}==
<
$dst = $src;</
=={{header|Picat}}==
Use <code>copy_term/1</code> to ensure that the original string is not changed.
<syntaxhighlight lang="picat">go =>
S1 = "string",
println(s1=S1),
S2 = S1,
S2[1] := 'x', % also changes S1
println(s1=S1),
println(s2=S2),
nl,
S3 = "string",
S4 = copy_term(S3),
S4[1] := 'x', % no change of S3
println(s3=S3),
println(s4=S4),
nl.</syntaxhighlight>
{{out}}
<pre>s1 = string
s1 = xtring
s2 = xtring
s3 = string
s4 = xtring</pre>
=={{header|PicoLisp}}==
<
(setq Str2 Str1) # Create a reference to that symbol
(setq Str3 (name Str1)) # Create new symbol with name "abcdef"</
=={{header|Pike}}==
<
string hi = "Hello World.";
string ih = hi;
}</
=={{header|PL/I}}==
<
s1 = 'now is the time';
s2 = s1;</
=={{header|Pop11}}==
Line 1,765 ⟶ 2,114:
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;
copy(src) -> dst;</
One can also combine assignment (initialization) with variable declarations:
<
vars dst=copy(src);</
=={{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:
<
$dup = $str</
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:
copy -a- from -b- to -c- </
=={{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.
<
A = B, B = "A test string".</
=={{header|PureBasic}}==
<
dst$ = src$</
=={{header|Python}}==
Line 1,805 ⟶ 2,154:
Since strings are immutable, all copy operations return the same string, with the reference count increased as appropriate
<
>>> a = src
>>> b = src[:]
Line 1,812 ⟶ 2,161:
>>> d = copy.deepcopy(src)
>>> src is a is b is c is d
True</
To actually copy a string:
<
>>> b = ''.join(a)
>>> a == b
True
>>> b is a ### Might be True ... depends on "interning" implementation details!
False</
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.
Line 1,832 ⟶ 2,181:
<br>
Strings are immutable.
<
=={{header|R}}==
Copy a string by value:
<
str2 <- str1</
=={{header|Racket}}==
<syntaxhighlight lang="racket">
#lang racket
Line 1,855 ⟶ 2,204:
(string-fill! s3 #\!)
(printf "~a~a~a~a\n" s1 s2 s3 s4)) ; outputs "HeyHey!!!!!!"
</syntaxhighlight>
=={{header|Raku}}==
Line 1,861 ⟶ 2,210:
There is no special handling needed to copy a string; just assign it to a new variable:
<syntaxhighlight lang="raku"
my $copy = $original;
say $copy; # prints "Hello."
$copy = 'Goodbye.';
say $copy; # prints "Goodbye."
say $original; # prints "Hello."</
You can also bind a new variable to an existing one so that each refers to, and can modify the same string.
<syntaxhighlight lang="raku"
my $bound := $original;
say $bound; # prints "Hello."
$bound = 'Goodbye.';
say $bound; # prints "Goodbye."
say $original; # 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.
<syntaxhighlight lang="raku"
#my $bound-ro ::= $original;
#say $bound-ro; # prints "Hello."
Line 1,889 ⟶ 2,238:
say $bound-ro; # prints "Hello."
$original = 'Goodbye.';
say $bound-ro; # prints "Goodbye."</
-->
Line 1,896 ⟶ 2,245:
Copy a string by reference:
<
a as b</
Copy a string by value:
<
a copy as b</
=={{header|REBOL}}==
<
Title: "String Copy"
URL: http://rosettacode.org/wiki/Copy_a_string
Line 1,925 ⟶ 2,274:
y: copy/part skip x 2 3
print ["Partial copy from offset:" mold x "," mold y]</
{{out}}
Line 1,936 ⟶ 2,285:
=={{header|Red}}==
<syntaxhighlight lang="red">
Red[]
originalString: "hello wordl"
Line 1,942 ⟶ 2,291:
; OR
copiedString2: copy originalString
</syntaxhighlight>
=={{header|Retro}}==
<syntaxhighlight lang
=={{header|REXX}}==
Line 1,956 ⟶ 2,305:
Also note that ''all'' REXX values (variables) are
stored as (varying length) ''character strings''.
<
dst = src</
=={{header|Ring}}==
<
cStr1 = "Hello!" # create original string
cStr2 = cStr1 # make new string from original
</syntaxhighlight>
=={{header|RLaB}}==
<
A string
>> s2 = s1
A string</
=={{header|Robotic}}==
<
set "$string1" to "This is a string"
set "$string2" to "$string1"
* "&$string2&"
</syntaxhighlight>
=={{header|RPL}}==
Copy a string in stack:
DUP
Copy a string from one variable to another:
"Example" 'STR1' STO
STR1 'STR2' STO
=={{header|Ruby}}==
In Ruby, String are mutable.
<
reference = original # copies reference
copy1 = original.dup # instance of original.class
Line 1,988 ⟶ 2,343:
p reference #=> "hello world!"
p copy1 #=> "hello"
p copy2 #=> "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)
Line 1,997 ⟶ 2,352:
p copy1 << " world!" #=> "hello world!"
p copy2.frozen? #=> true
p copy2 << " world!" #=> can't modify frozen String (RuntimeError)</
=={{header|Run BASIC}}==
<
newString$ = origString$ ' make new strig from original</
=={{header|Rust}}==
<
let s1 = "A String";
let mut s2 = s1;
Line 2,011 ⟶ 2,366:
println!("s1 = {}, s2 = {}", s1, s2);
}</
Output: <syntaxhighlight lang="text">s1 = A String, s2 = Another String</
=={{header|Sather}}==
<
main is
s ::= "a string";
Line 2,022 ⟶ 2,377:
-- s1 is a copy
end;
end;</
=={{header|S-BASIC}}==
Creating a copy of a string requires only a simple assignment. The effect of a reference can be obtained by declaring a base-located string and positioning it at run-time on top of the original string, the address of which can be obtained using the LOCATION statement Since they occupy the same memory, any change to the original string will be reflected in the base-located string and vice-versa.
<syntaxhighlight lang = "BASIC">
var original, copy = string
based referenced = string
var strloc = integer
rem - position referenced string on top of original string
location var strloc = original
base referenced at strloc
original = "Hello, World"
copy = original
print "Original : ", original
print "Copy : ", copy
print "Referenced: ", referenced
print
original = "Goodbye, World"
print "Original : ", original rem - changed
print "Copy : ", copy rem - unchanged
print "Referenced: ", referenced rem - changed
end
</syntaxhighlight>
{{out}}
<pre>
Original : Hello, World
Copy : Hello, World
Referenced: Hello, World
Original : Goodbye, World
Copy : Hello, World
Referenced: Goodbye, World
</pre>
=={{header|Scala}}==
<
// Its actually not a copy but a reference
// That is not a problem because String is immutable
Line 2,037 ⟶ 2,430:
assert((src eq cop)) // Still no copyed image
val copy = src.reverse.reverse // Finally double reverse makes a copy
assert(src == copy && !(src eq copy))// Prove, but it really makes no sense.</
=={{header|Scheme}}==
<
=={{header|
In ''sed'', there are two distinct locations for storing a string: The "pattern space" and the "hold space". The <code>h</code> command copies pattern space to hold space. The <code>g</code> command copies hold space to pattern space.
=={{header|Seed7}}==
<syntaxhighlight lang="seed7">var string: dest is "";
dest := "Hello";</
=={{header|SenseTalk}}==
<
put "glorious" into myWord
Line 2,066 ⟶ 2,461:
put "myRef: " & myRef
put "another: " & another
</syntaxhighlight>
{{out}}
<pre>
Line 2,076 ⟶ 2,471:
=={{header|Shiny}}==
<
cpy: src</
=={{header|Sidef}}==
<
var reference = original; # points at the original object
var copy1 = String.new(original); # creates a new String object
var copy2 = original+''; # ==//==</
=={{header|Simula}}==
<
TEXT ORIGINAL, REFERENCE, COPY1;
Line 2,113 ⟶ 2,508:
OUTTEXT(COPY1);
OUTIMAGE;
END;</
{{out}}
<pre>
Line 2,124 ⟶ 2,519:
=={{header|Slate}}==
<
=={{header|Smalltalk}}==
<
"bind the var s1 to the object string on the right"
s1 := 'i am a string'.
Line 2,134 ⟶ 2,529:
s2 := s1.
"bind s2 to a copy of the object bound to s1"
s2 := (s1 copy).</
=={{header|SNOBOL4}}==
<
* copy a to b
b = a = "test"
Line 2,145 ⟶ 2,540:
b "t" = "T"
output = b
end</
{{out}}
Line 2,158 ⟶ 2,553:
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};
src = CharArray.vector srcCopy; (* evaluates to true *)</
or from another <code>CharArray.array</code>:
<
CharArray.copy {src = srcCopy, dst = srcCopy2, di = 0};</
=={{header|Swift}}==
Just use assignment:
<
var dst = src</
Strings in Swift are value types, so assigning copies the string.
=={{header|Tcl}}==
<
set dst $src</
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.
Line 2,181 ⟶ 2,576:
=={{header|TI-83 BASIC}}==
<
:Str1→Str2</
=={{header|TI-89 BASIC}}==
<
:str1→str2</
=={{header|Toka}}==
<
a string.clone is-data b</
=={{header|Transd}}==
<syntaxhighlight lang="scheme">#lang transd
MainModule : {
_start: (λ
(with s "Hello!" s1 "" s2 ""
(= s1 s) // duplication of 's' content
(rebind s2 s) // another reference to 's'
(= s "Good bye!")
(lout s)
(lout s1)
(lout s2)
)
)
}</syntaxhighlight>{{out}}
<pre>
Good bye!
Hello!
Good bye!
</pre>
=={{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"
dst=str</
=={{header|UNIX Shell}}==
<
bar=$foo # This is a copy of the string</
=={{header|Ursa}}==
<
set a "hello"
set b a</
=={{header|V}}==
Line 2,216 ⟶ 2,632:
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
Line 2,226 ⟶ 2,642:
Debug.Print b
Debug.Print a
End Sub</
<pre>Hello World!
I'm gone</pre>
=={{header|Vim Script}}==
<
let str2 = str1
let str1 = "new string"
echo "String 1:" str1
echo "String 2:" str2</
{{Out}}
Line 2,246 ⟶ 2,662:
{{works with|Visual Basic .NET|9.0+}}
<
Dim a = "Test string"
Dim b = a 'reference to same string
Line 2,254 ⟶ 2,670:
Dim x As New Text.StringBuilder("Test string")
Dim y = x 'reference
Dim z = New Text.StringBuilder(x.ToString) 'new string</
Alternatively, you can use, with all versions of the .NET framework:
<
Dim b As String = String.Copy(a) ' New string</
=={{header|V (Vlang)}}==
Strings in Vlang are immutable. There is no need to distinguish between copying and making an additional reference.
<syntaxhighlight lang="Vlang">
text := "Hello"
copy_of := text
println(copy_of)
</syntaxhighlight>
{{out}}
<pre>
Hello
</pre>
=={{header|Wren}}==
Line 2,264 ⟶ 2,693:
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
System.print("Are 's' and 't' equal? %(s == t)")</
{{out}}
Line 2,276 ⟶ 2,705:
{{works with|nasm}}
creating a second 0 terminated string with the same content:
<
section .data
string db "Hello World", 0
Line 2,297 ⟶ 2,726:
xor eax, eax
ret
</syntaxhighlight>
creating a second string; first byte signals length of string
<
section .data
string db 11,"Hello World"
Line 2,323 ⟶ 2,752:
xor eax, eax
ret
</syntaxhighlight>
=={{header|X86-64 Assembly}}==
===UASM 2.52===
<
option casemap:none
option literals:on
Line 2,370 ⟶ 2,799:
end
</syntaxhighlight>
{{out}}
<pre>
Line 2,377 ⟶ 2,806:
-> dp (0x4030a4) = Goodbye, World!
-> bytes copied: 15
</pre>
===NASM 2.15===
<syntaxhighlight lang="asm">
%macro sysdef 2
%define sys_%1 %2
%endmacro
sysdef write, 1
%macro prolog 1
push rbp
mov rbp, rsp
sub rsp, %1
%endmacro
%macro epilog 1
add rsp, %1
pop rbp
%endmacro
%macro xlea 2
lea %1, [rel %2]
%endmacro
%macro inv 1-7 0,0,0,0,0,0
mov r9,%7
mov r8,%6
mov r10,%5
mov rdx,%4
mov rsi,%3
mov rdi,%2
mov rax,sys_%1
syscall
%endmacro
section .rodata
sz1 db "Goodbye, World!",0xa,0
section .bss
sz2 resq 1
section .text
strlcpy:
prolog 0x38
%define dest rbp-0x18
%define src rbp-0x10
%define n rbp-0x8
mov qword [rbp-0x28], rdi
mov qword [rbp-0x30], rsi
mov qword [rbp-0x38], rdx
mov rax, qword [rbp-0x28]
mov qword [dest], rax
mov rax, qword [rbp-0x30]
mov qword [src], rax
mov rax, qword [rbp-0x38]
mov qword [n], rax
cmp qword [n], 0
je _stlc_done
_stlc_doloop:
dec qword [n]
cmp qword [n], 0
je _stlc_done
mov rbx, qword [src]
lea rax, [rbx+1]
mov qword [src], rax
mov rax, qword [dest]
lea rcx, [rax+1]
mov qword [dest], rcx
movzx ebx, byte [rbx]
mov byte [rax], bl
movzx eax, byte [rax]
test al, al
je _stlc_done
jmp _stlc_doloop
_stlc_done:
epilog 0x38
ret
strlen:
prolog 0x10
%define s rbp-0x8
mov qword [rbp-0x10], rdi
mov rax, qword [rbp-0x10]
mov qword [s], rax
mov rsi, qword [s]
xor rcx, rcx
_stl_count:
cmp byte [rsi+rcx], 0
je _stl_exit
inc rcx
jne _stl_count
_stl_exit:
mov rax, rcx
epilog 0x10
ret
global main
main:
prolog 0x20
%define tmp rbp-0x20
xlea rbx, sz1
mov qword [tmp], rbx
mov rdi, qword [tmp]
call strlen
mov rcx, rax
push rcx
mov rdx, rcx
xlea rsi, sz1
xlea rdi, sz2
call strlcpy
xlea rbx, sz2
pop rcx
inv write, 1, rbx, rcx
inv exit, 0
epilog 0x20
ret
</syntaxhighlight>
{{out}}
<pre>
Goodbye, World!
</pre>
Line 2,385 ⟶ 2,936:
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
Line 2,397 ⟶ 2,948:
S2:= S1; \S2 now also points to the string
StrCopy(S1, S3); \S3 points to a separate copy of the string
]</
=={{header|Z80 Assembly}}==
===Making An Additional Reference===
Making an additional reference to a string is easy. If you know the address of the beginning of the string, store that address in RAM somewhere else.
<syntaxhighlight lang="z80">ld hl,MyString
ld (PointerVariable),hl
MyString: ;assembler equates this label to a memory location at compile time
byte "Hello",0
PointerVariable:
word 0 ;placeholder for the address of the above string, gets written to by the code above.</syntaxhighlight>
'''NOTE:''' If you're programming for the Game Boy, you can't store a 16-bit value directly into RAM from <code>HL</code>. There are other methods to achieve the same result, and here's one:
<syntaxhighlight lang="z80">ld a,<MyString ; < represents the low byte of the address. Some assemblers use LOW() with the label in the parentheses.
ld (PointerVariable),a
ld a,>MyString ; > represents the high byte of the address. Some assemblers use HIGH() with the label in the parentheses.
ld (PointerVariable+1),a</syntaxhighlight>
===Copying A String===
As long as you have enough RAM space to hold the entire string, you can copy it somewhere else in memory. If you know the string's length in advance a simple <code>LDIR</code> will be sufficient. This method will use the null terminator to tell the copy function when to stop:
<syntaxhighlight lang="z80">StrCpy:
;input: HL = base address of string you wish to copy
; DE = where you want to copy it to.
; This program assumes that the string is null-terminated, and that there is enough RAM to hold the entire string.
ld a,(hl)
or a ;compare A to 0.
ret z
ld (de),a
inc hl
inc de
jr StrCpy</syntaxhighlight>
If you're using the "Pascal style" where the string length is prepended before the string itself, you can use this method instead, assuming your string is shorter than 255 bytes in length.
<syntaxhighlight lang="z80">ld hl,myString
ld c,(hl)
ld b,0
inc c
ld de,buffer
ldir ;copies from (HL) to (DE), BC times.
ret
myString:
byte 5 ;len("Hello")
byte "Hello"
buffer:
byte 0
byte 0,0,0,0,0</syntaxhighlight>
=={{header|Zig}}==
<
const debug = std.debug;
Line 2,421 ⟶ 3,024:
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
Line 2,440 ⟶ 3,043:
copy(c,r);writeln(r);
end Main.
</syntaxhighlight>
=={{header|Zoomscript}}==
For typing:
<syntaxhighlight lang="zoomscript">var a
var b
a = "World"
b = a
a = "Hello"
print (a," ",b)</
For importing:
Line 2,456 ⟶ 3,059:
=={{header|ZX Spectrum Basic}}==
<
20 LET b$ = a$: REM b$ is the copy</
=={{header|Amazing Hopper}}==
Version 1:
Assign variable "s" to variable "b".
<syntaxhighlight lang="hopper">
#include <hopper.h>
main:
s = "string to copy"
t = s
{s,"\n",t}println
exit(0)
</syntaxhighlight>
Output:
string to copy
string to copy
Version 2:
Soft copy to variable (CPY).
<syntaxhighlight lang="hopper">
#include <hopper.h>
main:
s=""
{"1:","string to copy"},cpy(s),println
{"2:",s}println
exit(0)
</syntaxhighlight>
Output:
1:string to copy
2:string to copy
Version 3:
From stack to var: hard copy (move, MOV).
<syntaxhighlight lang="hopper">
#include <hopper.h>
main:
s=""
{"string to copy"},mov(s)
{s}println
exit(0)
</syntaxhighlight>
Output:
string to copy
|