Array in javascript

[RobG]

Richard Cornford wrote:

The javascript array has no potential to have multiple
dimensions and so no potential to be 'jagged'. ...

<snip>

As it happens it has just occurred to me that the concept of a
multi-dimensional array can be implemented with a single javascript
Array:-

var a = [];

for(var c = 0;c < 10;++c){
a[c] = a;
}

- The result is a single array that emulates an array with infinite
dimensions. I.E. you can stick as many sets of square brackets and valid
array indexes after the array's Identifier as you want:-

var y = a[0][0][0][0][0][0][0][0][0][0] ... [0][0][0][0][0];

- and still get a valid result from the evaluation of the property
accessor. The resulting object is of course utterly useless as an array,
it will be broken by any attempt to store anything in it, and it is not
(and could not be) 'jagged'. But utterly useless as the result may be it
is one, and the only one, way that a single javascript array can appear
to be multi-dimensional.

I believe such a case is frequently called the 'trivial solution'.

Maybe it should be called the 'Oozle Woozle Array' after the mythical
Oozle Woozle Bird - so long and thanks for the giggle!

 

[Richard Cornford]

A bit too loud to say maybe, but let's us assume it's true


Because VK is up to date the best specialist of *JavaScript
arrays* on the planet (if we decided do go by loud
definitions).

In your page at:-

<http://www.geocities.com/schools_ring/ArrayAndHash.html>

- (under the title "Array and Hash in JavaScript") your wrote:-

| You can use a notation like arrayObject[-1] to address the last
| element in the array, but it's not a negative index: it's just
| a shortcut of arrayObject[arrayObject.length-1]

- That statement is objectively false, and can be seen to be false by
doing no more than trying it. It is not credible to suppose that the
"best specialist of *JavaScript arrays* on the planet" would make (and
be publishing) statements that are so unambiguously false. In reality
your understanding of javascript arrays is poor; a cloud of superficial
perceptions, misconceptions, irrelevant associations and falsehoods.

The main factor standing in the way of your achieving any real
understanding of the subject is your absolute conviction that you alone
are right and everyone else wrong. A belief that is not even undermined
when it is made clear to you that your are (repeatedly) making false
stamens about javascript generally and javascript arrays in particular.
That, combined with your inability to understand and employ logic, is
more suggestive of mental illness than it is of expertise.

btw in the reality it's just the opposite: currently Randy
and Robert are the only known people on the planet denying
that JavaScript array is jagged.

When did the absence of people actively denying something make it true?
It has been a vary long time since anyone bothered to deny that the sun
goes around the earth, that doesn't mean it does.

Is it really necessary for every contributor to the group to line up and
explicitly tell you that your are wrong? In reality their silence in
response to the posts that are disagreeing with your position is a
statement of the general position. Everyone knows that you are wrong,
and is probably finding it difficult to understand why you are incapable
of seeing that.

(I'm not counting few amateurs posted here just for the
hell of nastiness).

So you can post a mixture of lies and nonsense to Usenet but want to
label others 'amateurs'? Remember that over the last month you have
asserted that a method call must be written on a single line of source
code, used a - return null; - statement in a function that could only be
meaningfully used as a constructor and written - void - as the leftmost
token in an expression statement. Your javascript understanding is poor,
and your application of it is amateurish.

Richard.

 

[VK]

In your page at:-

<http://www.geocities.com/schools_ring/ArrayAndHash.html>

- (under the title "Array and Hash in JavaScript") your wrote:-

| You can use a notation like arrayObject[-1] to address the last
| element in the array, but it's not a negative index: it's just
| a shortcut of arrayObject[arrayObject.length-1]

You must be using an outdated copy of my article. The quoted statement
has been made in the version 2.0 ( July 2005 ). It was pointed out by
Lasse Reichstein Nielsen and same day (July 07 2005) corrected. See
details at:
<http://groups.google.com/group/comp...3afa53a28f8/5d5d9f14b0ba09c9#5d5d9f14b0ba09c9>

Indeed "negative index shorcut" is allowed only in array methods (like
slice and splice) but not for addressing elements in the array itself.

Everyone can make a mistake - the task to correct it in a timely
manner.

To make sure that your knowledge about JavaScript arrays is correct,
always use the *official* version of "Array and Hash" article:

<http://www.geocities.com/schools_ring/ArrayAndHash.html>

 

[Randy Webb]

