Каково различие между Ранним и Поздним связыванием?

Как отметил @FelixKling, наиболее вероятным сценарием является то, что узлы, которые вы ищете, еще не существуют.

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

Аналогично, новая функциональность «Теневой DOM» развертывается в современных браузерах позволяет элементам быть частью документа, но не обрабатываться запросом document.getElementById и всеми его методами sibling (querySelector и т. д.). Это делается для инкапсуляции функциональных возможностей и, в частности, скрыть его.

Опять же, скорее всего, элемент, который вы ищете, просто (пока) в документе, и вы должны сделать, как предлагает Феликс , Тем не менее, вы также должны знать, что это все чаще является не единственной причиной того, что элемент может быть необоснованным (временно или постоянно).

76
задан 7 revs, 5 users 67% 17 November 2014 в 19:14
поделиться

4 ответа

Короткий ответ - то, что рано (или статичный) привязка относится ко времени компиляции, связывая и поздно (или динамичный), привязка относится к привязке времени выполнения (например, при использовании отражения).

57
ответ дан Christian Hagelid 24 November 2019 в 11:23
поделиться

На скомпилированных языках различие является абсолютным.

Java:

//early binding:
public create_a_foo(*args) {
 return new Foo(args)
}
my_foo = create_a_foo();

//late binding:
public create_something(Class klass, *args) {
  klass.new_instance(args)
}
my_foo = create_something(Foo);

В первом примере, компилятор может сделать все виды аккуратного материала во время компиляции. Во втором просто необходимо надеяться, что, кто бы ни использует метод, делает так ответственно. (Конечно, более новые JVMs поддерживают Class<? extends Foo> klass структура, которая может значительно снизить этот риск.)

Другое преимущество - то, что IDE могут горячая ссылка к определению класса, так как это объявляется тут же в методе. Вызов к create_something (Нечто) мог бы быть очень далеко от определения метода, и если Вы смотрите на определение метода, могло бы быть хорошо видеть реализацию.

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

16
ответ дан Pang 24 November 2019 в 11:23
поделиться

Взятый непосредственно от http://word.mvps.org/fAQs/InterDev/EarlyvsLateBinding.htm

существует два способа использовать Автоматизацию (или Автоматизацию OLE), чтобы программно управлять другим приложением.

Позднее связывание использует CreateObject, чтобы создать и инстанцировать объекта приложения, которым можно тогда управлять. Например, для создания нового экземпляра Excel с помощью позднего связывания:

 Dim oXL As Object
 Set oXL = CreateObject("Excel.Application")

, С другой стороны, для управления существующим экземпляром Excel (если бы Excel уже открыт) Вы использовали бы GetObject (независимо, используете ли Вы раннее или позднее связывание):

 Dim oXL As Object
 Set oXL = GetObject(, "Excel.Application")

Для использования раннего связывания сначала необходимо установить ссылку в проекте к приложению, которым Вы хотите управлять. В Редакторе VB любого Офисного приложения, или в самом VB, Вы делаете это путем выбора Инструментов + Ссылки и выбора приложения, которое Вы хотите от списка (например, “Microsoft Объект Excel 8.0 Library”).

Для создания нового экземпляра Excel с помощью раннего связывания:

 Dim oXL As Excel.Application
 Set oXL = New Excel.Application

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

6
ответ дан Jeff Mercado 24 November 2019 в 11:23
поделиться

На интерпретируемых языках различие является немного более тонким.

Ruby:

# early binding:
def create_a_foo(*args)
  Foo.new(*args)
end
my_foo = create_a_foo

# late binding:
def create_something(klass, *args)
  klass.new(*args)
end
my_foo = create_something(Foo)

, поскольку Ruby (обычно) не компилируется, нет компилятора, чтобы сделать, острота заранее наполняет. Рост JRuby означает, что больше Ruby компилируется в эти дни, тем не менее, заставляя его действовать больше как Java, выше.

проблема с IDE все еще стоит: платформа как Eclipse может искать определения классов, если Вы, твердый код их, но не может, если Вы оставляете их до вызывающей стороны.

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

3
ответ дан James A. Rosen 24 November 2019 в 11:23
поделиться
Другие вопросы по тегам:

Похожие вопросы: