JavaScript - Создание объектов. Прототипы и наследование

Статья, в которой познакомимся с понятием объекта и прототипа. Рассмотрим, как осуществляется наследование в JavaScript и создание собственных объектов. Разберём массив объектов и приёмы работы с ним.

Объект и его литеральный способ создания

В JavaScript содержится 8 различных типов данных. Семь из которых являются «примитивными». Они используются для хранения одного значения.

Объект в отличие от них является «составным» значением. Он объединяет в себя коллекцию значений (свойств и методов).

Создавать объекты в JavaScript можно разными способами. Одним из них является использование литерала объекта, т.е. фигурных скобок {...}.

Литерал объекта – это один из самых простых способов создания объектов в JavaScript. Обычно он используется, когда необходимо создать только один объект.

Синтаксис:

{
  // свойства
  свойство_1: значение_1,
  свойство_2: значение_2,
  ...,
  // методы
  // «старый» синтаксис
  метод_1: function() { ... },
  // «новый» синтаксис
  метод_2() { ... },
  ...
}

В объекте имя свойства отделяется от его значения посредством двоеточия.

Например, создадим объект point, состоящий из двух свойств и одного метода:

const point = {
  x: 5,
  y: 8,
  getCoordinates() {
    return `(${this.x}, ${this.y})`
  }
}

В этом объекте x и y – это свойства, а getCoordinates – метод.

Кстати создать метод можно также ещё с использованием ключевого слова function:

const point = {
  ...
  getCoordinates: function() {
    return `(${this.x}, ${this.y})`
  }
}

Свойства – это практически тоже самое что и переменные, но в составе объекта. Обращение к ним выполняется через точку или посредством квадратных скобок.

Например, получим значения свойств x и y:

// через точку
const coorX = point.x;
// через квадратные скобки (имя свойства в этом случае нужно заключать в кавычки (в формате строки))
const coorY = point['y'];

Но свойства можно не только получить, но и присвоить им новые значения:

point.x = 10;
point['y'] = 20;

Добавление свойства к объекту:

point.z = 35; // добавления свойства z к объекту point и присвоения ему в качестве значения числа 35

В качестве значений свойств объектов можно использовать любой тип данных, в том числе и объекты (ссылочный тип данных).

Удаление свойства у объекта осуществляется с помощью оператора delete:

delete point.z

Проверить есть ли свойство у объекта можно с помощью оператора in:

'z' in point; // проверить наличие свойства 'z' в объекте point

Методы можно сравнить с функциями. Они, как функции используются для выполнения каких-либо действий, но уже в контексте этого объекта.

Обращение к методам осуществляется также как к свойствам:

// получим ссылку на метод без его выполнения
const getCoords = point.getCoordinates;
// вызовем метод getCoordinates и сохраним результат, который он возвращает в coords
const coords = point.getCoordinates();
// выведем значение coords в консоль
console.log(coords);

К методу getCoordinates можно также обратиться через []:

// получим ссылку на метод без его выполнения
const getCoords = point['getCoordinates'];
// обратимся к методу getCoordinates объекта point и вызовем его
const coords = point['getCoordinates']();
//

Вызов метода выполняется также как функция, т.е. с использованием круглых скобок.

Имена свойств в JavaScript являются строками. Но их можно указывать без кавычек, как мы это сделали в примере выше. Но, только, когда они составлены по правилам именования переменных.

Если свойство составлено не по правилам, то в этом случае его обязательно нужно заключать в кавычки. Кроме этого не рекомендуется использовать в качестве названия свойств зарезервированные слова JavaScript.

Например:

const someObj = {
  '': 1, // имя свойства - пустая строка
  'name author': 'Алексей', // имя свойства, в котором используется пробел
}

Обращение к свойству или методу с помощью квадратных скобок обычно используется, когда название свойства находится в переменной.

const nameProp = 'x';
point[nameProp];

Кроме этого использование квадратных скобок является единственным способом доступом к свойствам объекта, когда их имена составлены не по правилам именования переменных.

Например, обратиться к свойству, имя которого представляет пустую строку можно только с помощью []:

const value = someObj[''];

Объекты в программировании сходны объектам реальной жизни.