VK said the following on 2/9/2006 2:18 AM:

A bit too loud to say maybe, but let's us assume it's true

It is, even if you don't admit it.

Because VK is up to date the best specialist of *JavaScript arrays* on
the planet (if we decided do go by loud definitions).

I want some of what ever you are smoking because it is some good stuff man.

But please tell me, oh great Javascript Array specialist that you claim
to be, how can something that is linear in form be "jagged"? Even your
own quotes (that you have refused, to date, to give URL's to) don't even
agree on what a jagged array is. Thomas gave you the best resources you
could possibly have used in your defense but you missed them.

btw in the reality it's just the opposite: currently Randy and Robert
are the only known people on the planet denying that JavaScript array
is jagged. (I'm not counting few amateurs posted here just for the hell
of nastiness).

Here's your chance then, oh "Great Javascript Array Guru" that you
portray yourself as. Please answer a question for me? It shouldn't be
too hard for you since you claim to be the best JS Array specialist around:

Question:
Why does Richard's code *not* qualify as a multi-dimensional array?

If you are so great, that should take you about .00000000002 seconds to
answer.

 

[VK]

I want some of what ever you are smoking because it is some good stuff man.

Only natural stuff man: a bit of beer and 40 (and counting) posts in
the row from frequent posters like in this thread. LSD takes a rest
after that.

But please tell me, oh great Javascript Array specialist that you claim
to be, how can something that is linear in form be "jagged"? Even your
own quotes (that you have refused, to date, to give URL's to) don't even
agree on what a jagged array is. Thomas gave you the best resources you
could possibly have used in your defense but you missed them.

Nothing helpful I can do for you besides copy my sample again:

var myArray = new Array();
myArray[0] = new Array(1,2,3,4);
myArray[1] = new Array(1,2,3);
myArray[2] = new Array(1,2);
myArray[3] = new Array(1,2,3,4);

Maybe it will be a bit more visual:

var myArray = [
[1,2,3,4],
[1,2,3],
[1.2],
[1,2,3,4]
];

If you still do not see why the term "jagged" has been coined then I'm
really out of further ideas. That maybe not the best term to use, but
not always the best terms are going into programming vocabulary.

To foreign readers:
jagged
1. raggedly notched; sharply irregular on the surface or at the
borders.
(Random House Webster, 1998, New York)

To British readers:
The word "jagged" in the above indicated meaning is first registered
in English manuscripts at the beginning of XV century.
(In case if someone thinks of it as a yaky Americanism)

Here's your chance then, oh "Great Javascript Array Guru" that you
portray yourself as. Please answer a question for me? It shouldn't be
too hard for you since you claim to be the best JS Array specialist around:

Question:
Why does Richard's code *not* qualify as a multi-dimensional array?

If you are so great, that should take you about .00000000002 seconds to
answer.

Maybe not so quick - my neuron signals are not going so quick (speed of
light limitation, damn it), plus give me a break for typing

Actually it was already answered right away why it is *not*
multi-dimensional array. But as I got more experience in having a
discussion with you, I'm not failing on this trick again. First of all,
dear Sir, you have to find out what *is* multi-dimensional array and
paste (or link) a working sample of multi-dimensional array, say
VBScript, C#, C++ or Java. And this has to come not from your own mind
or a freshly updated wiki article, but *at least* from an engine
producer page or (best of all) from some reputable higher education
establishment.

Asking for definition while refusing to disclose your own one (so you
can always say: "That's not one!") *was* a great trick, but it is
currently explored to the end - with me at least.

 

[Richard Cornford]

In your page at:-

<http://www.geocities.com/schools_ring/ArrayAndHash.html>

- (under the title "Array and Hash in JavaScript") your
wrote:-

| You can use a notation like arrayObject[-1] to address
| the last element in the array, but it's not a negative
| index: it's just a shortcut of
| arrayObject[arrayObject.length-1]

You must be using an outdated copy of my article. The quoted
statement has been made in the version 2.0 ( July 2005 ).

I accessed your page with that content on 2006-02-04, I would not have
quoted it if I had not first verified the current state of the page.
Claiming that you fixed it 6 months ago is not credible as there is no
way that an HTTP cache stored and delivered a 6 month old version of
such an obscure page.

I noticed when I looked at that page that about 50% of the contend had
disappeared since the last time I looked at your page, so the content
was significantly less false than the original. There isn't going to be
a great deal left once you have removed the remaining irrelevancies,
misconceptions and falsehoods.

Everyone can make a mistake - the task to correct it
in a timely manner.

Everyone can make mistakes, it takes a fool to repeat them.

To make sure that your knowledge about JavaScript arrays
is correct,

There is nothing that you could teach me about javascript arrays, and
your page is more likely to promoted confusion and misunderstanding than
knowledge.

always use the *official* version of "Array
and Hash" article:

<snip>

So have you changed the title?

Richard.

 

[VK]

I accessed your page with that content on 2006-02-04, I would not have
quoted it if I had not first verified the current state of the page.

Are you publically accusing me in cheating? That's not nice of you. The
relevant paragraph has been corrected July 7 2005. You could not get
not-corrected variant as of 2006-02-04 unless something is deeply wrong
with your server cach.

Claiming that you fixed it 6 months ago is not credible as there is no
way that an HTTP cache stored and delivered a 6 month old version of
such an obscure page.

<http://groups.google.com/group/comp...3afa53a28f8/5d5d9f14b0ba09c9#5d5d9f14b0ba09c9>
Jul 7 2005, 3:36 pm

Comment: "You can use a notation like arrayObject[-1] top address the
last element in the array". Nope, doesn't work. It merely tries to
access the property named "-1", which doesn't exist unless you created
it.

VK:
My bad! Did not check it for addressing option. Changed to:

Although in array methods you may refer the last array element using
-1, it's not a negative index, it's just a shortcut: for instance
arrayObject.slice(10,-1) simply means
arrayObject.slice(10,arrayObject.length-1)

P.S. Richard, that's getting too low for a *discussion*. Should we take
a coffee break for a day or two to let emotions out?

 

[Richard Cornford]

Randy Webb wrote:

Nothing helpful I can do for you besides copy my sample
again:

var myArray = new Array();

];

If you still do not see why the term "jagged" has been
coined then I'm really out of further ideas.

The reason for using the term 'jagged' (or the alternative 'ragged') has
never been questioned. This thread exists because when you said (and
repeated) "JavaScript Array is dynamic, jagged, sparse" you were
applying the term 'jagged' to something that is incapable of exhibiting
jaggedness; the javascript Array.

No amount of definitions of a 'jagged array' that effectively state that
a jagged array is something that a javascript Array is not will make the
term applicable to a javascript Array. And no number of examples of code
that can be described as a 'jagged array' but represent structures that
are not a javascript Array will convince anyone (except you) either.
Most people don't make the mistake of trying to transfer the qualities
of a construction onto its component parts.

Consider the implications of this notion of transferring a label for a
structure (no matter how appropriate that label may appear for that
structure) to its building blocks. By analogy, and using an archetypal
building block; the house brick: A house brick might be characterised as
'a normally rectangular block of ceramic', and it may be used to build
various sorts of structures, one of which might be appropriately
labelled 'a perimeter barrier around a property' (i.e. a garden wall).

The same logic that labels an array of arrays as a 'jagged array' and
then uses that to justify 'jagged' in "JavaScript Array is dynamic,
jagged, sparse" would also have a house brick characterised as 'a
normally rectangular block of ceramic, a perimeter barrier around
property'. This is not sound reasoning. When component parts are
distinct form the construction the ability to make the construction does
not imbue the components with the qualities of that construction.

And this style of reasoning is doubly poor because the same components
can be used to construct many things for which mutually exclusive labels
are appropriate. This is true of house bricks, which might be used to
create structures that may be labelled 'internal walls', 'paving' and so
on. The house brick could not have all of these qualities at the same
time. And this is particularly true of objects in a programming language
that is capable of emulating anything. Would it be reasonable to
characterise the javascript Object as 'a dynamic collection of
name/value pairs, interface to web services and an XML parser' because
it is possible to use it to create structures that could reasonably be
labelled 'an interface to web services' or an 'XML parser'? Obviously
not.

If you are going to characterise a javascript Array you should be saying
something that is true of javascript Arrays. Either true of all
javascript Arrays or potentially true of all javascript Arrays, and it
is impossible for any javascript Array to exhibit jaggedness so the term
'jagged cannot be appropriately used to characterise javascript Arrays.

This is the crux of the question of the appropriateness of 'jagged' as a
characterisation of the javascript Array; either a (any) javascript
Array instance can be shown to exhibit jaggedness or the term is not
applicable. And as the impossibility of a javascript Array exhibiting
jaggedness has been logically proven nothing short of code demonstrating
this 'impossible phenomenon' would modify the obvious conclusion that
you are incorrect to attempt to apply the tem 'jagged' as a
characterisation of the javascript Array.

That maybe not the best term to use, but
not always the best terms are going into
programming vocabulary.

How appropriate the term may be for an array of arrays is not relevant
when characterising something that is not an array of arrays.

To foreign readers:
jagged
1. raggedly notched; sharply irregular on the surface
or at the borders.
(Random House Webster, 1998, New York)

<snip>

And Randy's question was "how can something that is linear in form be
"jagged"?". We are agreed that the javascript array is not
multi-dimensional and presumably agree that it has a dimension, so it
must have just one dimension. Anything that has just one dimension can
reasonable be described as 'linear', but a straight line does not have a
sharply irregular surface or borders. So how can the single dimensional
javascript array be reasonably characterised as 'jagged'?

Actually it was already answered right away why it
is *not* multi-dimensional array.

<snip>

Someone wanting to label the structure that is an array of differently
sized arrays as a 'jagged array' should be able to state a good reason
when they don't what to label an array of identically sized arrays as a
multi-dimensional array. So far you have never made such a statment.

Recall that one of the definitions of a 'jagged array' that you posted
read; "We are using the term "jagged array" to describe a
multi-dimensional array that is not necessarily rectangular", and if a
'jagged array' is an array of arrays and a 'jagged array' is a
multi-dimensional array that is not necessarily rectangular it is
difficult to see how an array of arrays can avoid being labelled a
multi-dimensional array by these definitions of a 'jagged array'.

Richard.

 

[Richard Cornford]

Are you publically accusing me in cheating?

Are you accusing me of lying?

That's not nice of you.
Ditto.

The relevant paragraph has been corrected July 7 2005.
You could not get not-corrected variant as of
2006-02-04 unless something is deeply wrong with your
server cach.

<snip>

Unexpected HTTP caching behaviour is certainly one explanation for the
events that transpired.

It makes no real difference. In your self-proclaimed role as "the best
specialist of *JavaScript arrays* on the planet" you still wrote those
lines, and needed to be told by a lesser mortal that they were nonsense.

Of course all the other lesser mortals who pointed out the flaws in the
aspects of your page that remain were just as correct in their
assessment, you just prefer not to listen to what they had to say.

Richard.

 

[VK]

Are you accusing me of lying?

<snip>

Unexpected HTTP caching behaviour is certainly one explanation for the
events that transpired.
ASK

It makes no real difference. In your self-proclaimed role as "the best
specialist of *JavaScript arrays* on the planet" you still wrote those
lines, and needed to be told by a lesser mortal that they were nonsense.

Yes: *6 months ago*. And they were not some complete out-off-head
nonsense as you may notice. "Negative index shortcut" does exists - but
in array methods. It was a wrong extension of its usage. And 6 month
later "negative index shortcut" is even in standard Collection
addressing schema: insertRow(-1)

So it's nothing like "jagged because it contains links of different
length" and other Of Kings And Cabbage stuff posted here over the last
48 hrs by different people.

Of course all the other lesser mortals who pointed out the flaws in the
aspects of your page that remain were just as correct in their
assessment, you just prefer not to listen to what they had to say.

Whatever was pointed out and appeared to be my mistakes was immediately
corrected. You even may notice thank you notice to Lasse Reichstein
Nielsen at the bottom of my article with disclosure of his personal
position. And the date by the way.

 

[Richard Cornford]

Richard Cornford wrote:

ASK

Ask who exactly? The number, nature, disposition and ownership of HTTP
caches along the path of any particular HTTP request is unknowable.

Yes: *6 months ago*.

So 6 months ago you were not the self-proclaimed "the best specialist of
*JavaScript arrays* on the planet"? And what exactly has changed in the
intervening period?

And they were not some complete out-off-head
nonsense as you may notice.

Just an objectively false statement.

So it's nothing like "jagged because it contains links
of different length" and other Of Kings And Cabbage stuff
posted here over the last 48 hrs by different people.

Is that intended to mean something?

Whatever was pointed out and appeared to be my mistakes
was immediately corrected.

<snip>

Which suffers from your misguided filtering out of what appears (or at
the time appeared) to you not to be mistaken.

Richard.

 

[VK]

Ask who exactly? The number, nature, disposition and ownership of HTTP
caches along the path of any particular HTTP request is unknowable.

ASKnowledged

Means we just stop at this point w/o making me to request official
digitally signed FTP log from Yahoo, ICANN IP mapping for each session,
my provider IP mapping to ICANN mapping etc. etc. It's a whole bunch of
paper work from my part and it takes up to 6 months if not expedited. I
already had to pass it once but at least for my clients and at least
for some money involving copyright question. It is easier to blame on
cache really )

