Rust Trait

什么是 Trait

PHP trait

摘自php.net 对 trait 的介绍：

PHP 实现了一种代码复用的方法，称为 trait。

Trait 是为类似 PHP 的单继承语言而准备的一种代码复用机制。Trait 为了减少单继承语言的限制，使开发人员能够自由地在不同层次结构内独立的类中复用 method。Trait 和 Class 组合的语义定义了一种减少复杂性的方式，避免传统多继承和 Mixin 类相关典型问题。

Trait 和 Class 相似，但仅仅旨在用细粒度和一致的方式来组合功能。 无法通过 trait 自身来实例化。它为传统继承增加了水平特性的组合；也就是说，应用的几个 Class 之间不需要继承。

PHP Trait 示例：

/**
 * Trait Animal
 * 动物特型
 */
trait Animal {
    /**
     * 无法定义常量，使用变量代替
     * 物种
     * @var string 
     */
    private $SPECIES = "";

    /**
     * 抽象方法
     * 获取名称方法
     * @return string
     */
    abstract function name() :string;

    /**
     * 默认实现方法
     * 自我介绍方法
     * @return string
     */
    function say() :string {
        $name = $this->name();
        return "你好，我是一只{$this->SPECIES}，我的名字叫\"{$name}\"";
    }
}

Rust trait

摘自rust语言官网 对 trait 的介绍：

trait 告诉 Rust 编译器某个特定类型拥有可能与其他类型共享的功能。可以通过 trait 以一种抽象的方式定义共享的行为。可以使用 trait bounds 指定泛型是任何拥有特定行为的类型。

注意：trait 类似于其他语言中的常被称为 接口（interfaces）的功能，虽然有一些不同。

这里【其他语言】应该不包括PHP，因为PHP也有trait。

简单来说，Rust Trait 是通过 trait 关键字定义的一组方法（function）、类型（type）、常量（constant），实现代码复用。与 PHP trait 类似，PHP Trait 没有 type 和 constant，但是可以定义变量（field）。

Rust Trait 示例：

/// 动物特型
trait Animal {
    /// 类型
    /// 错误类型
    type Err;

    /// 常量
    /// 物种名称
    const SPECIES: &'static str;

    /// 抽象方法
    /// 获取名称方法
    fn name(&self) -> &str;

    /// 默认实现方法
    /// 自我介绍方法
    fn say(&self) -> String {
        format!(r#"你好，我是一只{}，我的名字叫"{}""#, Self::SPECIES, self.name())
    }
}

Trait 的实现

derive 宏

通过 derive 宏实现 trait，前提是已经定义了对应的proc_macro_derive宏方法，且内部类型都已经实现了该 trait。

/// Debug derive 宏核心库已经定义
/// 内部的 `name`(String)、`age`(u32) 都已经实现了 Debug trait，所以可以直接通过 derive 自动实现 Debug trait
#[derive(Debug)]
struct Bird {
    name: String
    age: u32
}

手动实现

impl trait name for struct or enum {}

/// 鸟是动物
impl Animal for Bird {
    type Err = ();
    const SPECIES: &'static str = "鸟";

