The use of traits

Original source: http://blog.csdn.net/longlongmylove/article/details/7521379

php5.4 New features traits introduction

1. Traits
Traits is a new method for implementing code reuse in 5.4.

PHP is a single-inheritance language, and we can't extends multiple base classes in a class like Java to implement code reuse, and now traits can solve the problem of code reuse, which allows developers to implement code reuse in a variety of classes.
Traits and class are defined in semantics to reduce the complexity of the code and avoid multiple inheritance problems.

Traits is similar to class, but it is used only to provide a set of functionality in a uniform and finer-grained manner, which cannot be instantiated within Traits, i.e. there is no class-like constructor __construct (). Traits is an extension of traditional PHP inheritance and enables horizontal integration, so you can no longer need inheritance in your application's class.

1) How to use
Use the keyword ' use ' In the class to refer to Traits. Multiple traits are separated by ', '.

The instance code is as follows:

[PHP] View plaincopy

2. Trait Ezcreflectionreturninfo {
3. function Getreturntype () {
4. }
5. function getreturndescription () {
6. }
7. }class ezcreflectionmethod extends reflectionmethod {
8. Use Ezcreflectionreturninfo;
9. /* ... */
10. }
11. class ezcreflectionfunction extends reflectionfunction {
12. Use Ezcreflectionreturninfo;
13. /* ... */
14. }
15. ?>

2) Priority level
The member functions in the base class will be overwritten by the functions in the traits, and the member functions in the current class will overwrite the functions in traits.

[PHP] View plaincopy

4. class Base {
6. Public function SayHello () {
8. Echo ' Hello ';
10. }
12. }
16. Trait Sayworld {
18. Public function SayHello () {
20. Parent::sayhello ();
22. Echo "world!\n";
24. }
26. }
30. class Myhelloworld extends Base {
32. Use Sayworld;
34. }
38. class Myhelloworldext extends Base {
40. Use Sayworld;
42. Public function SayHello () {
44. /**
46. * Here is a new change in 5.4, the previous version of 5.4 will prompt:
48. * PHP Fatal error:cannot Use string offset as an array
50. * 5.4 is improved to return the character of the index number in the string
52. */
54. $str = "Arvin" ;
56. Echo $str[0][0]; //Echo ' A ';
58. }
62. Public function shortarray () {
64. $array = [' first ', 2, 3, 4]; simple syntax for arrays in//5.4
66. Echo $array[0]; array element method in//5.4
68. }
70. }
74. $o = New Myhelloworld ();
76. $o ->sayhello ();
78. $oe = New Myhelloworldext ();
80. $oe ->sayhello ();
82. Echo "\ n";
84. $oe ->shortarray ();

[PHP] View plaincopy

1. Output:
2. Hello world!
3. A
4. First

3) Multi-traits

Multiple traits can be added to a class declaration, separated by "," between multiple traits.

[PHP] View plaincopy

4. Trait Hello {
6. Public function SayHello () {
8. Echo ' Hello ';
10. }
12. }
16. Trait World {
18. Public function sayworld () {
20. Echo ' world ';
22. }
24. }
28. class Myhelloworld {
30. Use Hello, world;
32. }
36. $o = New Myhelloworld ();
38. $o ->sayhello ();
40. $o ->sayworld ();
42. ?>

Output Result:

Hello World 4) Multiple traits conflicts
If you add the same function name to the two traits in the same class and do not explicitly process it, an error will occur.
In order to resolve a function conflict of the same name in two tratis in the same class, you need to select the correct function with the insteadof operator.
Because of the uniqueness and exclusivity of the method, the ' as ' operator allows the use of the conflict function to resolve internal conflict issues.

[PHP] View plaincopy

4. Trait A {
6. Public function smallTalk () {
8. Echo ' a ';
10. }
12. Public function bigtalk () {
14. Echo ' A ';
16. }
18. }
22. Trait B {
24. Public function smallTalk () {
26. Echo ' B ';
28. }
30. Public function bigtalk () {
32. Echo ' B ';
34. }
36. }
40. class Talker {
42. Use A, B {
44. B::smalltalk insteadof A;
46. A::bigtalk insteadof B;
48. }
50. }
54. class Aliased_talker {
56. Use A, B {
58. B::smalltalk insteadof A;
60. A::bigtalk insteadof B;
62. B::bigtalk as talk ;
64. }
66. }
68. ?>