So 6 months ago you were not the self-proclaimed "the best specialist of
*JavaScript arrays* on the planet"? And what exactly has changed in the
intervening period?

A lot of study.
Also please note that "the best specialist of *JavaScript arrays* on
the planet" had been used in the polemic context of "the best
JavaScript writers in the world in this group" which was said first and
not by me.

Is that intended to mean something?

It means when when I answered OP's question using proper academically
correct terms, I had to vaste my time and patience to answer on a bunch
of mostly irrelevant posts of kind of "Prove that the Earth is
rounded", "And now prove that the sky is blue" etc.

If something is not as you taught and thought of it to be, what VK has
to do with it? Go unleash you frustration on the first available wiki
(or two), not on me.

Which suffers from your misguided filtering out of what appears (or at
the time appeared) to you not to be mistaken.

This is why I checked myself over different reputable sources to make
sure that my "mental filters" do not filter out something important.

Personal "mental filters" check is an important thing everyone needs to
make on a not so frequent but regular basis.

 

[Thomas 'PointedEars' Lahn]

Richard Cornford wrote:

Unexpected HTTP caching behaviour is certainly one
explanation for the events that transpired.

ASK

Ask who exactly? [...]

ASKnowledged
[...]

<URL:http://foldoc.org/?query=ASK>
<URL:http://foldoc.org/?query=ACK>
<URL:http://www.catb.org/~esr/jargon/html/A/ACK.html>


