标签: late-binding

大多数PHP IDE依靠phpdoc来获取有关表达式类型的提示.然而,我经常使用这种模式,似乎没有涵盖:

class Control {
    private $label = '';

    /** @return ??? */
    public static function Make(){ return new static(); }

    /** @return ??? */
    public function WithLabel($value){  $this->label = $value;  return $this;  }

    /** @return void */
    public function Render(){ /* ... */ }
}

class Textbox extends Control {
   private $text = '';

    /** @return ??? */
    public function WithText($text){  $this->width = $text;  return $this;  }
}

现在我可以使用这样的类:

Textbox::Make()           // <-- late static binding, returns Textbox
   ->WithLabel('foo')     // …

从5.3版开始,PHP支持静态方法的后期绑定.虽然这是一个无疑是有用的功能,但只有几种情况需要使用它(例如Active Record模式).

考虑这些例子:

1.便利施工人员(::create())

class SimpleObject
{
    public function __construct() { /* ... */ }

    public static function create()
    {
        return new static; // or: return new self;
    }
}

如果这个类可能被扩展(但是,它没有被同一个包中的任何类扩展),那么应该使用延迟静态绑定来使它更容易扩展(无需重写::create()方法,更重要的是,不必记住要做到这一点)？

注意:这个习惯用于解决在构造对象上调用方法的不可能性:new SimpleObject()->doStuff()在PHP中无效.

2.类常数

class TagMatcher
{
    const TAG_PATTERN = '/\<([a-z\-]+?)\>/i';

    private $subject;

    public function construct($subject) { $this->subject = $subject; }

    public function getAllTags()
    {
        $pattern = static::TAG_PATTERN;
        preg_match_all($pattern, $this->subject);
        return $pattern[1];
    }
}

static::在此示例中使用的原因与前一个类似.它的使用只是因为这个类可以通过扩展它并覆盖常量来匹配不同形式的标签.

那么,要将它们全部包装起来,这些后期静态绑定的使用(以及类似的)是否过度杀伤？是否有明显的性能影响？此外,频繁使用后期绑定是否会降低操作码缓存的整体性能提升？

我可以做这个:

Dim fso As New FileSystemObject

或者我可以这样做:

Dim fso As Object
Set fso = CreateObject("Scripting.FileSystemObject")

我如何知道CreateObject使用什么字符串？例如,我怎么知道使用"脚本"."Scripting.FileSystemObject"的一部分？你去哪儿看？

Python被编译成中间字节码(pyc),然后执行.所以,有一个汇编,然后是解释.但是,长期使用Python的用户认为Python是一种"后期绑定"语言,它不应该被称为解释语言.

1. Python与其他解释语言有何不同？

2. 你能告诉我在Python上下文中"后期绑定"是什么意思吗？

Java是另一种语言,它首先将源代码编译成字节码,然后解释为字节码.

1. Java是一种解释/编译语言吗？

2. 在编译/执行方面,它与Python有何不同？

3. 据说Java没有"后期绑定".这与Java程序比Python快得多吗？

如果你能给我链接到人们已经讨论过的地方,那就太棒了.我想更多地了解这一点.谢谢.

我正在使用knockout.js来显示员工列表.我在页面上有一个隐藏的模态标记.单击单个员工的"详细信息"按钮时,我希望将该员工数据绑定到模式弹出窗口.我正在使用ko.applyBindings(employee,element),但问题是当页面加载时,它期望模态从绑定到某个东西开始.

所以我想知道,有一个技巧/策略来做延迟/延迟数据绑定吗？我查看了虚拟绑定,但文档不够有用.

谢谢!

我正在编写一个开源的javascript库,我使用的.bind()方法很多,因为我知道面向对象的代码看起来更清晰.(虽然有争议)

例

A1:

var that = this;

setTimeout(function () {
    that.method();
}, 0);

VS

B1:

setTimeout(this.method.bind(this), 0);

或者,更实用的代码部分

A2:

remoteDataSource.getData(function (a, b, c, d) {
     obj.dataGetter(a, b, c, d);
})

vs B2:

remoteDataSource.getData(obj/* or prototype */.dataGetter.bind(obj));

我使用非原生bind的浏览器,一切都很完美,直到我为bind打开jsperf基准.

看起来代码使用bind速度要快100倍.现在,在重写我的所有库之前,我对那些熟悉javascript引擎的人有一个问题:

作为新功能,是否有可能bind很快得到优化,或者由于JavaScript体系结构限制而没有机会？

我正在使用Spring DI连接我的组件,我遇到了这个问题.

我有一个BaseService类,它有多个实现.它上面的层有一个构建器,它调用服务来获取数据来填充POJO.我需要调用的服务实现(ServiceA,ServiceB)根据我需要构建的POJO的类型进行更改.

在这种情况下,我如何自动装配服务,因为它需要后期绑定服务.我该如何处理这种情况？(Spring DI中的例子真有帮助)

我读了类似的问题,但找不到答案.我读到服务主机等SOA模式为确切的用例提供了不同的解决方案.

请帮忙.谢谢

