Rosetta Code

Copy a string: Difference between revisions

← Older edit
Content deleted Content added
Chkas (talk | contribs)
2,195 edits
KayproKid (talk | contribs)
28 edits
Added S-BASIC example
 
(13 intermediate revisions by 7 users not shown)
Line 575:
src$ = " world..."
PRINT dst$; src$</syntaxhighlight>
 
==={{header|SmallBASIC}}===
<syntaxhighlight lang="qbasic">
src = "Hello"
dst = src
src = " world..."
PRINT dst; src
</syntaxhighlight>
 
 
==={{header|True BASIC}}===
Line 636 ⟶ 645:
?(^same$+5) = ?(^source$+5)
PRINT same$</syntaxhighlight>
 
=={{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}}==
Line 995 ⟶ 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>
 
Line 1,963 ⟶ 1,984:
 
=={{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}}==
<syntaxhighlight lang="pascal">program in,out;
Strings in PascalABC.NET are references.
 
<syntaxhighlight lang="pascal" highlight="9,13,15">
type
pString = ^string;
 
var
 
s1,s2 : string ;
pStr : pString ;
 
begin
var s: string := 'Hello';
 
var /*s1 direct:= copy */s;
end.
s1 := 'Now is the time for all good men to come to the aid of their party.'
</syntaxhighlight>
s2 := s1 ;
 
writeln(s1);
writeln(s2);
 
/* By Reference */
pStr := @s1 ;
writeln(pStr^);
 
pStr := @s2 ;
writeln(pStr^);
 
end;</syntaxhighlight>
 
=={{header|Perl}}==
Line 2,360 ⟶ 2,378:
end;
end;</syntaxhighlight>
 
=={{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}}==
Line 2,637 ⟶ 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.
<syntaxhighlight lang="ecmascriptwren">var s = "wren"
var t = s
System.print("Are 's' and 't' equal? %(s == t)")</syntaxhighlight>
Retrieved from "https://rosettacode.org/wiki/Copy_a_string"