HTH

PointedEars

 

[John G Harris]

A bit too loud to say maybe, but let's us assume it's true


Because VK is up to date the best specialist of *JavaScript arrays* on
the planet (if we decided do go by loud definitions).

btw in the reality it's just the opposite: currently Randy and Robert
are the only known people on the planet denying that JavaScript array
is jagged. (I'm not counting few amateurs posted here just for the hell
of nastiness).

It was an amateur who invented the photon. He got a Nobel Prize for it.
In English, amateur doesn't mean ignorant, it means someone who doesn't
get paid for it.

Coming back to the subject, the best that a javascript Array object can
do is to hold an array of references. If they are references to Array
objects then the programmer, with considerable effort, has implemented a
structure that has the behaviour of an n-dimensional array. The
structure might be jagged or it might never be - whichever the
programmer's code forces it to be.

The programmer might be building something else. I very much doubt if
your MIT people would use the word jagged when some points are two
dimensional and other points are five dimensional. They'd call it a
tree. (Or a forest, depending where they start from).

John

PS You're not forced to use Array objects to implement a forest/tree.

 

[VK]

It was an amateur who invented the photon. He got a Nobel Prize for it.
In English, amateur doesn't mean ignorant, it means someone who doesn't
get paid for it.

Right. Sorry.