    fn name(&self) -> &str {
        self.name.as_str()
    }
}

孤儿规则

当你为某类型实现某 trait 的时候，该类型或者trait至少有一个是在当前 crate 中定义的，不能为第三方的类型实现第三方的 trait 。否则可能会影响第三方 crate 中的行为。

Rust Trait 用途

在PHP中，trait 主要是解决 class 单继承的限制，但 Rust 中没有class 和继承的概念，也就没有这方面的用途。Rust Trait 用途主要有以下几个：

接口抽象

这个作用与 PHP trait 一样，但是PHP有专门的定义接口（interface）的功能；

/**
 * PHP 接口抽象 trait 形式
 */
trait Fly {
    /**
     * @throws Exception
     */
    function fly();
}

/**
 * PHP 接口抽象 interface 形式
 */
interface Fly {
    /**
     * @throws Exception
     */
    function fly();
}

/// Rust 接口抽象
/// 定义一个 `Fly` 接口
trait Fly {
    fn fly() -> Result<(), ()>;
}

/// 鸟能飞，实现 Fly 接口
impl Fly for Bird {
    fn fly(&self) -> Result<(), ()> {
        println!("芜湖起飞");
        Ok(())
    }
}

泛型约束

rust：

/// 定一个一个动物飞行方法
/// 一边飞一边自我介绍
/// 参数 flyer 类型为泛型参数T，T 约束为：需要同时实现 `Fly` trait 和 `Animal` trait
fn animal_fly<T: Fly + Animal>(flyer: T) {
    // fly 函数来自 `Fly` trait
    flyer.fly();
    // say 函数来自 `Animal` trait
    println!("{}，我正在天空翱翔", flyer.say())
}

PHP 中没有泛型，PHP 8 的 Union Types 是或（“|”）的关系，而不是且的关系。

方法重载

方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。在 Java 中，可以在 class 中直接定义多个重载方法。rust 中，无法为结构体定义重载方法，但是可以借助 trait 实现。

例如：i64 的 from 方法，是通过核心库的 From<T> trait 实现的

/// 给 `Bird` 声明 `from` 创建对象方法
impl Bird {
    fn from(name: &str) -> Self {
        Bird {
            name: name.to_string()
        }
    }
}
/// 通过 `From<T>` trait 重载 from 方法
/// 通过编号（u32）创建对象
impl From<u32> for Bird {
    fn from(num: u32) -> Self {
        Bird {
            name: format!("小{}", num)
        }
    }
}
/// 通过名称（String）创建对象
impl From<String> for Bird {
    fn from(name: String) -> Self {
        Bird {
            name
        }
    }
}

这样 Bird 也有几个 from 重载方法了，rust 会根据参数类型选择调用对应的方法

常用 Trait

Display

打印对象信息

use std::fmt::{Display, Formatter};

struct Pig {
    name: String
}

impl Display for Pig {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "这只小猪是：{}", self.name)
    }
}

fn main() {
    let bird = Pig { name: "佩奇".to_string() };
    println!("{}", bird); // 这只小猪是：佩奇
}

Debug

打印对象 Debug 信息

#[derive(Debug)]
struct Pig {
    name: String
}

fn main() {
    let bird = Bird { name: "佩奇".to_string() };
    println!("{:?}", bird); // Pig { name: "佩奇" }
}

Clone

#[derive(Clone)]
struct Sheep {
    name: String
}
fn main() {
    let sheep1 = Sheep {  name: "Dolly".to_string() };
    // 所有权发生转移，pig1 变成未定义
    let sheep2 = sheep1;
    // 报错
    println!("sheep1 是 {}", sheep1.name);
    

    // 调用 Clone Trait 的 clone 函数克隆羊，sheep2 依然存在
    let sheep3 = sheep2.clone();
    println!("sheep2 是 {}", sheep2.name);
    println!("sheep3 是 {}", sheep3.name);
}

Copy

/// 实现 Copy trait 需要同时实现 Clone
#[derive(Clone, Copy)]
struct Int(i64);

fn main() {
    let int1 = Int(1);
    // 不发生所有权转移，自动复制
    let int2 = int1;
    println!("int1： {}", int1.0);
    println!("int2： {}", int2.0);
}

From / Into

/// 为 Int 实现 From<i32>
impl From<i32> for Int {
    fn from(num: i32) -> Self {
        Int(i64::from(num))
    }
}

/// 为 Int 实现 Into<i32>
impl Into<i32> for Int {
    fn into(self) -> i32 {
        self.0 as i32
    }
}

fn main() {
    let int1 = Int::from(1_i32);
    let inner: i32 = int1.into();
    println!("int1： {}", int1.0);
    println!("inner： {}", inner);
}

PHP5.4实现了一种代码复用的方法称为Trait。

