Copy a string: Difference between revisions

{{omit from|bc}}

This task is about copying a string.

Where it is relevant, distinguish between copying the contents of a string

versus making an additional reference to an existing string.

 

=={{header|ABAP}}==

lv_string2 type string.

 

=={{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|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|Babel}}==

 

 

 

=={{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|Batch File}}==

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++}}==

#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|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}}

<pre>Goodbye

Goodbye, World!</pre>

 

=={{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|E}}==

but this is not guaranteed.

 

 

 

 

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

If str1 is longer than str2 it is truncated to fit.

 

=={{header|Gambas}}==

 

 

src = "Hello"

 

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

Its internal reference is likely to point to the same underlying array as src,

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

 

=={{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|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|jq}}==

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

| $t # $t still points to "abc"

;

 

demo

{{Out}}

"abc"

 

 

 

=={{header|KonsolScript}}==

 

=={{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|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|Lisaac}}==

+ svar : STRING;

 

svar.append "!\n";

 

STRING_CONSTANT is immutable, STRING is not.

 

=={{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|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|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|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))

(reverse c) ; Modifies c in place.

 

 

c = "This is a string"

 

=={{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}}==

 

=={{header|Octave}}==

 

 

=={{header|ooRexx}}==

* 16.05.2013 Walter Pachl

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

i2=s2~identityhash; Say 's2~identityhash='i2

 

 

Say 's1='s1

Say 's2='s2

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

{{out}}

<pre>s1=This is a Rexx string

s2=This is a Rexx string

s1=This is a Rexx string

 

=={{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|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|Python}}==

{{works with|Python|2.3, 2.4, and 2.5}}

 

>>> 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.

 

Be careful with ''is'' - use it only when you want to compare the identity of the object. To compare string values, use the ''=='' operator. For numbers and strings any given Python interpreter's implementation of "interning" may cause the object identities to coincide. Thus any number of names to identical numbers or strings might become references to the same objects regardless of how those objects were derived (even if the contents were properly "copied" around). The fact that these are immutable objects makes this a reasonable behavior.

 

=={{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|Raven}}==

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}}

Partial copy: "Slackeriffic!" , "Slacker"

Partial copy from offset: "Slackeriffic!" , "ack"</pre>

 

=={{header|Retro}}==

 

=={{header|REXX}}==

 

=={{header|RLaB}}==

A string

>> s2 = s1

 

=={{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.frozen? #=> false

 

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

 

=={{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|Seed7}}==

 

 

 

=={{header|Shiny}}==

 

=={{header|Sidef}}==

var reference = original; # points at the original object

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

 

=={{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|V}}==

so the string is immutable.

 

 

=={{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|XPL0}}==

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|zkl}}==

Strings are immutable so copy is just return the string:

 

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