Coming back to the subject, the best that a javascript Array object can
do is to hold an array of references. If they are references to Array
objects then the programmer, with considerable effort, has implemented a
structure that has the behaviour of an n-dimensional array. The
structure might be jagged or it might never be - whichever the
programmer's code forces it to be.

As well as array can be sparse or "condensed". A presence of some
feature doesn't imply the necessity to use this feature on practice. At
the same time this feature can be used for the abstract model
description in order to distinguish it from another model.

We say "prototype-based" but it doesn't imply prototype usage:

<script type="text/javascript">
var a = 2;
var b = a + 2;
</script>

No one proposed (yet?) to define JavaScript as "just simply programming
language - and prototype-based if prototypes are used".

P.S. If I was the president of some Programming Entities Naming
Committee I would not endorse "jagged" term. I would try to find
something better. But I'm just using what was named before me.
"static" modifier name is neither good not correct in application to
its effect. But it was named this way before me, so I have no
opportunity to use say "singleized" instead.

 

[ron.h.hall]

Right. Sorry.

Realy gotta love ya VK! When you're wrong, you insist you are right.
When in one of the seemingly less common instances you are right,
you're readily buffaloed.

The above definition of 'amateur' may be original, but it's not
comprehensive. A number of dictionaries, including the compact OED,
provide any of "incompetent", "inept", "non-professional", and
"lacking professional skill" as valid alternative meanings.

