为什么要使用异常及java异常的使用--及js、php、golang的异常机制

为什么要使用异常

使用场景引入

假设我们在用户操作前，要判断用户登录是否过期以及是否被禁言。那么，自然而然需要写一个判断登录是否成功，以及如果没有登录引导用户去登录的函数。然而，普通的函数的return语句，仅仅能够停止本函数的运行，不能够终止之后语句的运行，这就意味着，我们必须把如果登录失效引导用户登录的功能放到主函数去写。但是！这样需要每个上层函数都去判断，而且要重复书写很多次!很不方便，所以需要引入中途终止函数的方法，这就是异常。特别是对那些不像php这种有die函数的语言而言！
而在js中，这个作用就更明显了，因为js经常很多功能写在一个里面。不像后台接口，一个接口只干一件事。

好处

1、如上例子，可以中途阻断整个程序的运行。
2、使得代码逻辑更清晰；少写if语句，以及将其与正常的业务逻辑分离开，以及很多还需要错误信息提示，使得逻辑嵌套更加复杂

if(用户没有登陆) {提示
}
if(登陆了且被封号){提示
}
if(登陆了&没有被封号&用户没有购买资格){}
if(商品没库存){}
……
if(登陆、没封号、)

3、你可能说，很多东西可以通过限制，比如不让用户输入负数。但是，总有些东西是你控制不了的！
比如，数据库连接超时。非空、参数类型还可以通过if-else 但是数据库超时这种咋弄？
比如说你的程序需要读取某个文件或者需要连接网络又或者使用数据库这样的情况
虽然程序是你写的但是你绝对不能保证文件一定存在网络一定畅通数据库一定会打开!
这个时候为了程序能继续运行就需要把上边说的情况解释成异常要想运行就必须这些处理异常
4、即使是php这样的语言，由于mvc分层等原因，在service层中die也不合适，而且简单的die无法给更多的信息，如错误码、错误信息数组等。
5、异常能捕获到没有想到的错误而if else只能捕获想到的错误
6、可以在异常类中定义很多方法或者进行复杂处理，die只能输出一句错误原因
7、使用异常类可以捕获很多个异常（不止子类）还可以少些代码复用
8、人类无法穷举所有错误的情况，需要异常来帮助
9、异常处理可以交给上层函数调用者去完成很多时候写函数的时候不知道怎么处理这个异常
10

这个错误处理不了，要返回给上一层的调用者。在比较复杂的程序中，套个三四五六层跟玩儿一样（参考Spring等等），那么你就需要在这每一次嵌套的调用中都写上if(xxx) xxx else xxxx：// caller 1

int fun1(){int err;// ...if((err=fun2())<0){return err  }// ...
}// caller 2
int fun2(){int err;// ...if((err=fun3())<0){return err  }// ...
}// caller 3
int fun3(){int err;// ...if((err=fun4())<0){return err  }// ...
}// caller 4
int fun4(){int err;// ...if((err=fun5())<0){return err  }// ...
}

//…平白无故就多出来很多boilerplate代码，不必要的变量声明，并穿插在逻辑代码中，影响可读性（搭眼看过去全tm是错误处理了）。而且如果一不小心，很容易漏写某些代码。有兴趣可以去读一下诸如linux内核这样的大型C代码程序，上面这样子的代码数不胜数，你i了吗>_>

11没法准确判断程序运行时哪里可能出现问题。异常处理能更加快的找到问题出现的位置

异常的好处（什么时候使用异常）精要总结

1、很多地方如果不符合条件比如数据库连接错误、文件不存在。需要中断整个流程的运行，只用return 只能终止本层，如果多个函数嵌套调用，那么用return就是一场噩梦
2、提供了一种统一在一个地方处理异常的方法，减少代码量。如果不用就得数组那种有点像go
3、在处理完成后，比如数据库连接错误就换一个从库试试，程序还能接着运行，这是die做不到的
4、提供更多的报错信息，普通的die封装成函数——这其实就是异常类的处理方式了。而且die封装也始终只是函数用类的方法能提供更多的功能、比如getmessage gettrace
5、能够交给上层处理自己不知道咋弄.还能设置默认的未捕获的处理方法
6、将错误处理与正常逻辑流程分开，代码更清晰
7、finally：主要用于回收在try块里打开的物力资源(如数据库连接、网络连接和磁盘文件)，异常机制总是保证finally块总是被执行。只有finally块，执行完成之后，才会回来执行try或者catch块中的return或者throw语句，如果finally中使用了return或者 throw等终止方法的语句，则就不会跳回执行，直接停止。

