Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://2ality.com/2013/05/quirk-array-like-objects.html below:

JavaScript quirk 8: array-like objects

[This post is part of a

on JavaScript quirks.]

Some objects in JavaScript look like arrays, but aren’t. They are called array-like. This blog post looks at what exactly that means and how to best work with those objects.

An array-like object

• has: indexed access to elements and the property length that tells us how many elements the object has.
• does not have: array methods such as push, forEach and indexOf.

Two examples of array-like objects is the result of the DOM method

(many DOM methods return array-like objects) and the special variable

. You can determine the number of arguments via

	arguments.length

And you can access a single argument, e.g. read the first argument:

	arguments[0]

Array methods, however, have to be borrowed. You can do that, because most of those methods are

.

A generic method does not require

to be an array, it only requires

to have

and indexed element access. Normally, you invoke a method

on an array

as follows.

	arr.m(arg0, arg1, ...)

All functions have a method

that allows you to perform the above invocation differently:

	Array.prototype.m.call(arr, arg0, arg1, ...)

The first argument of

is the value for

that

receives (in this case,

). Because we access

directly and not via

, we can now hand any

to that method. For example,

:

	Array.prototype.m.call(arguments, arg0, arg1, ...)

Let’s continue with a concrete example. The following function

logs all arguments that it receives.

    function printArgs() {
        Array.prototype.forEach.call(arguments,
            function (arg, i) {
                console.log(i+'. '+arg);
            });
    }

We have used method

generically.

in use:

    > printArgs()
    > printArgs('a')
    0. a
    > printArgs('a', 'b')
    0. a
    1. b

You can even apply generic methods to ordinary objects:

    > var obj = {};
    > Array.prototype.push.call(obj, 'a');
    1
    > obj
    { '0': 'a', length: 1 }

In the above case, property

did not exist and was automatically created, with the initial value zero.

Sometimes the best way to work with an array-like object is to convert it to an array. That can also be done via a generic method:

	Array.prototype.slice.call(arguments)

Compare: to create a copy of an array

, you make the method call

	arr.slice()

1. JavaScript quirk 5: parameter handling

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4