Array-like objects in JavaScript_javascript skills-JS Tutorial-php.cn

Array-like objects in JavaScript_javascript skills

WBOY

Release： 2016-05-16 16:05:20

Original

1172 people have browsed it

I knew a long time ago that arguments can be converted into an array: [].slice.call(arguments), because
arguments is an array-like object, so it can be used like this. But I have never been clear about what array-like objects are called

When I read Effective JavaScript today, there was a section dedicated to this, and it felt really cool.

First look at some sample code I wrote:

Copy code The code is as follows:

a = "hello"

[].map.call(a, (e) -> e.toUpperCase()) # => [ 'H', 'E', 'L', 'L', 'O' ]

[].reduceRight.call(a, (acc, e) -> acc e) # => 'olleh'

b = {1: "a", 2: "b", 4: "c", length: 6}

[].reduce.call(b, (acc, e) -> acc e) # => 'abc'

The first ones operate on strings. Well, strings can also be regarded as array-like objects. But the b object at the back is actually
It is also an array-like object.

Read the explanation in the book:

Copy code The code is as follows:

So what exactly makes an object “array-like”? The basic contract of

an array object amounts to two simple rules.

It has an integer length property in the range 0...2^32 – 1.

The length property is greater than the largest index of the object.

An index is an integer in the range 0...2^32 – 2 whose string representation

is the key of a property of the object.

There are only these two simple rules.

So why can arguments, strings, and the b object above be regarded as array-like objects?

They all have a legal length attribute (a positive integer between 0 and 2**32 - 1).
Values of the length attribute are greater than their maximum index.
Another example:

Copy code The code is as follows:

b = {1: "a", 2: "b", 4: "c", length: 3}

[].reduce.call(b, (acc, e) -> acc e) # => 'ab'

Well, that’s wrong, it became ‘ab’, because it violates rule 2: the length attribute is 3,
The maximum index value is 4 which is greater than the length property. So the behavior is abnormal.

It’s too powerful. It seems that it just defines an interface. As long as it conforms to this interface, you can use all methods of the array.

In fact, not all methods can be used, Array.prototype.concat
It cannot be used because it connects two arrays. If you are not an array person, you will definitely not be able to use it.

Another small problem is that the string is immutable after it is created, so it will remain immutable no matter how you toss it.

But this book does not explain at all why it can be regarded as an array-like object if it meets these two conditions. In addition, the author of this book
He is a member of the ECMAScript committee, so it is basically credible. As for why it can be regarded as an array-like object if it meets these two conditions, I don't know. I searched on Google for a long time and found no reasonable explanation.

The above is the entire content of this article, I hope you all like it.