做PHP开发已经有快一年的时间了，在这一年的时间中，学习了很多生产环境中的技巧，学习了很多东西，期间也阅读了一些优秀的源码和关于代码的书，对写代码这一块有了一定的思考，也看过很多别人写的好的代码和坏的代码，这里说说自己的感悟和改进吧。

本篇博客直说自己的感悟，在写代码时，我给自己立下的规则，这样可以让代码清晰可读并少走一些坑。这些简单的规则虽然没有设计模式看起来那么激动人心，但是，平常注意可以让代码看起来很清爽。

1. 不要在对象外使用未声明的变量

这个问题其实表述起来可能不容易理解。这个问题是因为PHP语言本身的特点决定的。由于PHP是一个弱类型的动态脚本语言，所以很多情况下，给了这个语言本省很宽松的条件让开发者去编写代码。但是往往这些便利也会变为坑，所以在使用一些动态语言很方便的写法的时候，尤其要注意。

下面我们先声明一个类，暂且叫这个类为用户类，这个User类的背景设定为，框架自带，不允许修改，并且隐藏在框架深处，不容易发现，实际案例可以参考laravel框架的Request类，代码如下：

1. class User { 
2.   public $username; 
3.   public $password; 
4.     
5.   public $otherInfo = []; 
6.     
7.     
8.   public function readUserInfo() { 
9.     return [ 
10.       'username' => $this->username, 
11.       'password' => $this->password, 
12.     ]; 
13.   } 
14.     
15.   public function addAtri($info) { 
16.     array_push($this->otherInfo, $info); 
17.   } 
18. } 

这样的代码看似中规中矩，但是接下来，我们需要对这个类进行操作：

$user = new User();

$user->userRealName = "hello world";

这样的代码在PHP中是完全可以运行的，并且不会报错，但是这样的代码会对之后的一些事情做为干扰。我们现在假定，上边的代码是在PHP web项目中是一个拦截器，或者叫做中间件也可以，然后我们在controller中会会使用到这个类的实例，并且使用到这个中间件中添加的这个变量，如下：

1. class WebOperate { 
2.   public function doOprate(User $user) { 
3.     $user->userRealName = "hello world"; 
4.     next($user); 
5.   } 
6. } 

这里设定的场景是，WebOperate是一个中间件，所有的Controller都会走这个中间件后到达Controller，之后，在处理相应的Controller的功能，接下来，Controller会将中间件的实例注入进来，供控制器使用，而中间件开发人员不是很在意其的存在：

1. class IndexController { 
2.   public function index(User $user) { 
3.     return $user->userRealName; 
4.   } 
5. } 

而这样的代码是可以完美运行的，接下来，开发人员想要的实另一个User类，这个User类中添加一些其他功能，正如之前所说，这个类在框架深处并且很难找到，且不允许修改，因为其他功能使用了这个类，所以，我们只有继承并添加方法。根据开发经验，开发人员会认为User类中存在这个userRealName变量，所以就造成了这个写法：

首先是基于这个User衍生出来的Teacher类：

1. class Teacher extends User { 
2.   public function sayHello() { 
3.     return "hello world"; 
4.   } 
5. } 

这样，我们的Teacher就可以sayhello了，但是，这个时候，在我们的Controller中还想知道老师的真实姓名，怎么办？根据经验，我们可以将注入的类换成Teacher并且返回真实姓名：

1. class IndexController { 
2.   public function index(Teacher $user) { 
3.     return $user->userRealName; 
4.   } 
5. } 

那么这下问题来了，其实User类中并没有这个类，所以这个变量根本没有数值，但是根据经验，是中间件已经赋值过一次了，所以我们应该可以直接使用，但是并没有这个数值，我们开始看源码发现，继承的User类中根本不存在这个变量，那么这个变量之前为什么可以使用呢，因为在中间件中，给User的实力付了值。

所以我们的不能这样直接使用未声明的变量，在一个类中。

我们应该这样写：

