Преобразование в позднюю привязку [дубликат]

Вопрос был:

Как вернуть ответ от асинхронного вызова?

, который может быть интерпретирован как:

Как сделать синхронный асинхронный код синхронным?

Решение будет состоять в том, чтобы избежать обратных вызовов и использовать комбинацию Promises и async / await.

Я хотел бы привести пример для запроса Ajax.

(Хотя он может быть записан в Javascript, я предпочитаю писать его на Python и компилировать его в Javascript, используя Transcrypt . Это будет достаточно ясно.)

Позволяет сначала включить использование JQuery, чтобы $ был доступен как S:

__pragma__ ('alias', 'S', '$')

Определить функцию, которая возвращает Promise, в этом случае вызов Ajax:

def read(url: str):
    deferred = S.Deferred()
    S.ajax({'type': "POST", 'url': url, 'data': { },
        'success': lambda d: deferred.resolve(d),
        'error': lambda e: deferred.reject(e)
    })
    return deferred.promise()

Использовать асинхронный код, как если бы он был синхронным:

async def readALot():
    try:
        result1 = await read("url_1")
        result2 = await read("url_2")
    except Exception:
        console.warn("Reading a lot failed")

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

7 ответов

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

53
ответ дан Christian Hagelid 24 August 2018 в 07:57
поделиться
public class child()
{    public void method1()
     {     System.out.println("child1");
     }
    public void method2()
     {     System.out.println("child2");
     }

}
public class teenager extends child()
{    public void method3()
     {      System.out.println("teenager3");
     }
}
public class adult extends teenager()
{     
    public void method1()
    {    System.out.println("adult1);
         super.method1();
     }
}


//In java
public static void main(String []args)
{    ((teenager)var).method1();
}

Это выведет

adult1
child1

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

Следовательно метод method1 (от дочернего раннего связывания) будет переопределен методом1 от взрослого во время выполнения (поздняя привязка). Затем он будет реализовывать метод1 из дочернего элемента, поскольку нет метода1 в методе 1 в подростковом возрасте.

Обратите внимание, что если у ребенка не было метода1, тогда код в основном не компилировался.

0
ответ дан 2 revs, 2 users 82% 24 August 2018 в 07:57
поделиться

Полиморфизм времени компиляции также называется перегрузкой или ранним связыванием или статическим связыванием, когда у нас есть одно и то же имя метода с различным поведением. Реализуя множественный прототип того же метода, и в нем происходит различное поведение. Раннее связывание означает первую компиляцию программы. Но в последнем объекте привязки в программе происходит время выполнения. Также называется динамическим связыванием или переопределением или политипом времени выполнения.

0
ответ дан Ghousepeer 24 August 2018 в 07:57
поделиться

В интерпретируемых языках разница немного более тонкая.

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, вероятно, из-за ее экстремальной гибкости во время выполнения, но Rails отлично использует позднюю привязку чтобы уменьшить объем конфигурации, необходимый для получения вашего приложения.

3
ответ дан James A. Rosen 24 August 2018 в 07:57
поделиться

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

Существует два способа использования Automation (или OLE Automation) для программного управления другим приложением.

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

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

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

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

Чтобы использовать раннее связывание, вам сначала нужно установить ссылку в своем проекте на приложение, которое вы хотите манипулировать. В редакторе VB любого приложения Office или в самом VB вы делаете это, выбирая «Инструменты + ссылки» и выбрав нужное приложение из списка (например, «Библиотека объектов Microsoft Excel 8.0»).

Чтобы создать новый экземпляр Excel с использованием раннего связывания:

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

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

6
ответ дан Jeff Mercado 24 August 2018 в 07:57
поделиться

Подобный, но более подробный ответ из книги Гербара Шильдта C ++: -

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

Противоположность раннему связыванию является поздним связыванием. Позднее привязка относится к вызовам функций, которые не разрешаются до времени выполнения. Виртуальные функции используются для достижения позднего связывания. Как вы знаете, когда доступ осуществляется через базовый указатель или ссылку, фактически вызываемая виртуальная функция определяется типом объекта, на который указывает указатель. Поскольку в большинстве случаев это невозможно определить во время компиляции, объект и функция не связаны до времени выполнения. Основным преимуществом позднего связывания является гибкость. В отличие от раннего связывания, поздняя привязка позволяет создавать программы, которые могут реагировать на события, возникающие во время выполнения программы, не создавая большого количества «кода на случай непредвиденных обстоятельств». Имейте в виду, что, поскольку вызов функции не разрешен до времени выполнения, последнее связывание может привести к более медленному времени выполнения. Однако сегодня быстрые компьютеры значительно сократили время выполнения, связанное с поздним связыванием.

4
ответ дан Pancuz Kumar 24 August 2018 в 07:57
поделиться

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

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);

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

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

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

15
ответ дан Pang 24 August 2018 в 07:57
поделиться
Другие вопросы по тегам:

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