Naming problem on array object

[Cylix]

I have a array to store some student information, eg
var s = new Array('2006001' , 'Apple Joker', '5B');

normally, We get the data using s[0], s[1],s[2] ...
How can I define them more readable like
s['studentID'], s['studentName'], s['class'] ?

Thank you

[Erwin Moller]

Cylix wrote:

I have a array to store some student information, eg
var s = new Array('2006001' , 'Apple Joker', '5B');

normally, We get the data using s[0], s[1],s[2] ...
How can I define them more readable like
s['studentID'], s['studentName'], s['class'] ?

Make an Object of it instead of an array.
Objects behave like / are hashes.
eg:

var myClass = new Object();
myClass["studentID"] = 123;
myClass["studentNam e"] = "Cyclix";
etc.

Regards,
Erwin Moller

>
Thank you

[Cylix]

>Erwin Moller wrote:

var myClass = new Object();
myClass["studentID"] = 123;
myClass["studentNam e"] = "Cyclix";

Thank you for your suggestion first,
Under this way,
Can I still using myClass[0], myClass[1] to get the value?

[RobG]

Cylix wrote:

>Erwin Moller wrote:

>var myClass = new Object();
myClass["studentID"] = 123;
myClass["studentNam e"] = "Cyclix";

Thank you for your suggestion first,
Under this way,
Can I still using myClass[0], myClass[1] to get the value?

No.

Object properties can only have one name, which is a string. You can
call them '0', '1', '2', etc. but then you might as well use an Array.

You should probably check the FAQ on how to access properties using
square brackets and dot notation:

<URL:http://www.jibbering.c om/faq/#FAQ4_39>
--
Rob

[Laurent Bugnion]

Hi,

RobG wrote:

Cylix wrote:

>>Erwin Moller wrote:

>>var myClass = new Object();
myClass["studentID"] = 123;
myClass["studentNam e"] = "Cyclix";

Thank you for your suggestion first,
Under this way,
Can I still using myClass[0], myClass[1] to get the value?

No.

Object properties can only have one name, which is a string. You can
call them '0', '1', '2', etc. but then you might as well use an Array.

You should probably check the FAQ on how to access properties using
square brackets and dot notation:

<URL:http://www.jibbering.c om/faq/#FAQ4_39>

If you have to, you could do this:

var myArray = new Array();
myArray[ 0 ] = myArray[ "myLabel1" ] = anObject;

This way the property is referenced by index and by label. However, I
would avoid that if I were you, it introduces some level of confusion as
to what the container really does.

Not even mentioning that you must always remember to delete both
references, or else the referenced object won't be garbage collected.

HTH,
Laurent
--
Laurent Bugnion, GalaSoft
Software engineering: http://www.galasoft-LB.ch
Private/Malaysia: http://mypage.bluewin.ch/lbugnion
Support children in Calcutta: http://www.calcutta-espoir.ch

[RobG]

Laurent Bugnion wrote:

Hi,

RobG wrote:

>Cylix wrote:

[...]

>>Can I still using myClass[0], myClass[1] to get the value?

>No.

[...]

If you have to, you could do this:

var myArray = new Array();
myArray[ 0 ] = myArray[ "myLabel1" ] = anObject;

This way the property is referenced by index and by label. However, I
would avoid that if I were you, it introduces some level of confusion as
to what the container really does.

Not even mentioning that you must always remember to delete both
references, or else the referenced object won't be garbage collected.

Not at all - JavaScript isn't C++ :-)

Are you aware of any browser that won't run garbage collection once a UA
navigates away from a page[1]? If it's necessary at all, then:

myArray = null;

should to the trick, provided myArray was the only reference to the
object until recently referenced by myArray and other variables don't
hold any references to whatever it formerly referenced.

1. Other than the IE memory leak noted in the FAQ, which only occurs in
a specific circumstance that shouldn't be an issue here.

--
Rob

[Laurent Bugnion]

Hi,

RobG wrote:

Laurent Bugnion wrote:

>Hi,

RobG wrote:

>>Cylix wrote:

[...]

>>>Can I still using myClass[0], myClass[1] to get the value?

>>No.

[...]

>If you have to, you could do this:

var myArray = new Array();
myArray[ 0 ] = myArray[ "myLabel1" ] = anObject;

This way the property is referenced by index and by label. However, I
would avoid that if I were you, it introduces some level of confusion
as to what the container really does.

