Ruby's a = b vs PHP5's $obj1 =& $obj2

[SpringFlowers AutumnMoon]

Just want to confirm Ruby's

a = b

is the same as PHP5's

$obj1 = $obj2

in other words, the reference is copied.

While

$obj1 =& $obj2

or

$obj1 = &$obj2

in both PHP4 and PHP5 isn't the same as Ruby's a = b

$obj1 and $obj2 just become synonyms...

and after

$obj1 = new Foo("foo1");
$obj2 =& $obj1
$obj2 = new Foo("bar1");

$obj1 and $obj2 have the same content, as they are just synonyms. (not a
clone, not same reference, but just synonyms). The "foo1" object is
garbage-collected since no one is referencing it.

this is giving me an initial headache... until maybe after i get used to
it.

 

[Jano Svitok]

Just want to confirm Ruby's

a = b

is the same as PHP5's

$obj1 = $obj2

in other words, the reference is copied.

While

$obj1 =& $obj2

or

$obj1 = &$obj2

in both PHP4 and PHP5 isn't the same as Ruby's a = b

$obj1 and $obj2 just become synonyms...

and after

$obj1 = new Foo("foo1");
$obj2 =& $obj1
$obj2 = new Foo("bar1");

$obj1 and $obj2 have the same content, as they are just synonyms. (not a
clone, not same reference, but just synonyms). The "foo1" object is
garbage-collected since no one is referencing it.

this is giving me an initial headache... until maybe after i get used to
it.

in ruby:

a = Hash.new # a is a reference to Hash object #1
b = a # both a and b point to the same object
a[1] = 'a' # and b[1] is 'a' as well

but

b = Hash.new # now a points to Hash obj #1 and b to #2
b[1] = 'c' # a[1] is still 'a'

i.e. assignment may destroy the link.

 

[Jonas Roberto de Goes Filho (sysdebug)]

--------------enigC3D91DCD06D6154B3B37054D
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: quoted-printable

Just want to confirm Ruby's
=20
a =3D b
=20
is the same as PHP5's
=20
$obj1 =3D $obj2
=20
in other words, the reference is copied.
=20
While
=20
$obj1 =3D& $obj2
=20
or
=20
$obj1 =3D &$obj2
=20
in both PHP4 and PHP5 isn't the same as Ruby's a =3D b
=20
$obj1 and $obj2 just become synonyms...
=20
and after
=20
$obj1 =3D new Foo("foo1");
$obj2 =3D& $obj1
$obj2 =3D new Foo("bar1");
=20
$obj1 and $obj2 have the same content, as they are just synonyms. (not = a
clone, not same reference, but just synonyms). The "foo1" object is
garbage-collected since no one is referencing it.
=20
this is giving me an initial headache... until maybe after i get used t= o
it.

Hello,

In PHP, $obj1 =3D & $obj2 means that both $obj1 and $obj2 points to the=20
same content. Its like hardlinks in Unix.

In Ruby, depends of type of variable. If type of variable as object, its =

work like as PHP. If type of variable as a number, its not work as PHP.

See an example:

sysdebug(main):014:0> class A
sysdebug(main):015:1> def setName(name)
sysdebug(main):016:2> @name =3D name
sysdebug(main):017:2> end
sysdebug(main):018:1> def putsName
sysdebug(main):019:2> puts @name
sysdebug(main):020:2> end
sysdebug(main):021:1> end
=3D> nil
sysdebug(main):022:0>
sysdebug(main):023:0*
sysdebug(main):024:0* a =3D A.new
A
=3D> #<A:0xb7cce1f8>
sysdebug(main):025:0> b =3D a
=3D> #<A:0xb7cce1f8>
sysdebug(main):026:0> a.setName('Jonas')
=3D> "Jonas"
sysdebug(main):027:0> a.putsName
Jonas
=3D> nil
sysdebug(main):028:0> b.putsName
Jonas
=3D> nil
sysdebug(main):029:0> b.setName('Ana')
=3D> "Ana"
sysdebug(main):030:0> a.putsName
Ana
=3D> nil