我试图了解OSGi服务.我一直在问自己的主要问题是:使用服务而不是使用捆绑包及其导出的包有什么好处？

据我所知,Late Binding的概念似乎与它有关.Bundle依赖关系在bundle start处连接在一起,所以我猜它们非常固定.但随着服务似乎几乎相同.捆绑包启动并注册服务或绑定到服务.当然,服务可以随时出入,你必须跟踪这些机会.但核心理念似乎与我不同.

另一个方面似乎是服务更灵活.一个特定接口可能有许多实现.另一方面,对于特定的导出包也可以有许多不同的实现.

在另一篇文章中,我读到使用导出包的缺点是它们使应用程序比服务更脆弱.作者写道,如果从依赖图中删除一个包,则不再满足其他依赖关系,从而可能对整个图形造成多米诺骨牌效应.但是如果服务脱机会发生同样的情况吗？对我而言,服务依赖性似乎并不比bundle依赖性更好.

到目前为止,我找不到可以清楚地描述为什么服务比通过导出和导入包公开功能更好的博客文章,书籍或演示文稿.

总结一下我的问题:

使用OSGi服务使其优于导出和导入包有哪些主要好处？

加成

我试图收集有关此问题的更多信息,并在包和服务的普通导出/导入之间进行某种比较.也许这会帮助我们找到一个令人满意的答案.

1. 启动/停止/更新

   捆绑(因此包)和服务都可以启动和停止.除此之外,他们可以更新.服务也与捆绑生命周期本身有关.但在这种情况下,我只是意味着你可以启动和停止服务或捆绑(以便导出的包"消失").

2. 跟踪变化

   ServiceTracker和BundleTracker使跟踪和响应捆绑和服务可用性变化成为可能.

3. 与其他捆绑包或服务的特定依赖关系.

   如果要使用导出的包,则必须导入它.

   Import-Package: net.jens.helloworld
   

   Run Code Online (Sandbox Code Playgroud)

   将net.jens.helloworld提供服务,我还需要导入的包,以获取接口.

   因此,在这两种情况下,它们都会与某种或多或少的特定包装形成"紧密耦合".

4. 能够拥有多个实现

   特定包可以通过多个包导出.可能有一个包net.jens.twitterclient,它由bundle A和bundle B导出.这同样适用于服务.接口net.jens.twitterclient.TwitterService可以由bundle A和B发布.

总结这里的简短比较(导出包/服务):

1. 是的是的
2. 是的是的
3. 是的是的
4. 是的是的

所以没有区别.

此外,似乎服务增加了更多的复杂性并引入了另一层依赖关系(见下图).

alt text http://img688.imageshack.us/img688/4421/bundleservicecomparison.png

因此,如果导出的包和服务之间没有真正的区别,那么使用服务的好处是什么？

我的解释:

服务的使用似乎更复杂.但服务本身似乎更轻巧.如果您启动/停止整个捆绑包或者您只是启动和停止特定服务,那么它应该是(在性能和资源方面)的差异.

从架构的角度来看,我也猜测捆绑包可以被视为应用程序的基础.在启动和停止捆绑方面,基础不应经常更改.该功能由该包的服务在"捆绑层"之上的某种动态层中提供.这个"服务层"可能会经常变化.例如,如果数据库脱机,则取消注册用于查询数据库的服务.

你怎么看？我是开始得到服务的全部还是我还在想错误的方法？是否有我遗漏的东西会使服务比出口包更具吸引力？

我正在构建一个iPhone开发人员可以在他们的项目中包含的SDK.它以编译的".a"形式提供,没有源代码.我们称我的SDK为"AAA".

除了使用AAA之外,他的项目中的客户(我们称之为"BBB")也可以使用名为"CCC"的第三方库 - 它也是预编译的,闭源的.我不卖CCC,这是一家不同的公司.

我的SDK,AAA,可以选择使用CCC来改进产品,使用这些第三方功能.例如,假设CCC是用于加密某些内容的安全SDK.AAA不需要CCC,但如果客户选择在其项目中包含CCC,则会更安全.

现在这里有一个特别棘手的部分 - CCC库,是纯C代码,由C Structs和C函数组成 - 没有任何面向对象的东西.

问题是:

• 如何编译我的AAA SDK以使用来自CCC的函数/结构,而不在我的项目中包含CCC(不合法允许,并且不想跟上版本更新).
• 如何检测客户是否在其项目中具有CCC,仅在可用时使用这些额外功能？

以下测试失败:

#!/usr/bin/env python
def f(*args):
    """
    >>> t = 1, -1
    >>> f(*map(lambda i: lambda: i, t))
    [1, -1]
    >>> f(*(lambda: i for i in t)) # -> [-1, -1]
    [1, -1]
    >>> f(*[lambda: i for i in t]) # -> [-1, -1]
    [1, -1]
    """
    alist = [a() for a in args]
    print(alist)

if __name__ == '__main__':
    import doctest; doctest.testmod()

换一种说法:

>>> t = 1, -1
>>> args = []
>>> for i in t:
...   args.append(lambda: i)
... …