对于初学者来说，上面的答案可能很难，下面是最简单的理解方法:

特征

trait SayWorld {
    public function sayHello() {
        echo 'World!';
    }
}

所以如果你想在其他类中使用sayHello函数，而不需要重新创建整个函数，你可以使用trait，

class MyClass{
  use SayWorld;

}

$o = new MyClass();
$o->sayHello();

酷吧!

不只是函数，你可以使用trait中的任何东西(function, variables, const…)你也可以使用多个trait: SayWorld, AnotherTraits;

接口

  interface SayWorld {
     public function sayHello();
  }

  class MyClass implements SayWorld { 
     public function sayHello() {
        echo 'World!';
     }
}

因此，这就是接口与特征的不同之处:您必须在实现的类中重新创建接口中的所有内容。接口没有实现，接口只能有函数和常量，不能有变量。

我希望这能有所帮助!

其他答案很好地解释了界面和特征之间的差异。我将重点介绍一个有用的真实例子，特别是一个演示trait可以使用实例变量的例子——允许您用最少的样板代码向类添加行为。

再一次，像其他人提到的那样，特征与接口很好地配对，允许接口指定行为契约，而特征则完成实现。

在一些代码库中，向类添加事件发布/订阅功能是常见的场景。有3种常见的解决方案:

定义带有事件发布/订阅代码的基类，然后希望提供事件的类可以扩展它以获得功能。 定义一个带有事件发布/订阅代码的类，然后其他想要提供事件的类可以通过组合来使用它，定义自己的方法来包装组合对象，将方法调用代理给它。 用事件发布/订阅代码定义trait，然后其他想要提供事件的类可以使用该trait(也就是导入它)来获得功能。

它们的工作效果如何?

第一条效果不好。它会，直到有一天你意识到你不能扩展基类，因为你已经扩展了其他的东西。我将不展示这方面的示例，因为这样使用继承的局限性应该是显而易见的。

第二条和第三条都很有效。我将展示一个突出一些差异的例子。

首先，两个示例之间的一些代码是相同的:

一个接口

interface Observable {
    function addEventListener($eventName, callable $listener);
    function removeEventListener($eventName, callable $listener);
    function removeAllEventListeners($eventName);
}

以及一些演示用法的代码:

$auction = new Auction();

// Add a listener, so we know when we get a bid.
$auction->addEventListener('bid', function($bidderName, $bidAmount){
    echo "Got a bid of $bidAmount from $bidderName\n";
});

// Mock some bids.
foreach (['Moe', 'Curly', 'Larry'] as $name) {
    $auction->addBid($name, rand());
}

好了，现在让我们来看看在使用trait时Auction类的实现是如何不同的。

首先，这是#2(使用合成)的样子:

class EventEmitter {
    private $eventListenersByName = [];

    function addEventListener($eventName, callable $listener) {
        $this->eventListenersByName[$eventName][] = $listener;
    }

    function removeEventListener($eventName, callable $listener) {
        $this->eventListenersByName[$eventName] = array_filter($this->eventListenersByName[$eventName], function($existingListener) use ($listener) {
            return $existingListener === $listener;
        });
    }

    function removeAllEventListeners($eventName) {
        $this->eventListenersByName[$eventName] = [];
    }

    function triggerEvent($eventName, array $eventArgs) {
        foreach ($this->eventListenersByName[$eventName] as $listener) {
            call_user_func_array($listener, $eventArgs);
        }
    }
}

class Auction implements Observable {
    private $eventEmitter;

    public function __construct() {
        $this->eventEmitter = new EventEmitter();
    }

    function addBid($bidderName, $bidAmount) {
        $this->eventEmitter->triggerEvent('bid', [$bidderName, $bidAmount]);
    }

    function addEventListener($eventName, callable $listener) {
        $this->eventEmitter->addEventListener($eventName, $listener);
    }

    function removeEventListener($eventName, callable $listener) {
        $this->eventEmitter->removeEventListener($eventName, $listener);
    }