1. class WebOperate { 
2.   public function doOprate(User $user) { 
3.     $user->addAtri([ 
4.       'userRealName' => 'hello world', 
5.     ]); 
6.     next($user); 
7.   } 
8. } 

这样的中间件，在调用的时候继承类也可以使用同样的方法，很简单并且很不容易出现坏的味道。

2. 类or数组

其实这个问题同时也衍生出了另外的问题，就是函数返回值的问题。

首先，我明确表示，一个函数做多种类型的返回值是我个人感觉是不好的，在动态语言中虽然很常见，很多PHP的原生方法也有这样的，但是，在生产中使用这样的方式会造成函数返回的不确定性，我们需要作出很多判断来证明我们的结论，但是，如果返回值类型只有一种，我们就可以直接判断返回值就好了。

就像如下代码：

1. public function addNewUser() { 
2.     $res = $this->addData(); 
3.     if ($res) { 
4.       return true; 
5.     } else { 
6.       return [ 
7.         'error' => 1, 
8.         'errormsg' => "没有添加成功" 
9.       ]; 
10.     } 
11.   } 

这样的代码在作为调用者往往会多一次判断，如下：

1. public function index() { 
2.     $res = $this->addNewUser(); 
3.     if (is_array($res) && isset($res['error'])) { 
4.       return isset($res['errormsg']) ? $res['errormsg'] : "未知错误"; 
5.     } 
6.     return "成功"; 
7.   } 

这样的代码几乎每一次调用完成这个函数都会有这一套出现，不仅代码不美观，而且很臃肿。

这样的代码需要改善，首先限制住函数的返回值。比如，我们只让这个函数返回bool类型的数：

1. public function addNewUser() { 
2.   $res = $this->addData(); 
3.   if ($res) { 
4.     return true; 
5.   } else { 
6.     return false; 
7.   } 
8. } 

但是，显然，很多时候，我们要的不是简单的真价值，所以，我们会选择返回更多信息，这个时候，我们可以有三种处理方式。

1）返回int类型的数，然后通过这个int类型的数去判断处理结果，我们可以添加上映射关系：

1. class Operate{ 
2.   public $operateRes = [ 
3.     0 => '成功', 
4.     1 => '添加失败', 
5.     2 => '未知错误', 
6.   ]; 
7.     
8.     
9.   public function addNewUser() { 
10.     $res = $this->addData(); 
11.     if ($res) { 
12.       return 0; 
13.     } else if ($res > 1) { 
14.       return 1; 
15.     } 
16.     return 2; 
17.   } 
18.     
19. } 

这样方法的调用者就可以很简单的使用方法并给出提示了：

1. $opera = new Operate(); 
2. $res = $opera->addNewUser(); 
3. return $opera->operateRes[$res]; 

给出统一的返回值类型的时候就完全不需要判断返回值类型而且可以设置一个规范返回提示。

2）我们也可以使用数组

3）数组给人不缺定性，因为很多时候，数组里可以认为的少写一些元素，如果少写了，程序直接报错，很不好。

所以第三种方式就是建议将固定格式的返回，写成一个类，做返回的时候，使用这个类：

1. class Operate{ 
2.   public function addNewUser() { 
3.     $res = $this->addData(); 
4.     $result = new Result(); 
5.     if ($res) { 
6.       $result->errno = 0; 
7.       $result->errmsg = "成功"; 
8.     } else if ($res > 1) { 
9.       $result->errno = 1; 
10.       $result->errmsg = "失败"; 
11.     } 
12.     $result->errno = 2; 
13.     $result->errmsg = "未知错误"; 
14.     return $result; 
15.   } 
16.     
17. } 
18.  
19. class Result { 
20.   public $errno; 
21.   public $errmsg; 
22. } 

这样的返回，保证了所有变量的存在，同样可以减少一次判断。

所以，综合以上，在我们返回结果的时候，尽量使用同种类型的变量，尽量减少使用数组返回。

Tags: PHP坏代码

分享到：