Question

我喜欢在C＃中编写扩展方法的方法，然后执行以下操作：

string ourString = "hello";
ourString.MyExtension("another");

甚至

"hello".MyExtention("another");

有没有办法在PHP中有类似的行为？

Answer 1

如果您将所有字符串重新实现为对象，则可以。

class MyString {
    ...
    function foo () { ... }
}

$str = new MyString('Bar');
$str->foo('baz');

但你真的不想这样做。 PHP本身并不是面向对象的语言，字符串只是原始类型，没有方法。

在没有扩展核心引擎的情况下，在PHP中无法实现'Bar'->foo('baz')语法（这不是你想要的内容，至少不是为了这个目的：）。）。

对于扩展对象的功能也没有任何意义，这使得它本身比简单地编写接受基元的新函数更好。换句话说，PHP相当于

"hello".MyExtention("another");

是

my_extension("hello", "another");

出于所有目的和目的，它具有相同的功能，只是语法不同。

Answer 2

远离PHP中非对象原语的问题，当处理PHP中的实际类时，如果你的环境是理智的，你可以装饰一个给定的类来排序^{§< / strong>}模拟扩展方法。

给定一个接口和实现：

interface FooInterface { function sayHello(); function sayWorld(); } class Foo implements FooInterface { public function sayHello() { echo 'Hello'; } public function sayWorld() { echo 'World'; } }

只要Foo上的任何依赖项实际上都依赖于接口FooInterface（这就是我理解的理智），您就可以自己实现FooInterface作为Foo的包装，必要时转发Foo，并根据需要添加其他方法：

class DecoratedFoo implements FooInterface { private $foo; public function __construct(FooInterface $foo) { $this->foo = $foo; } public function sayHello() { $this->foo->sayHello(); } public function sayWorld() { $this->foo->sayWorld(); } public function sayDanke() { echo 'Danke'; } public function sayShoen() { echo 'Shoen'; } }

方法sayHello()和sayWorld()已修补到包含Foo对象，但我们已添加sayDanke()和sayShoen()。

以下内容：

function acceptsFooInterface(FooInterface $foo) { $foo->sayHello(); $foo->sayWorld(); } $foo = new Foo(); acceptsFooInterface($foo);

按预期工作，产生HelloWorld;但这样做：

$decoratedFoo = new DecoratedFoo($foo); acceptsFooInterface($decoratedFoo); $decoratedFoo->sayDanke(); $decoratedFoo->sayShoen();

结果为HelloWorldDankeShoen。

这是装饰图案中潜力的有限用途;您可以修改已实现方法的行为，或者根本不转发它们（但是，我们希望通过此示例中的原始类定义维护预期的行为）

这是在PHP中实现扩展方法（按照C＃）的一对一解决方案吗？不，绝对不是;但这种方法所提供的可扩展性将有助于更松散地解决问题。

§想想我会根据主题的一些聊天对话进行详细说明：你永远不会复制它（不是今天，也可能不是tommorow ） PHP，但我的答案中的关键是设计模式。当您不一定（通常或曾经）端口功能时，它们提供了将策略从一种语言移植到另一种语言的机会。

Answer 3

自PHP 5.4起，有traits可用作扩展方法。

示例：

<?php
trait HelloWorld {
    public function sayHelloWorld() {
        echo 'Hello World';
    }
}

class MyHelloWorld {
    use HelloWorld;
    public function sayExclamationMark() {
        echo '!';
    }
}

$o = new MyHelloWorld();
$o->sayHelloWorld();
$o->sayExclamationMark();
?>

结果：

Hello World!

一旦你将一个特征包含在一个类中，我们可以使用名称Extension来调用它，你可以添加你想要的任何方法并在别处找到它们。然后在该示例中，use Extension变成了可扩展类的一次性装饰。

Answer 4

我在PHP＆gt; = 5.3.0中有另一个实现，它就像Northborn Design解释的装饰器一样。

我们所需要的只是一个用于创建扩展的API和一个用于应用扩展的装饰器。

我们必须记住，在C＃扩展方法上，它们不会破坏扩展对象的封装，并且它们不会修改对象（没有意义，相反，实现该方法会更有效）。扩展方法是纯静态的，它们接收对象的实例，如下例所示（C＃，from MSDN）：

public static int WordCount(this String str)
{
    return str.Split(new char[] { ' ', '.', '?' }, 
                     StringSplitOptions.RemoveEmptyEntries).Length;
}

当然我们在PHP中没有String对象，但对于所有其他对象，我们可以为这种魔法创建通用装饰器。

让我们看看我的实现：

API：

<?php

namespace Pattern\Extension;

/**
 * API for extension methods in PHP (like C#).
 */
class Extension
{
    /**
     * Apply extension to an instance.
     *
     * @param object $instance
     * @return \Pattern\Extension\ExtensionWrapper
     */
    public function __invoke($instance)
    {
        return Extension::apply($instance);
    }

    /**
     * Apply extension to an instance.
     *
     * @param object $instance
     * @return \Pattern\Extension\ExtensionWrapper
     */
    public static function apply($instance)
    {
        return new ExtensionWrapper($instance, \get_called_class());
    }

    /**
     * @param mixed $instance
     * @return boolean
     */
    public static function isExtensible($instance)
    {
        return ($instance instanceof Extensible);
    }
}
?>

