What happens when try to use key of non-Object? Nothing?


If I run the code below after deleting "delete this string" from myArray (in line 1), then everything makes sense to me.

var myArray = [1, true, "yes!", new Object(), "delete this string"];
myArray[3].blah1 = "wtf";
myArray[myArray.length - 1]["oh yeah"] = 37;

But if I run the code above exactly as it is, it seems that line 3 has absolutely no impact. This sort of makes sense to me because "delete this string" is not an object and I'm trying to access "delete this string"."oh yeah" which does not exist (I should use myArray.length - 2 instead). But I'm puzzled that there was no error message, or that it does not implicitly change it to an object.

For instance, when accessing the nth element of an array of size < n, it will just expand the array accordingly. And when accessing the key of an object that was not defined yet, it will add the key to the object. But here it does not automatically replace the string with an object. Nor does it complain.

So... is it just ignoring line 3 completely?



An object has one or more properties, separated by a comma_,

A property has a property-key and it's associated VALUE

The associated VALUE can be anything from:

•Object  ◦Function/'Method'

Above you have an overview of all data-types.

===== Datatype Array =========
What you must understand,
is that if you ( as an example )
create a array
for the Javascript-Interpreter
you have created an object of the prototype array.
and if you do a google search
javascript array site:developer.mozilla.org
and choose
on the left hand side you will see
what information you can gather about the array



Methods ( pre-defined functions for Array operations )


========= looping over an array ===

The most common way to loop over all elements of an Array
is using the generic FOR-loop

for ([initialization]; [condition]; [final-expression]) {

You would
start at index zero,
continue as long as the index is =less than= the array.length,
and at each iteration increment / decrement the index-pointer

var myArray =["a",2,{anObjectKey: "anObjectValue"}];
for ( var index = 0, len = myArray.length; index < len ; index= index + 1 ) {
     // get access to the =element-Value= using the [bracket-notation]
     console.log( index + "==> "+myArray[index] );

== Do NOT use FOR-IN loop on an Array ==

You could look at an Array as it being an Object like

 myArray = {
      0: "a",
      1: 2,
      2: { anObjectKey: "anObjectValue"}

and with the FOR-IN loop

for (var key in myArray) {
     //getting access to the =associate property-Value= 
      //using the =key= in a [bracket-notation]
      console.log( key + "==>"+myArray[key] );

but do a google search
== discussions / opinions ==
javascript why is it a bad idea to use for-in on an Array site:stackoverflow.com
for instance
= http://stackoverflow.com/questions/5269757/why-is-javascripts-for-in-loop-not-recommended-for-arrays
An array is an object,
and array elements are simply properties with the numeric index converted to string.
For example, arr[123] refers to a property "123" in the array object arr.

The for ... in construct
works on all objects, not just arrays,
and that is cause for confusion.

When somebody for ... in an array,
most often the programmer intends to iterate just all the items, even most likely in order.

The semantics is so similar to array iteration in other programming languages that it is very easy to get confused.
In JavaScript, this construct does not iterate array elements in order.
It iterates all

  • the array's properties
  • (including inherited prototype functions, any properties added to it, any other non-element properties added to it etc.),
  • and not in order at all.
  • It will even find the property "length".

This is most likely not what the programmer means, if he/she comes from another programming language.

That's why you shouldn't do it.
You shouldn't use a language construct
that looks like it does obvious things, but actually does things that are completely different.
It creates bugs that are very obscure and very difficult to find.
[end quote Stephen Chung]