Trait为了减少单继承语言的限制，能够自由地在不同层次结构内独立的类中复用方法，Trait和Class组合的语义定义了一种减少复杂性的方式，避免传统多继承和 Mixin 类相关典型问题。无法通过 trait 自身来实例化。一个类要应用trait需要使用use关键字，一个类可以应用多个trait，只需要在use关键字后用逗号分隔多个trait。
trait中也可以应用其他的trait。

<?php
trait a{
    function getA(){
        return "a";
    }
}
trait b{
    function getB(){
        return "b";
    }
}
class Test{
    use a,b;
}
$test=new Test();
echo $test->getA()."\n";
echo $test->getB()."\n";
 
trait c{
    use a,b;
}
class Test2{
    use c;
}
$test=new Test2();
echo $test->getA()."\n";
echo $test->getB()."\n";
?>

如果trait和class中存在相同的成员，则优先级规则为，[当前类的成员->trait的成员->继承的成员]。

<?php
trait a{
    function getA(){
        parent::getA();
        echo "a in trait\n";
    }
}
class Base{
    function getA(){
        echo "a in Base\n";
    }
}
class Test extends Base{
    use a;
}
class Test2 extends Base{
    use a;
    function getA(){
        echo "a in Test2\n";
    }
}
$test=new Test();
$test->getA();
 
$test2=new Test2();
$test2->getA();
?>

在应用多个trait时，如果插入了同名的方法，则需要解决冲突，否则会产生致命错误。解决冲突可以使用insteadof关键字来指明使用哪一个方法。还可以通过as关键字为某个方法引入别名，as关键字还可以调整方法的访问控制。

<?php
trait A {
    public function printLower() {
        echo 'a';
    }
    public function printUpper() {
        echo 'A';
    }
}
 
trait B {
    public function printLower() {
        echo 'b';
    }
    public function printUpper() {
        echo 'B';
    }
    public function testAccess(){
        
    }
}
 
class Test {
    use A, B {
        B::printLower insteadof A;
        A::printUpper insteadof B;
        B::printUpper as private upper;
        testAccess as protected;
    }
}
 
$test=new Test();
$test->printLower();
$test->printUpper();
//$test->upper();
//$test->testAccess();
?>

trait还支持抽象方法，应用trait的类需要实现抽象方法，否则会产生致命错误。trait还支持静态成员。

<?php
trait a{
    function lower(){
        return "a";
    }
    abstract function upper();
    public static function foo(){
        echo "static function foo\n";
    }
}
class Test{
    use a;
    function upper(){
        return "A";
    }
}
$t=new Test();
echo $t->lower()."\n";
echo $t->upper()."\n";
Test::foo();
?>

trait中可以定义属性，但是应用trait的类不能定义与之同名的属性，否则会产生致命错误，除非属性是兼容的，即访问控制和初始默认值都相同。PHP7.0之前即使属性兼容也会有E_STRICT的提醒。

<?php
trait a{
    public $var="a";
    public $diff1="a";
    public $diff2="a";
}
class Test{
    use a;
    public $var="a";
    //public $diff1="b";
    //protected $diff2="a";
}
?>

Trait

本文作者LockieDeng，PHP工程师，致力于倒腾各种前沿技术，欢迎交流：

dengmuuming@163.com

概述

自 PHP 5.4.0 起，PHP 实现了一种代码复用的方法，称为 trait。
Trait 是为类似 PHP 的单继承语言而准备的一种代码复用机制。Trait 为了减少单继承语言的限制，使开发人员能够自由地在不同层次结构内独立的类中复用 method。Trait 和 Class 组合的语义定义了一种减少复杂性的方式，避免传统多继承和 Mixin 类相关典型问题。

官网地址：https://www.php.net/manual/zh/language.oop5.traits.php

示例 #1 Trait

Trait 和 Class 相似，但仅仅旨在用细粒度和一致的方式来组合功能。 无法通过 trait 自身来实例化。它为传统继承增加了水平特性的组合；也就是说，应用的几个 Class 之间不需要继承。

