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

Знание о том, наличие каких функций надо проверять, где будет сосредоточено?

Сосредоточить в таком виде

function IDisposable()
{
this.Dispose = function() {};
}

function isImplemented(classType, interfaceType)
{
// и тут бегаем по членам interfaceType проверяя есть ли они в classType
}

Понятно, т.е. отдельный объект под "интерфейс". Кстати, а сигнатуры методов проверятся будут? Если да, то как?

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

Понятно, но соглашения-то какие-то, по кол-ву аргументов, например, можно было бы ввести? Если уж мы таки пришли к реализации "интерфейсов". Вот я и уточняю

Мы не пришли к реализации "интерфейсов". Лично я пытаюсь максимально увести вас от них :)

Ставлю на Kolyaj!:yes:

B~Vladi,
давайте подождем. Так хочется увидеть реализацию интерфейсов в js (-:

Пришли к обсуждению их реализации. Не придирайтесь к словам

Потому что бесполезно или потому что вредно? Агрументируйте, плиз.
Аргументы в пользу я так понимаю были отброшены как не значимые?

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

Читайте чужой код на JavaScript. Посмотрите как реализованы известные фреймворки, ExtJS, например. JQuery не смотрите, там чёрт ногу сломит.

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

второй аргумент (вроде больше нету), насколько я понял - головные боли. И опять же я не вижу другой причины, кроме как ломка от перехода на динамический язык программирования. Вы предлагаете сделать язык менее гибким ради решения несуществующей проблемы

но если вы знаете задачи, в которых нужны интерфейсы (в контексте js)... я всегда открыт для новых знаний ;)

а про typeof мне приходит в голову только выполнение разных действий в зависимости от типа аргументов

function $( id ){
    return   typeof id == 'string'   ? document.getElementById(id)   : id;
}

в конце концов присутствие чего-либо в языке ничего не означает. Вспомнить хотя бы The Good Parts Дугласа Крокфорда

Так как js - язык слабо типизированный, то необходим инструмент для определения типа конкретного объекта. Для этих целей и существуют операторы typeof и instanceof.

Первый оператор позволяет отличить примитивные типы от объектов. Второй - чтобы отличить один тип объекта от другого.

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

kidar2,
sysif,
Решает ли этот код проблему отсутствия интерфейсов?

Источник - http://javascript.ru/forum/66098-post2.html

Object.mixin = function(dst /*, arg1, arg2... */)
{
	for (var i = 1; i < arguments.length; i++) {
		for (var prop in arguments[i]) {
			if ( arguments[i].hasOwnProperty(prop) ) {
				dst[prop] = arguments[i][prop];
			}
		}
	}
	return dst;
}

Function.prototype.inherit = function(proto)
{
	var that = this;
	proto = proto || {};
	var constructor = proto.hasOwnProperty('constructor') ? proto.constructor : function() { that.apply(this, arguments); };
	var F = function() {};
	F.prototype = this.prototype;

	// Оригинальная строка источника
	//constructor.prototype = mixin(new F(), proto);

	var dst = Object.mixin(new F(), proto);

	for (var i = 1; i < arguments.length; i++) {
		if ( ! arguments[i] ) {
			continue;
		}
		for (var p in arguments[i].prototype) {
			if ( ! arguments[i].prototype.hasOwnProperty(p) ) {
				continue;
			}
			if ( typeof arguments[i].prototype[p] == 'function' && typeof dst[p] != 'function' ) {
				throw new ReferenceError('"' + p + '" method is not implemented');
			}
		}
	}

	constructor.prototype = dst;

	constructor.superclass = this.prototype;
	constructor.prototype.constructor = constructor;
	return constructor;
};

// Глобальный интерфейс - родитель всех остальных интерфейсов
var Interface = Object.inherit({
	constructor: function()
	{
		throw new ReferenceError('An object could not be instantiated from an interface');
	}
});

// Интерфейс - Перемещаемые объекты
var IMovable = Interface.inherit({
	move: function() {}
});

// интерфейс - Рисуемые объекты
var IDrawable = Interface.inherit({
	draw: function() {}
});