But in number types:


sysdebug(main):031:0> num1 =3D 1
=3D> 1
sysdebug(main):032:0> num2 =3D num1
=3D> 1
sysdebug(main):033:0> num2
=3D> 1
sysdebug(main):034:0> num1 =3D 2
=3D> 2
sysdebug(main):035:0> num2
=3D> 1
sysdebug(main):036:0>


Regards,

--=20
Jonas Roberto de Goes Filho (sysdebug)
http://goes.eti.br


--------------enigC3D91DCD06D6154B3B37054D
Content-Type: application/pgp-signature; name="signature.asc"
Content-Description: OpenPGP digital signature
Content-Disposition: attachment; filename="signature.asc"

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.6 (GNU/Linux)

iD8DBQFG+79eaGIZR44LEAkRAgF+AJ4vgwezNHlFj/mmhuJ0Fuv+MNazhwCfRqDI
slFm7YEd+BdF9ALfKsrPgxg=
=xyAM
-----END PGP SIGNATURE-----

--------------enigC3D91DCD06D6154B3B37054D--

 

[Konrad Meyer]

--nextPart1554348.S3NVju4d6m
Content-Type: text/plain;
charset="utf-8"
Content-Transfer-Encoding: quoted-printable
Content-Disposition: inline

Quoth SpringFlowers AutumnMoon:

Just want to confirm Ruby's
=20
a =3D b
=20
is the same as PHP5's
=20
$obj1 =3D $obj2
=20
in other words, the reference is copied.
=20
While
=20
$obj1 =3D& $obj2
=20
or
=20
$obj1 =3D &$obj2
=20
in both PHP4 and PHP5 isn't the same as Ruby's a =3D b
=20
$obj1 and $obj2 just become synonyms...
=20
and after
=20
$obj1 =3D new Foo("foo1");
$obj2 =3D& $obj1
$obj2 =3D new Foo("bar1");
=20
$obj1 and $obj2 have the same content, as they are just synonyms. (not a
clone, not same reference, but just synonyms). The "foo1" object is
garbage-collected since no one is referencing it.
=20
this is giving me an initial headache... until maybe after i get used to
it.

PHP's $var1 =3D& $var2 seems to be setting a reference to a reference. I th=
ink=20
ruby is more like PHP's $var1 =3D $var2, though I could be wrong.

HTH,
=2D-=20
Konrad Meyer <[email protected]> http://konrad.sobertillnoon.com/

--nextPart1554348.S3NVju4d6m
Content-Type: application/pgp-signature; name=signature.asc
Content-Description: This is a digitally signed message part.

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.7 (GNU/Linux)

iD8DBQBG+/FgCHB0oCiR2cwRAq+TAKCfCgO6r9RCW8mhXnMuHq+hkq2/wgCbB0mv
1uIfnf/jIJ0DABJLzfQ1SMc=
=R+n0
-----END PGP SIGNATURE-----

--nextPart1554348.S3NVju4d6m--

 

[Gary Wright]

PHP, $obj1 = & $obj2 means that both $obj1 and $obj2 points to the
same content. Its like hardlinks in Unix.

In Ruby, depends of type of variable. If type of variable as
object, its work like as PHP. If type of variable as a number, its
not work as PHP.

There is no need to think of 'numbers' as a special case in Ruby.
And I don't think your example even illustrates that they are
different.

sysdebug(main):031:0> num1 = 1 # num1 references the object
'1'
=> 1
sysdebug(main):032:0> num2 = num1 # num2 references the object
'1'
=> 1
sysdebug(main):033:0> num2
=> 1
sysdebug(main):034:0> num1 = 2 # change num1 to reference
the object '2'
=> 2
sysdebug(main):035:0> num2 # num2 still references the
object '1'
=> 1
sysdebug(main):036:0>

The trick is to think of integer literals not as values but as
references to objects. 1 is not the "value" 1 but is a reference
to the Fixnum object that behaves like the number 1 and there is
only a single Fixnum object that behaves that way (i.e. Fixnum objects
are *not* containers for integer values).