异常的使用–最简单的直观展示，以js为例

x = document.getElementById("demo").value;try { if(x == "")  throw "值为空";if(isNaN(x)) throw "不是数字";x = Number(x);if(x < 5)    throw "太小";if(x > 10)   throw "太大";}catch(err) {message.innerHTML = "错误: " + err;}

当然这是简单的处理，所以看起来和if else区别不大。更详细的使用–面向对象的方式看下面java的

Java异常用法

实例

throw语句用在方法体内，表示抛出异常，由方法体内的语句处理。
throws语句用在方法声明后面，表示再抛出异常，由该方法的调用者来处理。如果你的代码中有处理逻辑这个不是必须的

0、最简单的异常----RuntimeException

public static void main(String[] args){Runtime(-2);//无需catch无需try}public static void Runtime(int a){//和js那的区别仅仅在于此处是面向对象的if(a<0) throw new RuntimeException("tuntime异常");}

1 最简单的普通异常—直接调用

区别：runtime异常可以不写try和catch块！更方便！而Exception要写！必须要catch异常不然会编译失败而为了写catch 又必须要写try块

public static void main(String[] args) {int a =-1;try { if(a<0) throw new Exception("不能为负数");}catch (Exception e) { //e就是你new MyException()出来的对象名System.out.println(e.getMessage());//打印错误信息}}

2 将异常处理封装成函数

可能我们不想只让它在主函数中调用，或者主函数中需要多次调用此时可以将其封装为函数

public class TestException2 {public static void main(String[] args) {int a =-1;check(a);}public static void check(int i) {try { if(i<0) throw new Exception("不能为负数");}catch (Exception e) {System.out.println(e.getMessage());}    }
}

3 使用自定义异常类–去自定义错误处理函数

我们可能需要更复杂的逻辑，比如发生错误的时候发邮件给管理员，此时可用自定义异常类

public class TestException2 {public static void main(String[] args) {int a =-1;try {    if(a<0) throw new MyException();}catch (MyException e) {e.checkAdd(a);//这里就能用我们自定义的异常处理函数了}}
}class MyException extends Exception{public void checkAdd(int j) {System.out.println("e是负数");if(j+5>0) System.out.println("但是加5可以大于0"); }
}

4、带自定义异常类和throws的函数交给上层处理

package testExpection;/** 总结 使用异常的好处（和die区别）* 1、分离业务代码和错误代码* 2、可以中止整个代码的运行 在子函数中仅仅return还是会执行后面的函数 很多语言似乎没有die这个函数* 3、可以在异常类中定义很多方法或者进行复杂处理，die只能输出一句错误原因* 4、使用异常类 可以捕获很多个异常（不止子类） 还可以少些代码 复用 */
//-------------------------------------------------------
/* 总结 使用异常的流程* 1、写一个异常类继承Exception（非必须，可用系统写好的异常类）* 2、在被调用的函数中(事实上，这一步也可在主方法的try块中直接写)*         A:函数申明部分throw出用到的异常类*       B:函数方法体，不符合条件时，throw出异常对象（new 异常构造器）* 3、主方法中：A:*         A: try块写throw过异常的被调用方法和逻辑*      B：catch块捕获异常 catch (InsufficientFundsExpection e) { 具体怎么处理 其中e可调用方法}*/public class TestException {//public修饰的类必须为文件名
//step1 写功能
class Account{private double balence;private int card_number;public Account(int card_number) {this.card_number=card_number;}//存钱public void deposit(double amount) {balence+=amount; }public double getBalence() {return balence;}public int getCardNumber() {return card_number;}//和之前php的区别 php一般是在这个函数里 如果不符合要求return false 或者余额不足 成功返回余额    或者直接die(errmeg)中止运行//而java是通过另一个方法getBalence 去获取这个值 可能是因为php通常是从数据库中拿东西 感受不到//函数申明部分要指明类，throw部分要指明对象，其实很好理解，声明类与新建对象的语法public void withdraw(double amount) throws InsufficientFundsExpection {   //是在函数处写用哪个异常类if(amount<=balence) {balence -=amount;System.out.println("余额为:"+ balence);}else {double need = amount-balence;throw new InsufficientFundsExpection(need);//此处throw写具体的构造函数，变成对象}}
}//Step2 定义异常类
//如果希望写一个检查性异常类，则需要继承 Exception 类。
//如果你想写一个运行时异常类，那么需要继承 RuntimeException 类
class InsufficientFundsExpection extends Exception{private double need;public InsufficientFundsExpection(double need) {this.need=need;}public double getNeed() {return need;}
}//Step3 使用异常
public static void main(String[] args) {Account a = new Account(10086);//前为类名 后为构造函数System.out.println("存款500");//必须双引号a.deposit(500);//开始异常块---使用了异常的函数 需要放到try_catch块中try {System.out.println("取款100");a.withdraw(100);System.out.println("取款1000");a.withdraw(1000);  } //catch块通常直接跟括号后面，这么写是为了注释//具体的处理异常的逻辑放这里  //至于有哪些异常 在这个函数中定义 函数内部仅仅定义异常类型 不规定怎么处理（如果通用也可以抽象出来放进去）catch (InsufficientFundsExpection e) {  System.out.println("取款失败，欠缺"+ e.getNeed()); //此处可以调用这个异常定义的方法，这就是面向对象的好处e.printStackTrace();//trace的方法 异常类都有}//catch块可以写多个//finally块可选}
}

异常其他

3、不管程序是否处于try中，甚至包括catch块中的代码，只要执行代码块时出现了异常，系统总会生成一个异常对象，如果程序没有对这段代码定义catch块，则ajva运行时就在这里退出。
4、catch块中也可使用continue，用于外层是while等如五子棋下棋的场景。
5、try块中的变量，catch块不能访问，且必须加括号不能省略

7、常见异常：数组越界异常、数字格式异常
8、JAVA7新增多异常捕获,

//竖线分隔
catch(AException|BException e)
变量e有final限制，不能赋新值，如e=new AException("TEST");

9 异常常见的方法
getMessage() 返回该异常的详细描述字符串
printStackTrace()将该异常的详细跟踪栈信息输出到标准错误输出
printStackTrace(printStream s) 同上不过是输出到指定输出流
getStackTrace()返回该异常的跟踪栈信息

10、java7新增的自动关闭资源的特性

try(需要自动关闭资源的代码写这里（只写声明和初始化）)
{正常的try语句，如使用资源的逻辑 写这里
}
//java7 重写了所有的资源类，改写后都实现了AutoCloseable或Choseable接口（能够被自动关闭的资源必须实现这两个类之一）

ps throw也可多个异常块但不是java7的 throw E1,E2的语法就行

异常规范

1、通常在finally块中回收try块打开的物理资源，如db等，异常机制会保证finally块总被执行！即使try中有return语句，也会保证先执行finally里的（除了System.exit(1)这种退出虚拟机的语法）。所以少在finally块中用return、throw避免出现奇奇怪怪的错误
8、程序总是把Exception类的异常放后面，这是因为所有异常对象都是Exception或者其子类的实例，所以把它放后面

try{}
catch (IndexOutOfBundsException e){do sth
}
catch (Exception e){}
finally

3、throw的真正含义，当前方法不知道怎么处理这个异常而交给调用它的方法去处理！所以写了throw块当前方法就不用写catch块了，如果调用它的也throw 那么就接着下一级。注，main方法也可用throw！这样会把异常交给jvm处理，而jvm的做法是打印Stack并终止代码运行

4、异常用于分离正常业务逻辑和错误处理，所以不要通过异常的方便去吧正常业务逻辑写进去
5、try块不应该过大如果真的很多分离开不同的try catch块
6、遇到异常尽量不要捕获而不处理实在不行交给上层调用它的去处理

java异常体系–Checked和Runtime

2、Java分两种异常，Checked异常和Runtime异常。开发者当然希望在运行前就排除所有错误，但是这是不现实的，比如网络编程发现那个文件不存在、内存不够、网络连接错误、硬件突然故障、操作系统崩溃、用户不按照要求输入等，这种异常只有使用中能够被发现。所以，Checked异常必须强制开发者处理，而Runtime异常无需处理。
6、Java把所有的非正常情况分两种，一种是Error，如系统崩溃、虚拟机错误等，一般是和虚拟机相关的问题，这类问题无法恢复或者不可能捕获，所以程序不应该捕获error错误。另一种是Exception异常。

只有java提供了Checked异常，其他语言都没有提供。

对于Checked异常，必须被显式处理，具体下面两种
1当前方法知道如何处理， try catch块
2当前方法不知道如何处理就throw 出去让调用这个方法的去处理
Runtime异常无需显示声明抛出，如果需要捕获也用try catch语法

Checcked异常体现了java的设计哲学，而且可以提醒粗心的程序员别忘了处理，但是很繁琐，所以很多争议，特别是很多方法也不知道怎么处理异常所以只是把它声明了出来 catch了而不处理

使用runtime异常简化异常处理

之前的写法

 public void withdraw(double amount) throws InsufficientFundsExpection {   //是在函数处写用哪个异常类throw new InsufficientFundsExpection(need);//此处throw写具体的构造函数，变成对象}

现在的写法

//无throws 很聪明 省的还写 runtime 复杂……没必要
public void withdraw(double amount) {throw new InsufficientFundsExpection(need);
}

使用的时候可catch 也可不catch 都可，不用catch jvm会自动终止运行并打印堆栈信息

异常链-异常转译 ----分级显示异常

如用户不关心sql层的异常用户只想看到报错信息所以分层是有必要的

try{正常逻辑
}
catch （底层异常 如sql异常）{//这里记录原始异常给管理员
...................throw new 上层异常('给用户的错误信息')
}}

Jdk1.4 后异常类可新增一个构造器具体以后再看吧···

other 以后补充进去

php的错误处理机制和异常

错误和异常的区别

1 异常和错误的定义

PHP中将代码自身异常（一般来说是环境或者语法非法所致）成为错误，将运行中出现的逻辑错误称为异常（Exception）。
错误是没法通过代码处理的（最多只能输出错误信息），而异常则可以通过try/catch处理。

错误是自动触发的，当然你也可以手动触发。比如1/0就会触发错误
而异常必须手动抛出

如果抛出的异常未被捕获，则导致 Fatal error，并使得代码停止执行。

由于历史原因，php一开始被设计为一门面向过程的语言，所以异常处理没有使用像Java一样的 try / catch 机制。这就是错误的诞生。

2 异常相较错误的好处

错误是不可处理最多只能记录下来错误位置、堆栈与发送给管理员的
没捕获异常的函数相当于die 或者能够打印堆栈的错误!!

带catch的异常不同于错误，是可以预料和处理的，比如用户头像因为微信改了接口，获取不到了默认给他指定一个。if也可以完成，但是好处在于分离了正常逻辑和错误处理逻辑，代码更加清晰。
异常还可以留给调用它的处理因为函数定义的时候可能不知道怎么处理异常但是又需要提醒调用者去处理异常。比如某函数用了打开文件失败了怎么办不能简单返回个 return false吧，因为不够清晰是什么类型的错误如果return ‘网络超时’，‘磁盘已满’ 又太多了造成可读性变差且无法提醒调用者必须对每种异常情况做出处理

错误处理机制

1简单的die()函数

die是退出当前接口不是退出php-fpm
缺点在于提供的信息不够多。当然也可先print_r 然后再die,但是每次都写很麻烦而且不统一。
当然也可以一起封装为函数----事实上这就是错误！
但是这种错误比较简单，没办法自定义错误级别和自动触发错误（自动触发错误比如堆栈信息、发邮件需要语法错误手动触发的很像异常）

2自定义错误和错误触发器、错误日志

2.1一个简单的例子

set_error_handler(function ($errno,$errstr,$errfile,$errline)//常用的四个参数
{echo "错误等级：".$errno."<br>错误信息：".$errstr."<br>错误的文件名：".$errfile."<br>错误的行号：".$errline;exit();//否则出错后还可正常运行
});
$a = 1/0; //自动触发的错误
trigger_error("this is a error");//自行触发的错误
echo '正常';

2.2、自定义错误处理函数

这个例子和上面的区别在于，将处理错误的函数单独写出来了，而且规定了错误级别。方便复用

<?php
/** 1, 创建自定义错误函数* 2，使用set_err_handler指定使用我们的错误处理函数* 3，触发错误，分自动触发和手动触发*//*
* 我们可以自定义错误处理函数
* 语法
* error_function(error_level,error_message,error_file,error_line,error_context)
* 函数名可变，前两个参数是必选项
*/
function customError($errno, $errstr)
{echo "<b>Error:</b> [$errno] $errstr<br>";die();//进阶error_log() 函数可向服务器错误记录、文件或远程目标发送一个错误。
}/*
// 设置使用我们自定义的错误处理函数
//set_error_handler() 仅需要一个参数，可以添加第二个参数来规定错误级别。
//如果第二个不传代表所有错误
*/
set_error_handler("customError",E_USER_WARNING);/*触发错误,分为自动触发和手动触发，此处为自动触发，下面的章节介绍手动触发的
*/
echo($test);//自动触发错误Error: [8] Undefined variable: test
$test = 2;
if ($test>1)
{trigger_error("变量值必须小于等于 1");//手动触发错误
}
}
?>

2.3 错误记录—error_log

在默认的情况下，根据在 php.ini 中的 error_log 配置，PHP 向服务器的记录系统或文件发送错误记录。通过使用 error_log() 函数，您可以向指定的文件或远程目的地发送错误记录

<?php
// 错误处理函数
function customError($errno, $errstr)
{echo "<b>Error:</b> [$errno] $errstr<br>";echo "已通知网站管理员";error_log("Error: [$errno] $errstr",1,"someone@example.com","From: webmaster@example.com");//err_log会自动die
}// 设置错误处理函数
set_error_handler("customError",E_USER_WARNING);// 触发错误
$test=2;
if ($test>1)
{trigger_error("变量值必须小于等于 1",E_USER_WARNING);
}
?>

2.4其他

Logging 函数允许用户对应用程序进行日志记录，并把日志消息发送到电子邮件、系统日志或其他的机器。----其实就是err_log

php7 对异常的更改:

异常

1、最简单的异常–类似java的Runtime的异常

<?php
// 创建一个有异常处理的函数---只需要throw而无需catch
function checkNum($number)
{if($number>1){throw new Exception("Value must be 1 or below");}return true;
}// 触发异常
checkNum(2);
/*
Fatal error: Uncaught exception 'Exception' with message 'Value must be 1 or below' in /www/runoob/test/test.php:7 Stack trace: #0 /www/runoob/test/test.php(13): checkNum(2) #1 {main} thrown in /www/runoob/test/test.php on line 7
*/
?>

2、带catch的异常----和java的区别，无需使用throws交给上层处理

<?php
// 创建一个有异常处理的函数
function checkNum($number)
{if($number>1){throw new Exception("变量值必须小于等于 1");}return true;
}// 在 try 块 触发异常
try
{checkNum(2);// 如果抛出异常，以下文本不会输出echo '如果输出该内容，说明 $number 变量';
}
// 捕获异常
catch(Exception $e)
{echo 'Message: ' .$e->getMessage();
}
?>

注意: 1、如果定义异常的时候就捕获异常 try块中的会中断代码运行，外面的不会

$a=1;
try {if ($a == 1) throw new Exception("获取access_token错误");print_r('try里');
} catch (Exception $e) {print_r($e->getMessage());
}
print_r('try外');
//result: try外部

2 、如果内层函数throw，php没有java的throws

function outer(){echo 1;inner();echo 4 ;
}function inner(){echo 2;throw new Exception('error');echo 3;
}try{outer();
}catch(Exception $e){echo 'catch';
}
echo 5;//out 1 2 catch 5
//总结:执行范围为throw块的上面 和继续执行捕获异常以及之后的部分

3、自定义的异常类

<?php
class customException extends Exception
{public function errorMessage(){// 错误信息$errorMsg = '错误行号 '.$this->getLine().' in '.$this->getFile().': <b>'.$this->getMessage().'</b> 不是一个合法的 E-Mail 地址';return $errorMsg;}
}$email = "someone@example...com";try
{// 检测邮箱if(filter_var($email, FILTER_VALIDATE_EMAIL) === FALSE){// 如果是个不合法的邮箱地址，抛出异常throw new customException($email);//区别在上面,可以自定义参数、处理方法等 比如加通知管理员的}
}catch (customException $e)
{//display custom message
echo $e->errorMessage();
}
?>

4、异常分级处理

上面自定义异常类，我们可能不想让用户看到具体的行号错误文件，
所以需要定义多个异常，分级输出异常。也就是重新抛出异常
<?php
class customException extends Exception
{public function errorMessage(){// 错误信息$errorMsg = $this->getMessage().' 不是一个合法的 E-Mail 地址。';return $errorMsg;}
}$email = "someone@example.com";try
{try{// 检测 "example" 是否在邮箱地址中if(strpos($email, "example") !== FALSE){// 如果是个不合法的邮箱地址，抛出异常throw new Exception($email);}}catch(Exception $e){// 重新抛出异常throw new customException($email);}
}
catch (customException $e)
{// 显示自定义信息，最终只给用户展示最外层的异常！echo $e->errorMessage();
}
?>

但是这样很麻烦有优化方式么？

5、设置顶层异常处理器—便捷程序员不想写catch块的情况

对原始的Exception 默认设置不catch的处理方式
和错误那个地方很像

//set_exception_handler() 函数可设置处理所有未捕获异常的用户定义函数。function myException($exception)
{echo "<b>Exception:</b> " , $exception->getMessage();
}
set_exception_handler('myException');//和错误那里很像//不用写catch块了
throw new Exception('Uncaught Exception occurred');

6、其他

错误转变成异常

我们可以把PHP错误转换为异常（并不是所有的错误都可以转换,只能转换php.ini文件中error_reporting指令设置的错误），使用处理异常的现有流程处理错误。
这里我们使用set_error_handler()函数将错误信息托管至ErrorException（它是Exception的子类），进而交给现有的异常处系统处理。如下：

set_exception_handler(function (Exception $e)
{echo "我自己定义的异常处理".$e->getMessage();
});set_error_handler(function ($errno, $errstr, $errfile, $errline )
{throw new ErrorException($errstr, 0, $errno, $errfile, $errline);//转换为异常
});trigger_error("this is a error");//自行触发错误
运行结果： 我自己定义的异常处理this is a error

结合看错误那里 php7对错误的更改

异常还可接受错误码用于给网页返回

可以定义必须处理的异常类

即使设置了全局默认异常处理类对特定的类还是可以再抛出异常

总之(怎么用二者)

新版本的php 建议默认都用exception了。
错误用于自动触发的场景，但是一半都是语法类错误，平常不多关注。(但是可以设置变量为定义的话强制停止？)
异常用于手动触发的场景，虽然错误也可手动触发，但是不建议用错误了（有时候还可能遇到莫名其妙的问题不展开了……）。异常更强大，也可以设置默认处理程序，还能手动catch。

使用exception的时候，可以写一个处理handler，用于未捕获异常的处理(一般必须写)。还可以自定义异常类(可写可不写看需求)

不要滥用异常

比如一个函数 isPermission 检测是否有权限的
使用这个函数，如果有权限返回true 没有返回false。只有比如用户id不存在应该抛出异常。
异常用于有问题应该应用于不处理需要直接终止脚本运行的场景或者返回值提示信息很多种类的情况。