// Класс Точка
// реализует интерфейсы Перемещаемые, Рисуемые
// но не реализует все методы интерфейсов
// поэтому будет брошено исключение
var Point = Object.inherit({
	constructor: function(x, y)
	{
		this.x = x;
		this.y = y;
	}, 
	draw: function()
	{
		alert('Point at [' + this.x + ', ' + this.y + ']');
	}
}, IMovable, IDrawable);

// Этот код не будет выполнен пока 
// 1. не будет реализован метод "move" или 
// 2. не будет исключен интерфейс Перемещаемые из цепочки наследования
var obj = new Point(1, 1);
obj.draw();

а что, действительно похоже, объемно только...;)

Какая старая статья... И всё же хочется кое-что сказать.
Во-первых JavaScript не класс-ориентированный язык программирования а прототипный (что это значит можно почитать на вики) и соответственно практики из класс-ориентированного ООП в принципе не совсем для него подходят, хотя если вам нужен некий аналог интерфейса, то могу предложить следующее решение:

// интерфейс
var interfaceA = {
  methodA: methodForMatchAPlusB,
  methodB: methodForMatchAMinusB,
  methodC: methodC
};

// основной код
console.info('a + b = %d', interfaceA.methodA(1, 2));
console.info('a - b = %d', interfaceA.methodB(7, 5));
interfaceA.methodC(7, 4);

//объявление функций
function methodForMatchAPlusB(a, b) {
  return a+b;
}

function methodForMatchAMinusB(a, b) {
  return a - b;
}

function methodC(a, b) {
  var result = interfaceA.methodA(a, b) * interfaceA.methodB(a, b);
  console.info('(a+b)*(a-b) = %d', result);
}

Или можно тоже самое оформить ещё лучше:

var objectA = new function() {
  // интерфейс
  this.methodA = methodForMatchAPlusB;
  this.methodB = methodForMatchAMinusB;
  this.methodC = methodC;


  //объявление функций
  function methodForMatchAPlusB(a, b) {
    return a+b;
  }

  function methodForMatchAMinusB(a, b) {
    return a - b;
  }

  function methodC(a, b) {
    var result = objectA.methodA(a, b) * objectA.methodB(a, b);
    console.info('(a+b)*(a-b) = %d', result);
  }
};


// основной код (возможно уже в другом файле)
console.info('a + b = %d', objectA.methodA(1, 2));
console.info('a - b = %d', objectA.methodB(7, 5));
objectA.methodC(7, 4);

В чем заключается "проблема" отсутствия ынтырфейсов? Покажи задачу, которую с ынтырфейсами решить проще или эффективней, чем без них.

Твой код не имеет ни малейщего смысла, с точки зрения семантики. Ты просто размазал какие-то непонятные сопли. Это то же самое, примерно, что

fu1=function(){}
fu2=function(){}
ob={a: fu1, b: fu2}

Gaito, подобный подход, с предварительными объявлениями, оправдывает себя лишь в одном случае, при построении цепочек наследования с использованием оператора with.

Operations={
  data: "",
  sum: "",
  mul: "",
  combine: function(){with(this) return sum()+mul()}
}

with(OperationsWithArray=Object.create(Operations)){
  sum=function(){return this.data.reduce(function(x, y) {return x + y})}
  mul=function(){return this.data.reduce(function(x, y) {return x * y})}
}

with(OperationsWithNumber=Object.create(Operations)){
 sum=function(){return this.data+this.data}
 mul=function(){return this.data*this.data}
}

with(Object.create(OperationsWithArray)){
 data=[1,2,3]
 console.log(combine())
}

with(Object.create(OperationsWithNumber)){
 data=3
 console.log(combine())
}

Использования with, который по сути deprecated ничего не оправдывает (http://javascript.ru/with)

EmperioAf,
Во первых, речь шла не о with как таковом, а об использовании предварительных деклараций, я тебе показал, где оно имеет смысл. Кроме этого случая, это нигде смысла не имеет, в том числе и в бредокоде, который тут выложен выше.

По поводу with. Меня не интересует, что какой-нибудь очередной вася пупкин думает по поводу его использования. Он есть в стандарте, в том числе в ES6

В модулях ES6 with запрещен (там форсится строгий режим).

Ну так не пиши в модулях, ты чо дебил штоли?

специально для вас
 

держи мой велосипед:

jsInterface - реализация идеи классических ООП интерфейсов с поправкой на динамическую природу JavaScript.
https://github.com/titulus/js-interface