Note: Not everyone thinks of Ruby integer's in this way but IMHO
it makes Ruby's assignment semantics very simple and regular.

Gary Wright

 

[Ian Whitlock]

In PHP, $obj1 = & $obj2 means that both $obj1 and $obj2 points to the
same content. Its like hardlinks in Unix.

In Ruby, depends of type of variable. If type of variable as object, its
work like as PHP. If type of variable as a number, its not work as PHP.

The first pargraph may or may not be correct. I do not know, since I
know nothing about PHP and little about UNIX.

In Ruby, depends of type of variable. If type of variable as object,
its
work like as PHP. If type of variable as a number, its not work as
PHP.

The second cannot be correct. Variables in Ruby do not have a type,
they reference objects. Moreover, when b is a variable

a = b

always means the same thing, and that does not depend on the type
of object referenced by b!

The line (a = b) means that the variables, a and b, reference the same
object UNTIL either reference is changed. Changing the reference to
one will mean they no longer refer to the same object. Changing some
reference within the object will not change what either variable
refers to, BUT the common object referred to is modified. This is
true for all types of objects in Ruby.

In Jonas' example, the difference is that the object created by

a = A.new

is capable of having a name and the line

a.setName('Jonas')

creates a reference to a string within that object. Since a and b
still refer to the same object either one can change the reference,
@name, i.e. they can change the name and then both a and b will know
about that change. Once either a or b refers to a different object
the link or common reference for a and b is broken!

The Fixnum class is different from the A class in that the only way to
change the value of a Fixnum object is to create a new object and
hence a new reference; while in A changing the name does not create a
new object, it modifies the object already created.

I think the basic problem is that in many languages variables refer to
a particular place in memory with a given structure. Ruby on the
other hand makes a variable refer to an object not a place in memory.
Anyone coming from the first type of language to Ruby has a big
adjustment to make in handling the language. (I know I did when I
first looked at Python.) Often it doesn't seem to matter, but that
just makes the adjustment harder because the difference is less
visible.

Ian Whitlock

 

[7stud --]

In PHP, $obj1 = & $obj2 means that both $obj1 and $obj2 points to the
same content. Its like hardlinks in Unix.

That is from C++. Those are "reference" semantics. It causes two names
to refer to the same spot in memory where a value is stored. Either
name can be used to change the value at that spot in memory, and since
both names always refer to that same spot in memory, either name can be
used to retrieve the new value there.

In Ruby, depends of type of variable. If type of variable as object, its
work like as PHP. If type of variable as a number, its not work as PHP.

See an example:

sysdebug(main):014:0> class A
sysdebug(main):015:1> def setName(name)
sysdebug(main):016:2> @name = name
sysdebug(main):017:2> end
sysdebug(main):018:1> def putsName
sysdebug(main):019:2> puts @name
sysdebug(main):020:2> end
sysdebug(main):021:1> end
=> nil
sysdebug(main):022:0>
sysdebug(main):023:0*
sysdebug(main):024:0* a = A.new
A
=> #<A:0xb7cce1f8>
sysdebug(main):025:0> b = a
=> #<A:0xb7cce1f8>
sysdebug(main):026:0> a.setName('Jonas')
=> "Jonas"
sysdebug(main):027:0> a.putsName
Jonas
=> nil
sysdebug(main):028:0> b.putsName
Jonas
=> nil
sysdebug(main):029:0> b.setName('Ana')
=> "Ana"
sysdebug(main):030:0> a.putsName
Ana
=> nil


But in number types:


sysdebug(main):031:0> num1 = 1
=> 1
sysdebug(main):032:0> num2 = num1
=> 1
sysdebug(main):033:0> num2
=> 1

The difference is this next step:

sysdebug(main):034:0> num1 = 2
=> 2
sysdebug(main):035:0> num2
=> 1
sysdebug(main):036:0>

You used assignment in that step. In other words, you reassigned to
num1. In your previous example you never used assignment to reassign
anything to a; instead you changed the object that a referred to.