../rh

 

[VK]

Realy gotta love ya VK! When you're wrong, you insist you are right.
When in one of the seemingly less common instances you are right,
you're readily buffaloed.

I'm readily agree when I'm wrong in any matter, small or big... as soon
as it is pointed to the correct explanation. Moreover I feel graceful
for being taught something I did not know. I do not agree to be wrong
just because someone says "You ignorant, that's wrong because I says
so". Such arguments do not work for me. And if you read this thread
once over you will see that 95% of posts are of this exact nature.

The above definition of 'amateur' may be original, but it's not
comprehensive. A number of dictionaries, including the compact OED,
provide any of "incompetent", "inept", "non-professional", and
"lacking professional skill" as valid alternative meanings.

Still the *first* meaning in all distionaries I can hold on is like "a
person who engages in a study, sport, or other activity for pleasure
rather than for financial benefits".

I used it in the additional meaning of "a person inexperienced or
unskilled in a particular activity". I still sorry for using it as such
response drops me down to the level of some of my opponents.

 

[Richard Cornford]

VK wrote:

As well as array can be sparse or "condensed". A presence
of some feature doesn't imply the necessity to use this
feature on practice.

The total absence of any evidence of any javascript Array instances
exhibiting jaggedness, plus the logical proof that it is impossible for
a javascript Array instance to exhibit jaggedness, does imply that
'jagged' is an inappropriate term to apply to javascript Arrays.

P.S. If I was the president of some Programming
Entities Naming Committee

That will never happen.

I would not endorse "jagged" term. I
would try to find something better.

<snip>

Jagged is a fine term to apply to entities that exhibit jaggedness. It
is even an acceptable term to apply to entities that could exhibit
jaggedness but don't happen to in a specific instance. It is not an
appropriate term to apply to entities that are incapable of exhibiting
jaggedness, but as you are the only person who wants to do that (and are
incapable of providing any relevant justification for your decision) the
only folly here is yours, and you are the only person who need be
involved in correcting it.

Richard.

 

[Richard Cornford]

A lot of study.

But you are the person for whom study results in your beliefs becoming
more false.

Also please note that "the best specialist of *JavaScript
arrays* on the planet" had been used in the polemic context

You still made that claim. Laughable as everyone else found it.

of "the best JavaScript writers in the world in this group"
which was said first and not by me.

An opinion about others from someone with the experience to apply
judgement to his opinions.

In your constant appeals to unnamed "professional programmers and
programming specialists" and un-cited "academic" sources you appear to
be assuming that all the contributors to this group are uninformed
amateurs dabbling in browser scripting as a hobby. While in reality the
bulk of the contributors to this group are active professional
programmers, some are browser scripting specialists and there are even
computer science academics. And you can easily see this in the veracity
of the statements they make here. Statements often made with the
openness of the individuals full name, rather than hiding behind the
anonymity of an arbitrary label.

You are certainly not a professional programmer (even if someone may be
fool enough to pay you to write computer code). That is evident, if from
no other source, in your total inability to comprehend or employ logic
(one of the mainstays of computer programming). You cannot see that in:-

