AxWald wrote:Does this mean I always have a key/ value pair? With just 1 value? OMG, I really need to search for some manual "arrays made easy, special edition for databankster". Cannot help to think I have a massive misconception of it

Here's one stab at it:
LiveCode Script's arrays are associative arrays, similar to what you'd find in other languages that support associative arrays, like Perl, Python and others. Some languages call them "dictionaries", but the general structure and use is more or less the same for all associative arrays. They may differ in specifics, esp. limits and types, so what follows is for LC only.
An associative array is a collection of
key-value pairs.
The
key can be any string up to 255 chars, NULLs and CRs best avoided (the dictionary suggests sticking to alphanumeric characters, which is generally good guidance).
The
value can be any string, or any binary data, or even another array. There's a logical limit of 4 GB to an array element, but in practical terms you're likely to run out of memory for other reasons before you reach that one.
Other than the syntax you already know, that's most of everything you need to know to use arrays.
But sometimes it can help to use them well to be able to picture what's going on under the hood:
When a value is put into an array element, the key is run through a simple hash function to determine a memory bucket to store it in, which each bucket being a collection of pointers to the values. The hash is designed to distribute element pointers across buckets somewhat evenly, favoring access time at the cost of any internal representation of order.
For example, given a set of elements named "bob", "ellen", "elmer", and "ethan", if our hash merely used the first letter to assign an element to one of four buckets, we'd be top-heavy in "e" with only one element in "b", and two buckets would be empty. The hash used in LC is smarter, attempting to assign buckets somewhat evenly so we might wind up with "bob" in bucket 4, "ellen" in bucket 1, "ethan" in bucket 3, and "elmer" in bucket 4. The hash isn't concerned with order, it's focused on even distribution.
This internal hashing is not something we normally need to think about, but helps explain why there is no sense of order to the elements of an associative array, in contrast the indexed arrays found in some languages where keys are always sequential integers.
When integers are used in an associative array, they're merely strings; e.g. "1" might just as well be "one" or "uno" or even "bob". Numeric keys may useful for us conceptually, like being able to get and set values sequentially in our scripts. But the internal mechanism that keeps track of keys doesn't care whether the string contains only numerals or anything else. The key of an associative array element is always just a string to the engine, and all keys are stored internally by hash value, not any numeric value that may be in the string.
This hashing also explains why the time needed to find an element doesn't change much even as the array grows, because the location is determined by the hash of the key, pointing directly to a bucket through which the value can be found. This contrasts with things like delimited lists, which require the engine to evaluate each character sequentially, counting delimiters as it goes.
In the engine, an array's collection of memory pointers can occupy many locations, so there is no single contiguous block of memory representing it. This means that we have no way to save an array in its native form, so we need to
serialize it, to turn the sequence of pointers to disparate locations into a single contiguous stream of bytes.
And that takes us to arrayEncode, which converts the pointer collection as the engine handles the array into a bytestream that can be saved to disk or sent over a network. The arrayDecode reverses that process, converting the bytestream back into a collection of pointers in memory ready for the engine to use efficiently.
Hope some of this background is useful. The Wikipedia page on associative arrays provides more detail:
https://en.wikipedia.org/wiki/Associative_array