<?php
    trait ezcReflectionReturnInfo {
        function getReturnType() { /*1*/ }
        function getReturnDescription() { /*2*/ }
    }
    
    class ezcReflectionMethod extends ReflectionMethod {
        use ezcReflectionReturnInfo;
        /* ... */
    }
    
    class ezcReflectionFunction extends ReflectionFunction {
        use ezcReflectionReturnInfo;
        /* ... */
    }
?>

优先级

从基类继承的成员会被 trait 插入的成员所覆盖。优先顺序是来自当前类的成员覆盖了 trait 的方法，而 trait 则覆盖了被继承的方法。

示例 #2 优先顺序示例

从基类继承的成员被插入的 SayWorld Trait 中的 MyHelloWorld 方法所覆盖。其行为 MyHelloWorld 类中定义的方法一致。优先顺序是当前类中的方法会覆盖 trait 方法，而 trait 方法又覆盖了基类中的方法。

<?php
    class Base {
        public function sayHello() {
            echo 'Hello ';
        }
    }
    
    trait SayWorld {
        public function sayHello() {
            parent::sayHello();
            echo 'World!';
        }
    }
    
    class MyHelloWorld extends Base {
        use SayWorld;
    }
    
    $o = new MyHelloWorld();
    $o->sayHello();
?>

以上例程会输出：

Hello World!

示例 #3 另一个优先级顺序的例子

    <?php
    trait HelloWorld {
        public function sayHello() {
            echo 'Hello World!';
        }
    }
    
    class TheWorldIsNotEnough {
        use HelloWorld;
        public function sayHello() {
            echo 'Hello Universe!';
        }
    }
    
    $o = new TheWorldIsNotEnough();
    $o->sayHello();
?>

以上例程会输出：

Hello Universe!

多个 trait

通过逗号分隔，在 use 声明列出多个 trait，可以都插入到一个类中。

示例 #4 多个 trait 的用法

<?php
    trait Hello {
        public function sayHello() {
            echo 'Hello ';
        }
    }
    
    trait World {
        public function sayWorld() {
            echo 'World';
        }
    }
    
    class MyHelloWorld {
        use Hello, World;
        public function sayExclamationMark() {
            echo '!';
        }
    }
    
    $o = new MyHelloWorld();
    $o->sayHello();
    $o->sayWorld();
    $o->sayExclamationMark();
?>

以上例程会输出：

Hello World!

冲突的解决

如果两个 trait 都插入了一个同名的方法，如果没有明确解决冲突将会产生一个致命错误。
为了解决多个 trait 在同一个类中的命名冲突，需要使用 insteadof 操作符来明确指定使用冲突方法中的哪一个。
以上方式仅允许排除掉其它方法，as 操作符可以 为某个方法引入别名。 注意，as 操作符不会对方法进行重命名，也不会影响其方法。

示例 #5 冲突的解决

在本例中 Talker 使用了 trait A 和 B。由于 A 和 B 有冲突的方法，其定义了使用 trait B 中的 smallTalk 以及 trait A 中的 bigTalk。

Aliased_Talker 使用了 as 操作符来定义了 talk 来作为 B 的 bigTalk 的别名。

<?php
    trait A {
        public function smallTalk() {
            echo 'a';
        }
        public function bigTalk() {
            echo 'A';
        }
    }

    trait B {
        public function smallTalk() {
            echo 'b';
        }
        public function bigTalk() {
            echo 'B';
        }
    }

    class Talker {
        use A, B {
            B::smallTalk insteadof A;
            A::bigTalk insteadof B;
        }
    }

    class Aliased_Talker {
        use A, B {
            B::smallTalk insteadof A;
            A::bigTalk insteadof B;
            B::bigTalk as talk;
        }
    }

    $o = new Aliased_Talker();
    $o->smallTalk();
    $o->bigTalk();
    $o->talk();
?>

以上例程会输出：

bAB