| Neither C++ or Java array are *obligated* to be multi-dimensional.
| In any language I can perfectly create a simple single-dimention
| array. Applying your own thesis: "The very fact that you must
| have more than one dimension in order to implement the concept of
| `multi-dimensional' means that the term _cannot_ apply to a C++
| array (singular)."

- the conclusion cannot be derived from the perms, or that the only
conclusion that can be derived is unrelated to the conclusion you drew
and utterly trivial.

The only valid derivation is that single-dimension and multi-dimension
have a mutually exclusive relationship, which follows trivially from the
definitions of "single" and the prefix "muti", but as the C++ array can
have any number of dimensions, including one, the trivial exclusive
relationship between single-dimension and multi-dimensional doesn't
apply as a characteristic of the C++ array, only as characteristic of
individual C++ array instances.

It means when when I answered OP's question using proper
academically correct terms,

But those are only academically correct terms for something other than
the subject you applied them to. The supposedly academically originating
definitions you quoted said as much.

I had to vaste my time and patience to answer on a
bunch of mostly irrelevant posts of kind of "Prove
that the Earth is rounded", "And now prove that the
sky is blue" etc.

But the statement you are trying to defined is along the lines of 'air
molecules re blue, and you should be asked to defend that position if
you are going to take it.

If something is not as you taught and thought of it to be,
what VK has to do with it?

The something that is, is as it is independently of what either of us
may say on the subject, but what you are saying on the subject is
irrational and that has a great deal to do with you personally.

Go unleash you frustration on the first available wiki
(or two), not on me.

Why, you are the cause of the problem, only making you see that your
mental processes are error-producing could result in your correcting
your faulty behaviour.

This is why I checked myself over different reputable sources
to make sure that my "mental filters" do not filter out
something important.

But you don't see how this self-checking is letting you down? You post
statements that are absolutely and demonstrably false when applied to
javascript on a regular basis. You argue when your are validly
corrected, maintaining the truth of your statements, posting snippets of
code that don't actually do what you think they do, and you even go off
and bother bug reporting systems with examples of things that are not
doing what you think they should be doing but are actually completely
correct. And in general waste a great deal of time being repeatedly
corrected for errors that others would only need to see pointed out
once.

Personal "mental filters" check is an important thing everyone
needs to make on a not so frequent but regular basis.

When your 'mental filters' reject the proposition that your mental
filters are fundamentally erroneous you can check yourself as often as
you like and never see reason to change anything. The opinions of others
are very impotent in forming an objective assessment of your 'mental
filters', assuming that they can avoid automatically filtering those
opinions as well.

Richard.

 

[Richard Cornford]

Despite you're trying to point to my own vocabulary problems,
you show (or more probably pretending to show) even more
serious vocabulary problems.

Like what?

I'm repeating it in Nth and the last time, as it's getting
really boring:

Yes, you should stop repeating yourself and do something about
addressing the substantive criticisms of the potion you have taken.

"jagged" in application to array doesn't mean "irregular on
the borders", "ragged" etc. These are meanings from the common
vocabulary.

If you didn't want the 'common vocabulary' applied to your statement why
did you quote the common definition?

Jagged array means an array whose elements are arrays.

So a construct that must involve at least two javascript Arrays (if it
is to have any potential to exhibit jaggedness).

This is why I'm not happy with the term "jagged": it doesn't
describe well the nature of the entity which it names.

No, it is a fine way of describing the entities that it names, the issue
here has been that you want to apply the label to an object that is not
one of the entities that it can be applied to.

Still I tend to believe that the most basic knowledge of
English

And in the absence of any apparent real understanding of English I
suppose you are only left with believing you have such an understanding.

(plus some programming skills of course)

You can always specuatle.

suffice now to get the picture right.

They should suffice, if you had either.

Here is an MSDN link

http://msdn.microsoft.com/library/en-us/csref/html/vclrfjaggedarrays.asp

A page on C# that states that "A jagged array is an array whose elements
are arrays", and so once again describes a construct created with arrays
and not a characteristic of an array (in C# or javascript).

- I took it not as the most reputable source, but as the
most plain language written among my collection.

And again a statement that describes/categorises a structure and does
not even attempt to make a statement about the nature of an array object
in the pertinent language.

So once again:

JavaScript / JScript array is:

Dynamic
- which doesn't imply this property usage. You can instantiate
an array of some size and stay within this size only.

Where dynamicsness is a fundamental characteristic of a javascript
Array. all arrays may be subject to runtime modification.

Sparse
- which doesn't imply this property usage. You can go strictly
by ++ / -- index increment.

Where sparseness is a fundamental characteristic of a javascript Array.
all javascript arrays either are sparse or can be rendered sparse.

Jagged
- which doesn't imply this property usage.

That doesn't really mean anything.

You can instantiate a regular single-dimension array

All javascript Arrays are single-dimensional, that is also a
characteristic of the javascript Array.

without any arrays as its elements.

If a 'jagged array' is an array or arrays (or any other name for a
construct that requires more than one javascript Array) then all objects
that are not arrays of arrays (or constructs made with more than one
javascript Array) cannot be a 'jagged array'. And a javascript Array is
not an array of arrays. The qualities of the construct do not transfer
to its components by virtue of their potential to be used as such
components.

Some sources also suggest to use "multi-typed" ...

<snip>

More irrelevant misdirection?

Richard.