{{index encapsulation, isolation, modularity}}

The core idea in object-oriented programming is to divide programs

own state.

This way, some knowledge about the way a piece of the program works

Such program pieces are modeled using ((object))s. Their interface

consists of a specific set of ((method))s and properties. Properties

outside code should not be touching, are called _private_.

{{index "underscore character"}}

Many languages provide a way to distinguish public and private

ones altogether. JavaScript, once again taking the minimalist

approach, does not. Not yet, at least—there is work underway to add

this to the language.

You can think of `this` as an extra ((parameter)) that is passed in a

different way. If you want to pass it explicitly, you can use a

function's `call` method, which takes the `this` value as first

{{index this, "arrow function"}}

Arrow functions are different—they do not bind their own `this`, but

something like the following code, which references `this` from inside

{{index inheritance, "Function prototype", "Array prototype", "Object prototype"}}

Many objects don't directly have `Object.prototype` as their

default properties. Functions derive from `Function.prototype`, and

arrays derive from `Array.prototype`.

prototype is associated with a constructor (through its `prototype`

property) and the way objects _have_ a prototype (which can be found

with `Object.getPrototypeOf`). The actual prototype of a constructor

`prototype` _property_ holds the prototype used for instances created

through it.

Overriding properties that exist in a prototype can be a useful thing

to do. As the rabbit teeth example shows, it can be used to express

exceptional properties in instances of a more generic class of

standard value from their prototype.

{{index "toString method", "Array prototype", "Function prototype"}}

different `toString` method than the basic object prototype.

`.join(",")` on it—it puts commas between the values in the array.

Directly calling `Object.prototype.toString` with an array produces a

different string. That function doesn't know about arrays, so it

brackets.

{{index "Object.create function", prototype}}

As such, using plain objects as maps is dangerous. There are several

objects with _no_ prototype. If you pass `null` to `Object.create`,

safely be used as a map.

{{index "Map class"}}

Fortunately, JavaScript comes with a class called `Map` that is

type of keys.

It is possible for multiple interfaces to use the same property name

the `toString` method is supposed to convert the object into a piece

of yarn. It would not be possible for an object to conform to both

that interface and the standard use of `toString`.

The class stores its content in a single array of _width_ × _height_

element in the fifth row is (using zero-based indexing) stored at

position 4 × _width_ + 2.

The class tracks the progress of iterating over a matrix in its `x`

and `y` properties. The `next` method starts by checking whether the

bottom of the matrix has been reached. If it hasn't, it _first_

position, moving to the next row if necessary.

Let us set up the `Matrix` class to be iterable. Throughout this book,

Interfaces often consist mostly of methods, but it is also okay to

include properties that hold non-function values. For example, `Map`

objects have a `size` property that tells you how many keys are stored

It is not even necessary for such an object to compute and store such

a property directly in the instance. Even properties that are accessed

Sometimes you want to attach some properties directly to your

constructor function, rather than to the prototype. Such methods won't

provide additional ways to create instances.

Inside a class declaration, methods that have `static` written before

{{index inheritance, "matrix example", "object-oriented programming", "SymmetricMatrix class"}}

Some matrices are known to be _symmetric_. If you mirror a symmetric

same. In other words, the value stored at _x_,_y_ is always the same

as that at _y_,_x_.

the fact that the matrix is and remains symmetrical. We could write it

from scratch, but that would involve repeating some code very similar

to what we already wrote.

JavaScript's prototype system makes it possible to create a _new_

class, much like the old class, but with new definitions for some of

its properties. The prototype for the new class derives from the old

In object-oriented programming terms, this is called

_((inheritance))_. The new class inherits properties and behavior from

The `set` method again uses `super`, but this time not to call the

constructor, but to call a specific method from the superclass' set of

behavior. Because `this.set` refers to the _new_ `set` method, calling

that wouldn't work. Inside class methods, `super` provides a way to

call methods as they were defined in the superclass.

{{index inheritance}}

is an instance of `Matrix`. The operator can also be applied to

standard constructors like `Array`. Almost every object is an instance

of `Object`.

_polymorphism_.

When implementing multiple classes that differ in only some details,

existing class, _inheriting_ part of its behavior.

{{index "for/of loop", "iterable interface"}}

The `from` method can use a `for`/`of` loop to get the values out of

group.

hint}}

If you used an array to represent the group's members, don't just

return the iterator created by calling the `Symbol.iterator` method on

It is okay if your iterator behaves strangely when the group is

modified during iteration.

it is done, and if not, moves past the current value and returns it.

The `Group` class itself gets a method named by `Symbol.iterator`

that group.

hint}}