В качестве примера рассмотрим объект реальной жизни «Фонарик». Фонарик, как и любой другой объект, имеет свойства. Свойства объекта – это его характеристики, например, материал корпуса, источник питания, длина и др. Т.е. это всё что можно описать с помощью существительных и прилагательных. Кроме свойств у объектов есть ещё действия (методы). Например, его можно включить и выключить. Некоторые методы, как например эти, предназначены для изменения состояния объекта. В общем, к действиям (методам) объекта относят обычно всё, что можно обозначить посредством глаголов.

Прототипы и наследование

В JavaScript каждый объект кроме свойств и методов имеет ещё внутреннюю ссылку (__proto__). Данная ссылка определяет связанный с данным объектом прототип. Прототип – это некоторый объект (отличный от данного) или же null.

Если прототипом является null, то это означает, что данный объект не имеет прототипа.

В результате того, что в JavaScript каждый объект имеет прототип, между ними (объектами) образовываются соответствующие связи. Например, если взять некоторый объект, то от него посредством этой связи можно перейти к его прототипу, а от него к его прототипу и так далее до конца цепочки. Цепочка заканчивается тогда, когда прототипом является null. Данную цепочку ещё называют цепочкой прототипов.

Прототипы используются в JavaScript для организации наследования.

Например, когда необходимо получить доступ к некоторому свойству объекта интерпретатор JavaScript сначала ищет его в этом объекте. Если данного свойства в нём нет, то он переходит к прототипу и пытается найти его там. Если его там нет, то он пытается найти его в прототипе этого прототипа и так далее пока это свойство не найдётся или не завершится цепочка прототипов этого объекта. Если свойство не будет найдено, то будет возвращено значение undefined.

Кстати, наследование, основанное на прототипах - это единственный тип наследования, который есть в JavaScript.