    function removeAllEventListeners($eventName) {
        $this->eventEmitter->removeAllEventListeners($eventName);
    }
}

下面是第三点(特质):

trait EventEmitterTrait {
    private $eventListenersByName = [];

    function addEventListener($eventName, callable $listener) {
        $this->eventListenersByName[$eventName][] = $listener;
    }

    function removeEventListener($eventName, callable $listener) {
        $this->eventListenersByName[$eventName] = array_filter($this->eventListenersByName[$eventName], function($existingListener) use ($listener) {
            return $existingListener === $listener;
        });
    }

    function removeAllEventListeners($eventName) {
        $this->eventListenersByName[$eventName] = [];
    }

    protected function triggerEvent($eventName, array $eventArgs) {
        foreach ($this->eventListenersByName[$eventName] as $listener) {
            call_user_func_array($listener, $eventArgs);
        }
    }
}

class Auction implements Observable {
    use EventEmitterTrait;

    function addBid($bidderName, $bidAmount) {
        $this->triggerEvent('bid', [$bidderName, $bidAmount]);
    }
}

注意，EventEmitterTrait内部的代码与EventEmitter类内部的代码完全相同，只是trait将triggerEvent()方法声明为受保护。因此，您需要注意的唯一区别是Auction类的实现。

And the difference is large. When using composition, we get a great solution, allowing us to reuse our EventEmitter by as many classes as we like. But, the main drawback is the we have a lot of boilerplate code that we need to write and maintain because for each method defined in the Observable interface, we need to implement it and write boring boilerplate code that just forwards the arguments onto the corresponding method in our composed the EventEmitter object. Using the trait in this example lets us avoid that, helping us reduce boilerplate code and improve maintainability.

然而，有时你可能不希望你的Auction类实现完整的Observable接口——也许你只想公开1到2个方法，甚至可能根本不公开，这样你就可以定义自己的方法签名。在这种情况下，您可能仍然喜欢组合方法。

但是，在大多数情况下，这个特性非常引人注目，特别是当接口有很多方法时，这会导致您编写大量的样板文件。

*你实际上可以两者都做——定义EventEmitter类，以防你想组合使用它，并定义EventEmitterTrait trait，使用EventEmitter类实现在trait里面:)

trait只是为了代码重用。

Interface只是提供了要在类中定义的函数的签名，它可以根据程序员的判断使用。这样就为我们提供了一组类的原型。

供参考, http://www.php.net/manual/en/language.oop5.traits.php

如果你懂英语，知道trait的意思，它就是这个名字的意思。它是一个无类的方法和属性包，您可以通过输入use将其附加到现有类。

基本上，你可以将它与单个变量进行比较。闭包函数可以从作用域外部使用这些变量，这样它们就有了作用域内部的值。他们是强大的，可以在任何地方使用。如果trait被使用，也会发生同样的情况。

接口定义了实现类必须实现的一组方法。

当trait被使用时，方法的实现也会出现——这在接口中不会发生。

这是最大的不同。

PHP RFC的水平重用:

trait是一种在单继承语言(如PHP)中代码重用的机制。Trait旨在通过允许开发人员在不同类层次结构中的几个独立类中自由地重用方法集来减少单个继承的一些限制。

我认为trait对于创建包含方法的类是有用的，这些方法可以被用作几个不同类的方法。

例如:

trait ToolKit
{
    public $errors = array();

    public function error($msg)
    {
        $this->errors[] = $msg;
        return false;
    }
}

您可以在任何使用此特性的类中拥有并使用此“error”方法。

class Something
{
    use Toolkit;

    public function do_something($zipcode)
    {
        if (preg_match('/^[0-9]{5}$/', $zipcode) !== 1)
            return $this->error('Invalid zipcode.');
        
        // do something here
    }
}

而对于接口，你只能声明方法签名，而不能声明它的函数代码。此外，要使用接口，您需要遵循层次结构，使用实现。但特质却不是这样。

这是完全不同的!