Книга: JavaScript. Подробное руководство, 6-е издание

9.5.4. Грубое определение типа

9.5.4. Грубое определение типа

Ни один из приемов определения класса объекта, описанных выше, не свободен от проблем, по крайней мере, в клиентском JavaScript. Альтернативный подход состоит в том, чтобы вместо вопроса «какому классу принадлежит объект?» задать вопрос «что может делать этот объект?». Этот подход является типичным в таких языках программирования, как Python и Ruby, и носит название грубое определение типа (<duck-typing, или «утиная типизация») в честь высказывания (часто приписываемого поэту Джеймсу Уиткомбу Райли (James Whitcomb Riley)):

Когда я вижу птицу, которая ходит, как утка, плавает, как утка и крякает, как утка, я называю ее уткой.

Для программистов на языке JavaScript этот афоризм можно интерпретировать так: «Если объект может ходить, плавать и крякать как объект класса Duck, его можно считать объектом класса Duck, даже если он не наследует объект-прототип класса Duck».

Примером может служить класс Range из примера 9.2. Этот класс предназначен для представления диапазонов чисел. Однако обратите внимание, что конструктор Range() не проверяет типы аргументов, чтобы убедиться, что они являются числами. Аналогично метод includes() использует оператор <=, но не делает никаких предположений о типах значений границ диапазона. Благодаря тому что класс не ограничивается определенным типом значений, его метод includes() способен обрабатывать значения границ любых типов, которые могут сравниваться с помощью операторов отношения:

var lowercase = new Range("a", 'z');
var thisYear = new Range(new Date(2009, 0, 1), new Date(2010, 0, 1));

Метод foreach() класса Range также не проверяет типы значений границ, но он использует функцию Math.ceil() и оператор ++, вследствие чего может применяться только к числовым значениям границ диапазона.

В качестве еще одного примера вспомним объекты, подобных массивам, обсуждавшиеся в разделе 7.11. Во многих случаях нам не требуется знать, действительно ли объект является экземпляром класса Array: вполне достаточно знать, что он имеет свойство length с неотрицательным целочисленным значением. Если посчитать, что целочисленное свойство length - это способ массивов «ходить», то мы могли бы сказать, что любой объект, который умеет «ходить» так же, можно (во многих случаях) отнести к массивам.

Однако имейте в виду, что свойство length настоящих массивов обладает особым поведением: свойство length автоматически обновляется при добавлении нового элемента, а когда значение свойства length уменьшается, массив автоматически усекается. Можно было бы сказать, что эти две особенности описывают, как массивы «плавают» и «крякают». Если вы пишете программу, где требуется, чтобы объект «плавал» и «крякал» как массив, вы не сможете использовать в ней объект, который только «ходит» как массив.

Примеры грубого определения типа, представленные выше, опираются на возможность сравнения объектов с помощью оператора < и на особенности поведения свойства length. Однако чаще всего под грубым определением типа подразумевается проверка наличия в объекте одного или более методов. Строго типизированная функция triathlon() могла бы потребовать, чтобы ее аргумент был объектом класса TriAthlete. Альтернативная реализация, выполняющая грубую проверку типа, могла бы принимать любой объект, имеющий методы walk(), swim() и bike(). Если говорить более конкретно, можно было бы переписать класс Range так, чтобы вместо операторов < и ++ он использовал бы методы compareTo() и succ() объектов значений границ.

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

В примере 9.5 определяется функция quacks() (более подходящим было бы имя «implements» (реализует), но implements является зарезервированным словом), которая может пригодиться для грубого определения типа. Функция quacks() проверяет наличие в объекте (первый аргумент функции) методов, указанных в остальных аргументах. Для каждого последующего аргумента, если аргумент является строкой, проверяется наличие метода с этим именем. Если аргумент является объектом, проверяется наличие в первом объекте методов с теми же именами, что и во втором объекте. Если аргумент является функцией, предполагается, что она является конструктором, и в этом случае проверяется наличие в первом объекте методов с теми же именами, что и в объекте-прототипе.

Пример 9.5. Функция грубой проверки типа

// Возвращает true, если о реализует методы, определяемые последующими аргументами.
function quacks(o /*, ... */) {
for(var i=1; i<arguments.length; i++) { // для каждого аргумента после о
  var arg = arguments[i];
  switch(typeof arg) { // Если arg - это:
    case ’string': // строка: проверить наличие метода с этим именем
      if (typeof o[arg] !== "function") return false;
      continue;
    case ’function’: //функция: использовать объект-прототип
      // Если аргумент является функцией, использовать ее прототип
      arg = arg.prototype;
      // переход к следующему случаю case
    case object': // объект: проверить наличие соотв. методов
      for(var m in arg) { // Для каждого свойства объекта
        if (typeof arg[m]!=="function") continue; // Пропустить свойства,
        // не являющиеся методами
        if (typeof o[m] !== "function") return false;
      }
    }
  }
  // Если мы попали сюда, значит, объект о реализует все, что требуется
  return true;
}

Есть два важных момента, касающиеся функции quacks(), которые нужно иметь в виду. Во-первых, она просто проверяет наличие в объекте одного или более методов с заданными именами. Присутствие этих свойств ничего не говорит ни о том, что делают эти функции, ни о том, сколько и какого типа аргументы они принимают. Однако это и есть сущность грубого определения типа. Определяя интерфейс, в котором вместо строгой проверки используется прием грубого определения типа, вы получаете более гибкий прикладной интерфейс, но при этом перекладываете на пользователя всю ответственность за правильное его использование. Второй важный момент, касающийся функции quacks(), заключается в том, что она не может работать со встроенными классами. Например, нельзя выполнить проверку quacks(o, Array), чтобы убедиться, что объект о обладает всеми методами класса Array. Это обусловлено тем, что методы встроенных классов недоступны для перечисления и цикл for/in в quacks() просто не заметит их. (Следует отметить, что это ограничение можно преодолеть в ECMAScript 5 с помощью функции Object.getOwnProperty Names().)

Оглавление книги