Copy a string: Difference between revisions

 

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

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

 

STRING src:="Hello", dest;

dest:=src

 

=={{header|AutoHotkey}}==

 

 

=={{header|AWK}}==

 

a = "a string"

b = a

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

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

 

=={{header|BASIC}}==

src$ = "Hello"

dst$ = src$

 

=={{header|Batch File}}==

 

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

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

*

* DANGER! strcpy() can overflow the destination buffer.

* the destination buffer. We know that "Hello" (6 characters

* with the final '\0') easily fits in dst1 (80 characters).

 

return 0;

 

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

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

#include <string.h>

 

return 0;

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

=={{header|Clojure}}==

 

s1 s]

 

=={{header|ColdFusion}}==

 

 

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

 

 

 

 

=={{header|Delphi}}==

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

 

 

{$APPTYPE CONSOLE}

Writeln(s1);

Writeln(s2);

 

<pre>Goodbye

Goodbye, World!</pre>

 

=={{header|DWScript}}==

 

 

=={{header|E}}==

 

 

 

 

 

=={{header|Euphoria}}==

 

 

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

let additionalReference = str

let deepCopy = System.String.Copy( str )

 

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

 

=={{header|Factor}}==

 

 

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

 

 

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"

dst = src

 

=={{header|GAP}}==

a := "more";

b := a;

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

a;

 

=={{header|GML}}==

 

=={{header|Go}}==

Just use assignment:

 

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

 

 

 

=={{header|J}}==

 

 

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

 

=={{header|Joy}}==

 

Strings are immutable.

 

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

 

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

 

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

(reverse c) ; Modifies c in place.

 

 

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

 

 

NSString *new = [original copy];

 

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];

 

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

 

<pre>Script: "String Copy" (16-Dec-2009)

Both variables reference same string: "TXsting." , "TXsting."

Partial copy: "Slackeriffic!" , "Slacker"

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

 

=={{header|Retro}}==

 

=={{header|REXX}}==

 

=={{header|RLaB}}==

A string

>> s2 = s1

 

=={{header|Ruby}}==

copy1 = original.dup # instance of original.class

 

=={{header|Sather}}==

main is

s ::= "a string";

-- s1 is a copy

end;

 

=={{header|Scheme}}==

 

=={{header|Seed7}}==

 

 

 

=={{header|Shiny}}==

 

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

 

test

test

Test

 

=={{header|Standard ML}}==

 

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

 

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

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

 

=={{header|Toka}}==

 

=={{header|Trith}}==

 

=={{header|TUSCRIPT}}==

str="Hello"

 

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

 

 

=={{header|V}}==

 

 

=={{header|Visual Basic .NET}}==

 

{{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|ZX Spectrum Basic}}==