注意:

在 PHP 7.0 之前，在类里定义和 trait 同名的属性，哪怕是完全兼容的也会抛出 E_STRICT（完全兼容的意思：具有相同的访问可见性、初始默认值）。

修改方法的访问控制

使用 as 语法还可以用来调整方法的访问控制。

示例 #6 修改方法的访问控制

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

    // 修改 sayHello 的访问控制
    class MyClass1 {
        use HelloWorld { sayHello as protected; }
    }

    // 给方法一个改变了访问控制的别名
    // 原版 sayHello 的访问控制则没有发生变化
    class MyClass2 {
        use HelloWorld { sayHello as private myPrivateHello; }
    }

    // 修改 sayHello 的访问控制
    class MyClass3 {
        use HelloWorld { sayHello as public; }
    }


    $o = new MyClass3();
    $o->sayHello();
?>

以上例程会输出：

Hello World!

从 trait 来组成 trait

正如 class 能够使用 trait 一样，其它 trait 也能够使用 trait。在 trait 定义时通过使用一个或多个 trait，能够组合其它 trait 中的部分或全部成员。

示例 #7 从 trait 来组成 trait

<?php
    trait Hello {
        public function sayHello() {
            echo 'Hello ';
        }
    }
    
    trait World {
        public function sayWorld() {
            echo 'World!';
        }
    }
    
    trait HelloWorld {
        use Hello, World;
    }
    
    class MyHelloWorld {
        use HelloWorld;
    }
    
    $o = new MyHelloWorld();
    $o->sayHello();
    $o->sayWorld();
?>

以上例程会输出：

Hello World!

Trait 的抽象成员

为了对使用的类施加强制要求，trait 支持抽象方法的使用。

警告
一个可继承实体类，可以通过定义同名非抽象方法来满足要求；方法的签名可以不同。

示例 #8 表示通过抽象方法来进行强制要求

<?php
    trait Hello {
        public function sayHelloWorld() {
            echo 'Hello'.$this->getWorld();
        }
        abstract public function getWorld();
    }

    class MyHelloWorld {
        private $world;
        use Hello;
        public function getWorld() {
            return $this->world;
        }
        public function setWorld($val) {
            $this->world = $val;
        }
    }

    $o = new MyHelloWorld();
    $o->setWorld('你好');
    $o->getWorld();
    $o->sayHelloWorld();
?>

以上例程会输出：

Hello你好

Trait 的静态成员

Traits 可以被静态成员静态方法定义。

示例 #9 静态变量

<?php
    trait Counter {
        public function inc() {
            static $c = 0;
            $c = $c + 1;
            echo "$c\n";
        }
    }

    class C1 {
        use Counter;
    }

    class C2 {
        use Counter;
    }

    $o = new C1(); $o->inc(); // echo 1
    $p = new C2(); $p->inc(); // echo 1
?>

示例 #10 静态方法

<?php
    trait StaticExample {
        public static function doSomething() {
            return 'Doing something';
        }
    }

    class Example {
        use StaticExample;
    }

    echo(Example::doSomething()); // echo Doing something
?>

属性

Trait 同样可以定义属性。

示例 #11 定义属性

<?php
    trait PropertiesTrait {
        public $x = 1;
    }
    
    class PropertiesExample {
        use PropertiesTrait;
    }
    
    $example = new PropertiesExample;
    echo( $example->x ); // echo 1
?>

Trait 定义了一个属性后，类就不能定义同样名称的属性，否则会产生 fatal error。 有种情况例外：属性是兼容的（同样的访问可见度、初始默认值）。 在 PHP 7.0 之前，属性是兼容的，则会有 E_STRICT 的提醒。

<?php
    trait PropertiesTrait {
        public $same = true;
        public $different = false;
    }

    class PropertiesExample {
        use PropertiesTrait;
        public $same = true; // PHP 7.0.0 后没问题，之前版本是 E_STRICT 提醒
        public $different = true; // 致命错误
    }
?>