which scripts are used in a piece of text:

function textScripts(text) {
  let scripts = countBy(text, char => {
    let script = characterScript(char.codePointAt(0));
    return script ? script.name : "none";
  }).filter(({name}) => name != "none");

  let total = scripts.reduce((n, {count}) => n + count, 0);
  if (total == 0) return "No scripts found";

  return scripts.map(({name, count}) => {
    return `${Math.round(count * 100 / total)}% ${name}`;
  }).join(", ");

console.log(textScripts('英国的狗说"woof", 俄罗斯的狗说"тяв"'));
// → 61% Han, 22% Latin, 17% Cyrillic


Being able to pass function values to other functions is a deeply useful aspect of JavaScript.

Array higher-order methods: forEach, filter, map, reduce, some, findIndex.



Use the reduce method in combination with the concat method to “flatten” an array of arrays into a single array that has all the elements of the original arrays.

let arrays = [[1, 2, 3], [4, 5], [6]];
// Your code here.
// → [1, 2, 3, 4, 5, 6]

Your own loop

Write a higher-order function loop that provides something like a for loop statement.

// Your code here.

loop(3, n => n > 0, n => n - 1, console.log);
// → 3
// → 2
// → 1


Analogous to the some method, arrays also have an every method. This one returns true when the given function returns true for every element in the array. In a way, some is a version of the || operator that acts on arrays, and every is like the && operator.

Implement every as a function that takes an array and a predicate function as parameters. Write two versions, one using a loop and one using the some method.

function every(array, test) {
  // Your code here.

console.log(every([1, 3, 5], n => n < 10));
// → true
console.log(every([2, 4, 16], n => n < 10));
// → false
console.log(every([], n => n < 10));
// → true

Dominant writing direction

Write a function that computes the dominant writing direction in a string of text.
each script object has a direction property that can be "ltr" (left to right), "rtl" (right to left), or "ttb" (top to bottom).
The dominant direction is the direction of a majority of the characters that have a script associated with them. The characterScript and countBy functions defined earlier in the chapter are probably useful here.

function dominantDirection(text) {
  // Your code here.

// → ltr
console.log(dominantDirection("Hey, مساء الخير"));
// → rtl

Chapter 6 - The Secret Life of Objects


The core idea in object-oriented programming is to divide programs into smaller pieces and make each piece responsible for managing its own state.

This way, some knowledge about the way a piece of the program works can be kept local to that piece.
Whenever these local details change, only the code directly around it needs to be updated.

Different pieces of such a program interact with each other through interfaces, hiding their precise implementation.

In Javascript, you can't distinguish (yet) private and public method. But it's common to put an underscore character at the start of property names to indicate that those properties are private.

Separating interface from implementation is a great idea. It is usually called encapsulation.


Methods are nothing more than properties that hold function values.

let rabbit = {};
rabbit.speak = function(line) {
  console.log(`The rabbit says '${line}'`);

rabbit.speak("I'm alive.");
// → The rabbit says 'I'm alive.'

this automatically points at the object it is called on:

function speak(line) {
  console.log(`The ${this.type} rabbit says '${line}'`);
let whiteRabbit = {type: "white", speak};
let hungryRabbit = {type: "hungry", speak};

whiteRabbit.speak("Oh my ears and whiskers, " +
                  "how late it's getting!");
// → The white rabbit says 'Oh my ears and whiskers, how
//   late it's getting!'
hungryRabbit.speak("I could use a carrot right now.");
// → The hungry rabbit says 'I could use a carrot right now.'

You can use call explicitely with the object paramater:

speak.call(hungryRabbit, "Burp!");
// → The hungry rabbit says 'Burp!'

Arrow functions are different—they do not bind their own this but can see the this binding of the scope around them:

function normalize() {
  console.log(this.coords.map(n => n / this.length));
normalize.call({coords: [0, 2, 3], length: 5});
// → [0, 0.4, 0.6]


let empty = {};
// → function toString(){…}
// → [object Object]

A prototype is another object that is used as a fallback source of properties. When an object gets a request for a property that it does not have, its prototype will be searched for the property, then the prototype’s prototype, and so on.

the great ancestral prototype, the entity behind almost all objects, Object.prototype:

console.log(Object.getPrototypeOf({}) ==
// → true
// → null

Many objects don’t directly have Object.prototype as their prototype but instead have another object that provides a different set of default properties.

console.log(Object.getPrototypeOf(Math.max) ==
// → true
console.log(Object.getPrototypeOf([]) ==
// → true

to create an object with a specific prototype:

let protoRabbit = {
  speak(line) {
    console.log(`The ${this.type} rabbit says '${line}'`);
let killerRabbit = Object.create(protoRabbit);
killerRabbit.type = "killer";
// → The killer rabbit says 'SKREEEE!'


constructor without new:

function makeRabbit(type) {
  let rabbit = Object.create(protoRabbit);
  rabbit.type = type;
  return rabbit;

constructor with new:

function Rabbit(type) {
  this.type = type;
Rabbit.prototype.speak = function(line) {
  console.log(`The ${this.type} rabbit says '${line}'`);

let weirdRabbit = new Rabbit("weird");

Constructors (all functions, in fact) automatically get a property named prototype, which by default holds a plain, empty object that derives from Object.prototype.

console.log(Object.getPrototypeOf(Rabbit) ==
// → true
console.log(Object.getPrototypeOf(weirdRabbit) ==
// → true

Class notation

After 2015, you can write:

class Rabbit {
  constructor(type) {
    this.type = type;
  speak(line) {
    console.log(`The ${this.type} rabbit says '${line}'`);

let killerRabbit = new Rabbit("killer");
let blackRabbit = new Rabbit("black");

Like function, class can be used both in statements and in expressions. When used as an expression, it doesn’t define a binding but just produces the constructor as a value.

let object = new class { getWord() { return "hello"; } };
// → hello

Overriding derived properties

Rabbit.prototype.teeth = "small";
// → small
killerRabbit.teeth = "long, sharp, and bloody";
// → long, sharp, and bloody
// → small
// → small

toString from array prototype is customized (not the default object toString):

console.log(Array.prototype.toString ==
// → false
console.log([1, 2].toString());
// → 1,2

console.log(Object.prototype.toString.call([1, 2]));
// → [object Array]


map names to ages:

let ages = {
  Boris: 39,
  Liang: 22,
  Júlia: 62

console.log(`Júlia is ${ages["Júlia"]}`);
// → Júlia is 62
console.log("Is Jack's age known?", "Jack" in ages);
// → Is Jack's age known? false
console.log("Is toString's age known?", "toString" in ages);
// → Is toString's age known? true

As an alternative to the in operator, you can use the hasOwnProperty method, which ignores the object’s prototype.

console.log({x: 1}.hasOwnProperty("x"));
// → true
console.log({x: 1}.hasOwnProperty("toString"));
// → false

If you pass null to Object.create, the resulting object will not derive from Object.prototype and can safely be used as a map.

console.log("toString" in Object.create(null));
// → false

The object Map stores a mapping and allows any type of keys.

let ages = new Map();
ages.set("Boris", 39);
ages.set("Liang", 22);
ages.set("Júlia", 62);

console.log(`Júlia is ${ages.get("Júlia")}`);
// → Júlia is 62
console.log("Is Jack's age known?", ages.has("Jack"));
// → Is Jack's age known? false
// → false

Object.keys returns only an object’s own keys, not those in the prototype.


Overiding the default toString method:

Rabbit.prototype.toString = function() {
  return `a ${this.type} rabbit`;

// → a black rabbit