Not even mentioning that you must always remember to delete both
references, or else the referenced object won't be garbage collected.

Not at all - JavaScript isn't C++ :-)

Are you aware of any browser that won't run garbage collection once a UA
navigates away from a page[1]? If it's necessary at all, then:

myArray = null;

should to the trick, provided myArray was the only reference to the
object until recently referenced by myArray and other variables don't
hold any references to whatever it formerly referenced.

1. Other than the IE memory leak noted in the FAQ, which only occurs in
a specific circumstance that shouldn't be an issue here.

In the last web application I worked on (a building automation
management station), we have situations where a page isn't posted back
for 2 weeks at least, all the values on the page being refreshed every
30 seconds using AJAX. So believe me, memory is critical in such
situation. The whole "The page is going to be refreshed anyway" attitude
was valid 3 to 5 years ago, it's not anymore!

JavaScript is not C++... it's much more flexible and it's much easier to
make mistakes and to create huge memory leaks, believe me (been there
done that). It's even more important in JavaScript than in C++ (or at
least than in C#) to program cleanly and to avoid confusing scenarios.
The one where an array contains both indexed values and properties seems
confusing enough to me to recommend against it.

HTH,
Laurent
--
Laurent Bugnion, GalaSoft
Software engineering: http://www.galasoft-LB.ch
Private/Malaysia: http://mypage.bluewin.ch/lbugnion
Support children in Calcutta: http://www.calcutta-espoir.ch

[McKirahan]

"Cylix" <cy*******@gmai l.comwrote in message
news:11******** **************@ m73g2000cwd.goo glegroups.com.. .

I have a array to store some student information, eg
var s = new Array('2006001' , 'Apple Joker', '5B');

normally, We get the data using s[0], s[1],s[2] ...
How can I define them more readable like
s['studentID'], s['studentName'], s['class'] ?

var studentID = 0
var studentName = 1
var class = 2

Thus, s[0] = s[studentID].

Except that "class" is a reserved word.

[RobG]

Laurent Bugnion wrote:

Hi,

RobG wrote:

Laurent Bugnion wrote:

[...]

Not even mentioning that you must always remember to delete both
references, or else the referenced object won't be garbage collected.

Not at all - JavaScript isn't C++ :-)

Are you aware of any browser that won't run garbage collection once a UA
navigates away from a page[1]? If it's necessary at all, then:

myArray = null;

should to the trick, provided myArray was the only reference to the
object until recently referenced by myArray and other variables don't
hold any references to whatever it formerly referenced.

1. Other than the IE memory leak noted in the FAQ, which only occurs in
a specific circumstance that shouldn't be an issue here.

In the last web application I worked on (a building automation
management station), we have situations where a page isn't posted back
for 2 weeks at least, all the values on the page being refreshed every
30 seconds using AJAX. So believe me, memory is critical in such
situation. The whole "The page is going to be refreshed anyway" attitude
was valid 3 to 5 years ago, it's not anymore!

That is something of an extreme case, I'd expect that provided you
aren't constantly creating new objects and variables, it shouldn't be
an issue. I'm currently working on an intranet data entry, reporting
and workflow application with pages that will persist for some time,
hopefully not 2 weeks at a time!

JavaScript is not C++... it's much more flexible and it's much easier to
make mistakes and to create huge memory leaks, believe me (been there
done that). It's even more important in JavaScript than in C++ (or at
least than in C#) to program cleanly and to avoid confusing scenarios.

Which is better/worse is moot, but I take your point that memory
management should always be considered and if necessary, addressed.

Memory leaks in JavaScript *should* only be a product of a faulty
environment. If a script simply keeps adding more and more objects or
variables, it is plain poor coding that will cause problems
(eventually) in any language.

The one where an array contains both indexed values and properties seems
confusing enough to me to recommend against it.

Absolutely. The first question is what is the benefit of the same
object having two properties synchronised to the same value? And is
whatever benefit is gained worth the overhead of managing the object's
properties manually?

I expect that discussion to be specific to a particular circumstance -
such as a page that is updated at 30 second intervals (via AJAX?) and
not refreshed for 2 weeks. :-)
--
Rob

[Cylix]

Actually, I just want to declaire something like the javascript style.
For example, we may reference a frame as
window.frames[0] or window.frames['ABC']

so, does it mean the design of javascript is poor in this case?