В JavaScript нет классов, которые есть в языках с класс-ориентированным подходом (С++, PHP, C# и др.). В JavaScript класс - это чисто условное понятие, под которым понимают прототип, свойства которого наследуется одним или множеством объектов.

Как организовано наследование стандартных объектов

В JavaScript всё (функции, массивы, регулярные выражения и т.д.) является объектами за исключением шести примитивных типов данных (string, number, boolean, null, undefined, symbol). Все объекты в JavaScript имеют в самой верхней точке прототипной цепи наследования Object.prototype. Объект Object.prototype не имеет прототипа.

// попробуем получить прототип объекта Object.prototype с помощью метода getPrototypeOf
Object.getPrototypeOf(Object.prototype); // null
// попробуем получить прототип объекта Object.prototype с помощью свойства __proto__
Object.prototype.__proto__; // null

Object.prototype имеет в качестве конструктора функцию Object.

// получим конструктор объекта Object.prototype
Object.prototype.constructor; // ƒ Object() { [native code] }

Конструктор (функция-конструктор) – это функция, посредством которой в JavaScript можно создавать объекты. Функция-конструктор вызывается с использованием ключевого слова new. Чтобы данную функцию можно было отличить от обычной функции, ей назначают имя, начинающееся с большой буквы.

При создании объектов с помощью функции-конструктора JavaScript добавляет к функции свойство prototype. Свойство prototype функции-конструктора – это объект, который будет являться прототипом, для каждого объекта, создаваемого с помощью этой функции-конструктора.

В тоже время объект (свойство prototype функции-конструктора) имеет свойство constructor по умолчанию. Свойство constructor указывает на функцию-конструктор, для которой объект является свойством prototype.

Теперь рассмотрим, как в JavaScript организован некоторый тип данных (стандартный объект), например дата.

Создание даты (объект типа Date) осуществляется с помощью функции-конструктора Date.

// присвоение переменной nowDate текущей даты (ссылки на объект типа Date)
var nowDate = new Date();

Дата, хранящаяся в переменной nowDate, имеет в качестве прототипа объект Date.prototype. А объект Date.prototype имеет в качестве прототипа Object.prototype.

В результате созданный объект типа Date, ссылка на который присвоена переменной nowDate, имеет доступ к методам getDate, getHours, isPrototypeOf и др. Всех этих методов нет в текущем объекте, но они доступны в нём из-за наследования.

Методы getDate и getHours находятся в прототипе Date.prototype, а метод isPrototypeOf – в Object.prototype.

Создание объектов

Кроме литерала объекты в JavaScript можно создать также ещё другими способами. Среди них:

• Object.create;
• функции-конструктора;
• ключевого слова class.

Создание объекта с использованием функции-конструктора

Ещё один способ создания объектов в JavaScript заключается в использовании функции-конструктора. Данный способ отличается от других тем, что он позволяет очень просто создавать при необходимости множество однотипных объектов.

В JavaScript принято имя функции-конструктора начинать с прописной буквы. Это рекомендуемая условность позволяет отличить функцию-конструктора от обычной функции.

Вызов функции-конструктора осуществляется через оператор new.

// функция-конструктор Point
function Point(x,y) {
  this.x = x;
  this.y = y;
}
// создание объекта point1 через функцию-конструктор Point
var point1 = new Point(10,40);
// создание объекта point2 через функцию-конструктор Point
var point2 = new Point(30, 30);

В функции-конструкторе ключевое слово this указывает на создаваемый новый объект.

В JavaScript имеется встроенная функция-конструктор Object. Данная функция позволяет создать пустой объект, который будет иметь в качестве прототипа стандартный прототип объекта Object.prototype.

К сведению, благодаря этому стандартному прототипу, у пустого объекта будут доступны такие стандартные методы как toString, valueOf и др.

// создадим новый пустой объект flashLight
var flashLight = new Object();
// добавим к нему 3 свойства
flashLight.material = 'Алюминий';
flashLight.sourcePower = '2 батарейки AA';
flashLight.length = 13.5;
// добавим к нему 2 метода
flashLight.turnOn = function(){}
flashLight.turnOff = function(){}

При вызове функции-конструктора без аргументов скобки можно не указывать. Это разрешение стандартом, но делать так не рекомендуется.

// НЕ РЕКОМЕНДУЕТСЯ
var flashLight = new Object;
...

Ещё пример создания объектов через функцию-конструктор:

// функция-конструктор Circle
function Circle(selector, x, y, r, color) {
  this.selector = selector;
  this.x = x;
  this.y = y;
  this.r = r;
  this.color = color;
  this.setStyles = function(){
    var element = document.querySelector(this.selector);
    element.style.position = 'fixed';
    element.style.left = (this.x - this.r) + 'px';
    element.style.top = (this.y - this.r) + 'px';
    element.style.width = this.r + 'px';
    element.style.height = this.r + 'px';
    element.style.borderRadius = this.r + 'px';
    element.style.backgroundColor = this.color;
  }
}

// создание объекта circle1 через функцию-конструктор Circle
var circle1 = new Circle('#circle-1', 200, 200, 100, 'darkblue');
// вызов метода setStyles объекта circle1
circle1.setStyles();

// создание объекта circle1 через функцию-конструктор Circle
var circle2 = new Circle('#circle-2', 300, 300, 50, 'gray');
// вызов метода setStyles объекта circle2
circle2.setStyles();

При создании объектов через функцию-конструктор можно использовать локальные переменные и функции. Эти переменные и функции будут видны только внутри объекта, и не будут доступны вне его.

function Point(x, y) {
  // локальные переменные x и y
  var
    _x = x,
    _y = y;
  // методы объекта
  this.setX = function (x) {
    _x = x;
  }
  this.getX = function () {
    return _x;
  }
  this.setY = function (y) {
    _y = y;
  }
  this.getY = function () {
    return _y;
  }
}
// создание объекта point1
var point1 = new Point(11, 18);
// создание объекта point2
var point2 = new Point(24, 36);

// к переменной _x нет доступа из вне
console.log(point1._x); //undefined
// получить значение переменной _x можно с помощью метода getX
console.log(point1.getX()); //11
// установить значение переменной _x можно с помощью метода setX
point1.setX(12);

Обычно в функции-конструкторе не используется return. Функция-конструктор в качестве результата автоматически возвращает this. Но если в качестве результата функции-конструктора вернуть некоторый объект (с помощью return), то в этом случае он станет результатом, а не this.

// функция-конструктор Point
function Point(x,y) {
  this.x = x;
  this.y = y;
  return {
    r: 5
  }
}
// создание объекта point1 через функцию-конструктор Point
var point1 = new Point(10,40); // {r:5}
// у объекта point1 нет свойства x
console.log(point1.x); // undefined
// у объекта point1 нет свойства y
console.log(point1.y); // undefined
// у объекта point1 есть только свойство r
console.log(point1.r); // 5

Создать объект с использованием функции-конструктора можно сразу.

// создание объекта point с использованием функции-конструктора
var point = new function() {
  this.x = 20;
  this.y = 25;
}

Этот способ позволяет создать только один объект. Но он также применяется когда внутри функции необходимо использовать локальные переменные и функции.

Создание объекта с использованием Object.create

Object.create - это ещё один способ создания нового объекта в JavaScript. Данный способ отличается от других тем, что он позволяет указать прототип для создаваемого объекта.

В качестве прототипа можно указывать не только объект, но и специальное значение null.

Если указать null, то это будет означать, что объект не будет иметь прототипа.

// создание объекта point через Object.create
var point = Object.create(null);
// добавление свойств объекту point
point.x = 10;
point.y = 20;
// добавление метода объекту point
point.info = function(){
  return "Точка имеет координаты: x = " + this.x + "; y = " + this.y;
}

// получение значения свойства x объекта point
point.x; // 10
// установление свойству объекта point значения 15
point.y = 15;
// вызов метода info объекта point
point.info(); // "Точка имеет координаты: x = 10; y = 15"
// получим прототип объекта
Object.getPrototypeOf(point); // null

// создание объекта product через литерал объекта
var product = {
  id: '045332236',
  name: 'Danesi Doppio кофе в зернах, 2 кг',
  description: 'Элитный итальянский эспрессо, появившийся более ста лет назад. Секрет его популярности кроется в использовании самого отборного сырья, стабильном качестве, деликатной обжарке кофейных зерен.',
  price: 7943.00,
  discount: 5,
  currency: 'руб.',
  discountPrice: function () {
    return (this.price * (1 - this.discount / 100)).toFixed(2);
  }
}

// создание объекта book через Object.create (прототипом создаваемого объекта является объект product)
var book = Object.create(product);
// установление свойств
book.id = '141805815';
book.name = 'Краткая история времени';
book.description = 'В книге рассказывается о появлении Вселенной, о природе пространства и времени, чёрных дырах, теории суперструн и о некоторых математических проблемах.';
book.price = 611.00;
book.isbn = 9785171022846;
book.author = 'Стивен Хокинг';
book.totalPages = 232;
// получение свойства discount
book.discount; // 5 (величина скидки в процентах)
// вызов метода discountPrice объекта book
book.discountPrice(); // "580.45" (цена с учётом скидки)

// new Object - создаём новый пустой объект
var flashLight = Object.create(null);
// осталось заполнить его свойствами
flashLight.material = 'Алюминий';
flashLight.sourcePower = '2 батарейки AA';
flashLight.length = 13.5;
flashLight.turnOn = function(){}
flashLight.turnOff = function(){}

Создание объектов посредством ключевого слова class

Классы в JavaScript появились, начиная с ECMAScript 2015 (ES6). Представляют они собой просто специальные функции, предназначенные для более простого создания объектов и организации существующего в языке прототипного наследования. Классы не представляют собой новую объектно-ориентированную модель, это просто синтаксический сахар, предназначенный упростить конструирование объектов.

Более просто представить себе класс можно как форму или шаблон, на основании которого создаются объекты. А объект как экземпляр, созданный по этому шаблону и имеющий в соответствии с ним определенные свойства и методы.

Создание классов выполняется с помощью ключевого слова class, после которого указывают его название (имя). Содержимое класса, т.е. его тело, указывается в фигурных скобках.

Синтаксис класса:

class НазваниеКласса {
  constructor
  methods
}

• constructor - это особый метод (конструктор), в котором описываются свойства и методы, которые будут иметь непосредственно каждый экземпляр объекта, созданный на базе этого класса.
• methods – это секция для описания методов, которые должны находиться не в самих объектах, созданных на основе этого класса, а в их прототипе (т.е. в объекте НазваниеКласса.prototype).

Пример создания класса:

class Point {
  // конструктор объекта (параметры x и у по умолчанию будут иметь значение 0)
  constructor(x = 0, y = 0) {
    this.x = x;
    this.y = y;
  }
  // метод, который будет добавлен к прототипу объекта, т.е. к Point.prototype
  getInfo() {
    return 'Координаты точки: (' + this.x + ', ' + this.y + ')';
  }
}

// создаём объект на базе класса Point
var point_1 = new Point(5, 17);
// создаём ещё один объект на базе класса Point
var point_2 = new Point(14, 8);
// вызовем метод getInfo для объектов point_1 и point_2
console.log(point_1.getInfo());
console.log(point_2.getInfo());

// Проверим является ли класс Point функцией?
console.log(typeof Point); // function
// Содержит ли переменная point_1 объект, а точнее ссылку на него?
console.log(typeof point_1); // object
// Является ли point_1 представителем класса Point?
console.log(point_1 instanceof Point); // true

Создание объектов выполняется с помощью ключевого слова new и названия класса. В круглых скобках при необходимости указываются аргументы, которые может использовать constructor при создании объекта. Ключевое слово this в классе указывает на создаваемый (новый) объект. В классе может находиться только один конструктор. Если в классе не указать конструктор, то JavaScript создаст его автоматически.

Статические свойства и методы

Статические свойства – это свойства, которые принадлежат самому классу, а не объектам, созданным на его основе. Они обычно переменяются для хранения различной вспомогательной информации.

Создание статических свойств выполняется после создания класса. Осуществляется это посредством добавления к нему свойства. Это возможность существует благодаря тому, что функции в JavaScript – это объекты.

class Point {
  constructor(x = 0, y = 0) {
    this.x = x;
    this.y = y;
    Point.count++;
  }
}
// добавление статического свойства count классу Point и присвоение ему значения 0
Point.count = 0;

var point_1 = new Point(3, 6);
var point_2 = new Point(1, 5);

// выводим в консоль значение статического свойства count класса Point
console.log('Количество точек: ' + Point.count); // Количество точек: 2

Статические методы – это методы, которые принадлежат самому классу, а не объектам, созданным на его основе. Они обычно используются для создания различных вспомогательных функций. Добавление в класс статического метода выполняется с использованием ключевого слова static.

class Point {
  constructor(x = 0, y = 0) {
    this.x = x;
    this.y = y;
  }
  // статический метод для вычисления расстояния между 2 точками
  static distance(p1, p2) {
    return Math.hypot(p1.x - p2.x, p1.y - p2.y);
  }
}

var point_1 = new Point(5, 2);
var point_2 = new Point(3, 2);

// выводим в консоль результат вызова статического метода distance класса Point
console.log('Расстояние между точками: ' + Point.distance(point_1, point_2));

Массив объектов и приёмы работы с ним

Массив объектов - это массив, элементами которого являются объекты.

Пример создания массива, имеющего в качестве элементов объекты:

var arrHeaders = [
  {
    tag: "H2",
    id: "page-1",
    text: "Заголовок 1"
  },
  {
    tag: "H2",
    id: "page-2",
    text: "Заголовок 2"
  }
]

Добавление к массиву, приведённому выше ещё одного объекта:

arrHeaders.push(
  {
    tag: "H2",
    id: "page-3",
    text: "Заголовок 3"
  }
);

Пример динамического создания массива объектов:

// переменная в которую поместим массив объектов
var arrHeaders = [];
// переберём заголовки h1, h2, h3 и h4 на странице и сформируем из них массив объектов
document.querySelectorAll('h1, h2, h3, h4').forEach(function(item) {
  arrHeaders.push({
    tag: item.tagName,
    id: item.id,
    text: item.textContent
  })
});
// выведем массив, содержащий объекты в консоль
console.log(arrHeaders);

Пример, в котором показано как можно организовать поиск в массиве объектов.

// array - массив содержащий объекты
// property - свойство массива
// value - искомое значение
function findObjectInArray(array, property, value) {
  var result;
  array.forEach(function(item, index){
    if (item[property] === value) {
      result = item;
      return;
    }
  });
  return result; // в качестве результата возвращает первый найденный объект или значение undefined
}

// например, найдём объект в массиве по свойству text, значения которого равно "Заголовок 2"
var findObject = findObjectInArray(arrHeaders, 'text', 'Заголовок 2'); // найденный индекс

if (findObject) {
  console.log(findObject);
} else {
  console.log('Объект не найден!');
}

Ещё один вариант выполнения поиска в массиве объектов (с использованием метода find):

// value - значение элемента
// index - индекс элемента
// array - массив
function checkHeaderText(value, index, array) {
  if (value.id === "page-3") {
    return true; // прекращает выполнение и возвращает указанный элемент
  }
}

// например, найдём объект в массиве по свойству id, значения которого равно "page-3"
var findObj = arrHeaders.find(checkHeaderText);

if (findObj) {
  console.log(findObj);
} else {
  console.log('Объект не найден!');
}

Пример кода, в котором показано как можно выполнить сортировку массива объектов (в данном случае arrArticles по полю title).

var arrArticles = [
  {
    href: "/article7",
    title: "Статья 7",
    likes: 15,
    comments: 5
  },
  {
    href: "/article1",
    title: "Статья 1",
    likes: 15,
    comments: 17
  },
  {
    href: "/article5",
    title: "Статья 5",
    likes: 3,
    comments: 10
  },
  {
    href: "/article3",
    title: "Статья 3",
    likes: 20,
    comments: 2
  }
]

function compareTitle(articleA, articleB) {
  if (articleA.title < articleB.title)
    return -1;
  if (articleA.title > articleB.title)
    return 1;
  return 0;
}

arrArticles.sort(compareTitle);

console.log(arrArticles);

Этот способ заключается в создании собственной функции сравнения и указания её в качестве параметра методу sort.

Пример кода, в котором показано как можно создать функцию сравнения для сортировки массива объектов по нескольким полям:

// функция сравнения для сортировки массива объектов сначала по свойству likes, а затем по comments
function compareLikesComments(articleA, articleB) {
  if ((articleA.likes > articleB.likes) || (articleA.likes === articleB.likes && articleA.comments > articleB.comments)) {
    return -1;
  } else if ((articleA.likes < articleB.title) || (articleA.likes === articleB.likes && articleA.comments < articleB.comments)) {
    return 1;
  }
  return 0;
}

arrArticles.sort(compareLikesComments);

Пример, в котором показан способ удаления объекта из массива по его индексу:

// массив объектов
var points = [
  {x: 5, y: 7},
  {x: -2, y: 9},
  {x: 0, y: 8},
  {x: -1, y: -3}
];

// поиск объекта в массиве по x и y
var findIndex =  function(x, y) {
  return points.findIndex(function(value, index, array){
    if (value.x === x && value.y === y) {
      return true;
    }
  })
};

// получения индекса (если объект не будет найден, то будет возвращено значение -1)
var result = findIndex(-2, 9);
if (result >= 0) {
  points.splice(result, 1); // удаляем объект из массива по его индексу
}
// выводим полученный массив объектов в консоль
console.log(points);

Пример, в котором показано несколько способов того, как можно удалить множество объектов из массива в JavaScript:

var points = [
  {x: 5, y: 7},
  {x: -2, y: 9},
  {x: 0, y: 8},
  {x: -1, y: -3}
];

// Задача: удалить из массива все объекты, у которых хотя бы одно из значений x или y меньше нуля

// 1 способ - посредством перебора (с использованием метода splice)
var i = points.length - 1;

while (i >= 0) {
  if (points[i].x < 0 || points[i].y > 0) {
    points.splice(i, 1);
  }
  i--;
}
console.log(points);

// 2 способ - с использованием метода filter
var filtered = points.filter(function(value, index, array){
  return value.x >= 0 && value.y >= 0;
});
console.log(filtered);

Как преобразовать объект в массив

Пример, в котором рассмотрим как в JavaScript можно преобразовать объект в массив.

// объект
var obj = {
  'key1': 'value1',
  'key2': 'value2',
  'key3': 'value3'
};
/* задача. преобразовать данный объект в массив:
[
  ['key1', 'value1'],
  ['key2', 'value2'],
  ['key3', 'value3']
};
*/

var arr = Object.entries(obj);

Как проверить является ли объект пустым

Несколько решений как можно проверить объект на пустоту:

// 1 способ
var isEmptyObject = function (obj) {
  var prop;
  for (prop in obj) {
    if(obj.hasOwnProperty(prop))
      return false;
    }
  return true;
}
// 2 способ (ECMAScript 5+)
var isEmptyObject2 = function (obj) {
  return Object.keys(obj).length === 0 && obj.constructor === Object;
}

var obj1 = {x: 5, y: 7};
var obj2 = {};

isEmptyObject(obj1); //false
isEmptyObject2(obj1); //false

isEmptyObject(obj2); //true
isEmptyObject2(obj2); //true

Инструкция с использованием функции isEmptyObject "если пришел пустой объект javascript" будет выглядеть так:

var obj = {};

// если пришёл пустой объект
if (isEmptyObject(obj)) {
  // инструкции которые будут выполнены если объект пустой
} else {
  // инструкции которые будут выполнены если объект не пустой
}