In the above example, talker uses traits A and B, so there is a conflict between the same function names in both.
Alker defines smalltalk taken from traits B,bigtalk taken from traits A.
Using the AS operator in Aliased_talker ensures that bigtalk in traits B is implemented by Alias talk.
5) Changing function access rights
We can use the AS syntax to change the access properties of functions in traits.

[PHP] View plaincopy

4. Trait HelloWorld {
6. Public function SayHello () {
8. Echo ' Hello world! ' ;
10. }
12. }
16. //change visibility of SayHello, changing the access rights of SayHello.
18. class MyClass1 {
20. Use HelloWorld {sayHello as protected;}
22. }
26. //Alias method with changed visibility
28. //SayHello visibility not changed, set alias Myprivatehello.
30. class MyClass2 {
32. Use HelloWorld {sayHello as private Myprivatehello;}
34. }
36. ?>

6) Traits composition of the new traits
As with many classes, you can use traits in the same class as in Traits,traits. One or more traits can be defined in one traits, and these traits can be defined in other traits as part or all of the members.

[PHP] View plaincopy

4. Trait Hello {
6. Public function SayHello () {
8. Echo ' Hello ';
10. }
12. }
16. Trait World {
18. Public function sayworld () {
20. Echo ' world! ' ;
22. }
24. }
28. Trait HelloWorld {
30. Use Hello, world;
32. }
36. class Myhelloworld {
38. Use HelloWorld;
40. }
44. $o = New Myhelloworld ();
46. $o ->sayhello ();
48. $o ->sayworld ();
50. ?>

The above routines will output:

[PHP] View plaincopy

1. Hello world!

7) Abstract Trait members
In order to enforce some methods in a class, you can use an abstract method in traits.
For example:

[PHP] View plaincopy

4. Trait Hello {
6. Public function sayhelloworld () {
8. Echo ' Hello '. $this ->getworld ();
10. }
12. Abstract public Function Getworld ();
14. }
18. class Myhelloworld {
20. Private $world;
22. Use Hello;
24. Public function __construct ($world) {
26. $this ->world = $world ;
28. }
30. Public function getworld () {
32. return $this->world;
34. }
36. }
40. /**
42. * Here are 5.4 new feature class instances to dissolve the reference operation
44. * (new Class ())->method ();
46. */
48. (new myhelloworld (' Arvin '))->sayhelloworld ();
50. ?>
54. The instance output:
56. Hello Arvin

8) Static Trait members

Static variables cannot be defined in traits, but can be defined in Tratis functions. Static functions can also be defined in Tratis.

[PHP] View plaincopy

4. Trait Counter {
6. Public function Inc () {
8. Static $c = 0; //static variable
10. $c + = 1;
12. Echo "$c \ n";
14. }
16. /**
18. * static Method
20. */
22. Public static function dosomething () {
24. Echo ' Doing something ';
26. }
28. }
32. class C1 {
34. Use Counter;
36. }
40. (new C1 ())->inc (); //Echo 1
42. C1::d osomething ();
44. ?>
46. The output is:
48. 1
50. Doing something

9) Traits defining attributes

If a property is defined in a trait, a property with the same name cannot be defined in the class that references the trait, if the defined attribute in the class has the same name and access visibility as the defined property in trait, it is a e_strict Prompt, otherwise throws a syntax error.

 
                             x, $example->y;? > Output: 12

At the end of the post php5.4.0 part of the new feature Changelog:

Added Short array syntax support ([All-in-A-z]), see Upgrading Guide for full details. Added binary numbers Format (0b001010). Added Support for CLASS::{EXPR} () syntax. Added support for traits.//The main content of this article Added closure $this support back. Added array dereferencing support.//arrays are supported, with an instance Added callable Typehint above. Added indirect method call through array. #47160. Added DTrace support.//legend DTrace is a profiling tool that can track data such as function call points, return points, Added class member access on instantiation (e.g. new Foo)->bar ()) support.//class new instance dereference operation, with instance

The purpose of this paper is to explore the new features of php5.4 together. ^_^

The above describes the use of traits, including aspects of the content, I hope that the PHP tutorial interested in a friend helpful.