装饰者：

<?php

namespace Pattern\Extension;

/**
 * Demarcate decorators that resolve the extension.
 */
interface Extensible
{
    /**
     * Verify the instance of the holded object.
     *
     * @param string $className
     * @return bool true if the instance is of the type $className, false otherwise.
     */
    public function holdsInstanceOf($className);

    /**
     * Returns the wrapped object.
     * If the wrapped object is a Extensible the returns the unwrap of it and so on.
     *
     * @return mixed
     */
    public function unwrap();

    /**
     * Magic method for the extension methods.
     *
     * @param string $name
     * @param array $args
     * @return mixed
     */
    public function __call($name, array $args);
}
?>

通用实现：

<?php

namespace Pattern\Extension;

/**
 * Generic version for the Extensible Interface.
 */
final class ExtensionWrapper implements Extensible
{
    /**
     * @var mixed
     */
    private $that;

    /**
     * @var Extension
     */
    private $extension;

    /**
     * @param object $instance
     * @param string | Extension $extensionClass
     * @throws \InvalidArgumentException
     */
    public function __construct($instance, $extensionClass)
    {
        if (!\is_object($instance)) {
            throw new \InvalidArgumentException('ExtensionWrapper works only with objects.');
        }

        $this->that = $instance;
        $this->extension = $extensionClass;
    }

    /**
     * {@inheritDoc}
     * @see \Pattern\Extension\Extensible::__call()
     */
    public function __call($name, array $args)
    {
        $call = null;
        if (\method_exists($this->extension, '_'.$name)) {
            // this is for abstract default interface implementation
            \array_unshift($args, $this->unwrap());
            $call = array($this->extension, '_'.$name);
        } elseif (\method_exists($this->extension, $name)) {
            // this is for real implementations
            \array_unshift($args, $this->unwrap());
            $call = array($this->extension, $name);
        } else {
            // this is for real call on object
            $call = array($this->that, $name);
        }
        return \call_user_func_array($call, $args);
    }

    /**
     * {@inheritDoc}
     * @see \Pattern\Extension\Extensible::unwrap()
     */
    public function unwrap()
    {
        return (Extension::isExtensible($this->that) ? $this->that->unwrap() : $this->that);
    }

    /**
     * {@inheritDoc}
     * @see \Pattern\Extension\Extensible::holdsInstanceof()
     */
    public function holdsInstanceOf($className)
    {
        return \is_a($this->unwrap(), $className);
    }
}
?>

使用：

假设存在第三方类：

class ThirdPartyHello
{
    public function sayHello()
    {
        return "Hello";
    }
}

创建您的扩展程序：

use Pattern\Extension\Extension;

class HelloWorldExtension extends Extension
{
    public static function sayHelloWorld(ThirdPartyHello $that)
    {
        return $that->sayHello().' World!';
    }
}

Plus：对于Interface Lovers，创建一个Abstract Extension：

<?php
interface HelloInterfaceExtension
{
    public function sayHelloFromInterface();
}
?>
<?php
use Pattern\Extension\Extension;

abstract class AbstractHelloExtension extends Extension implements HelloInterfaceExtension
{
    public static function _sayHelloFromInterface(ThirdPartyOrLegacyClass $that)
    {
        return $that->sayHello(). ' from Hello Interface';
    }
}
?>

然后使用它：

////////////////////////////
// You can hide this snippet in a Dependency Injection method

$thatClass = new ThirdPartyHello();

/** @var ThirdPartyHello|HelloWorldExtension $extension */
$extension = HelloWorldExtension::apply($thatClass);

//////////////////////////////////////////

$extension->sayHello(); // returns 'Hello'
$extension->sayHelloWorld(); // returns 'Hello World!'

//////////////////////////////////////////
// Abstract extension

$thatClass = new ThirdPartyHello();

/** @var ThirdPartyHello|HelloInterfaceExtension $extension */
$extension = AbstractHelloExtension::apply($instance);

$extension->sayHello(); // returns 'Hello'
$extension->sayHelloFromInterface(); // returns 'Hello from Hello Interface'

优点：

PHP中C＃扩展方法的非常相似的方式;
无法直接测试扩展实例作为扩展对象的实例，但这很好，因为它更安全，因为我们可以在那里没有扩展该classe实例的地方;
作为提高团队敏捷性的框架的意图，你必须少写;
扩展使用似乎是对象的一部分，但它只是装饰（对于团队来说，快速开发可能会很有趣，但如果涉及到遗留问题，将来会审查该扩展对象的实现）;
您可以直接使用扩展的静态方法来提高性能，但这样做就会失去模拟部分代码的能力（DI被高度指示）。

缺点：

必须向对象声明扩展名，它不仅仅是像C＃中那样的导入，你必须＆＃34;装饰＆＃34;所需的实例，以扩展它。
无法直接测试扩展实例作为扩展对象的实例，需要使用API测试更多代码;
由于使用魔术方法而导致性能下降（但是当需要性能时，我们会更改语言，重新创建核心，使用极简主义框架，如果需要则使用汇编程序）;

这是Api的要点：https://gist.github.com/tennaito/9ab4331a4b837f836ccdee78ba58dff8

PHP中的C＃类扩展方法？

4 个答案: