精华内容
下载资源
问答
  • try-catch-finally的执行顺序
    2021-05-09 11:16:46

    下面说下在javascript中try-catch-finally的执行顺序

    1、不管有没有出现异常,都会执行finally中的代码

    2、不管try   catch中有没有return,都会执行finally中的代码

    3、若try或者catch中有return,finally中没有return,则一定是执行了try、catch中的语句,接着执行finally中的语句,最后才会执行try、catch中的return

    4、若try、catch没有return,finally中有return,则一定是执行了try、catch中的语句,接着执行finally中的语句,最后执行finally中的return

    5、若try、catch有return,finally中有return,则一定是执行了try、catch中的语句,接着执行finally中的语句,最后执行finally中的return

    即finally是一定会执行,在try、catch语句执行之后、return语句执行之前执行;若finally没有return,则用try、catch的return;若finally有return,不管try、catch是否有return,都用finally的return

     

    下面看一下demo:

    <!doctype html>
    <body>
      <script>
        test1()
        //  输出结果
        // try
        // catch
    
        test2()
        // 输出结果
        // try
        // error
        // catch
    
        console.log(test3())
        // 输出结果
        // try
        // finally
        // try fragment
    
        console.log(test4())
        // 输出结果
        // try
        // finally
        // finally fragment
    
        console.log(test5())
        // 输出结果
        // try
        // finally
        // try fragment
    
        console.log(test6())
        // 输出结果
        // try
        // error
        // finally
        // catch fragment
    
        console.log(test7())
        // 输出结果
        // try
        // error
        // finally
        // finally fragment
    
        console.log(test8())
        // 输出结果
        // try
        // error
        // finally
        // finally fragment
    
        // 没有return
        function test1() {
          try {
            console.log('try')
          } finally {
            console.log('catch')
          }
        }
    
        function test2() {
          try {
            console.log('try')
            throw new Error('error')
          } catch (error) {
            console.log(error.message)
          } finally {
            console.log('finally')
          }
        }
    
        // 有return
        function test3() {
          try {
            console.log('try')
            return 'try fragment'
          } finally {
            console.log('finally')
          }
        }
    
        function test4() {
          try {
            console.log('try')
          } finally {
            console.log('finally')
            return 'finally fragment'
          }
        }
    
        function test5() {
          try {
            console.log('try')
            return 'try fragment'
          } finally {
            console.log('finally')
            return 'finally fragment'
          }
        }
    
        function test6() {
          try {
            console.log('try')
            throw new Error('error')
          } catch (error) {
            console.log(error.message)
            return 'catch fragment'
          } finally {
            console.log('finally')
          }
        }
    
        function test7() {
          try {
            console.log('try')
            throw new Error('error')
          } catch (error) {
            console.log(error.message)
          } finally {
            console.log('finally')
            return 'finally fragment'
          }
        }
    
        function test8() {
          try {
            console.log('try')
            throw new Error('error')
          } catch (error) {
            console.log(error.message)
            return 'catch fragment'
          } finally {
            console.log('finally')
            return 'finally fragment'
          }
        }
      </script>
    </body>
    </html>

     

    更多相关内容
  • TryCatchFinally执行顺序

    2019-07-25 09:44:38
  • try catch finally 的执行顺序 代码的执行情况是 try -> catch -> finally ,所以返回的顺序也是,如果try 里面有return,或者catch里面有return,会把return的对象返回到调用栈中,然后执行finally里面的逻辑...

    try catch finally 的执行顺序

    代码的执行情况是 try -> catch -> finally ,所以返回的顺序也是,如果try 里面有return,或者catch里面有return,会把return的对象返回到调用栈中,然后执行finally里面的逻辑,但是如果finally里面也有return 则会把调用栈里面的对象更新,如下代码:

    public class TryCatchDemo {
    
        public static void main(String[] args) {
            System.out.println(test());
        }
    
        private static int test() {
            try {
                return 1;
            } catch (Exception e) {
                return 2;
            } finally {
                return 3;
            }
        }
    }
    

    打印结果如下

    在这里插入图片描述
    如果在try 和catch返回值,在finally里不返回值,修改值,此时返回的栈的值并没有改变所以,finally修改没有效果。代码如下

    public class TryCatchDemo {
    
        public static void main(String[] args) {
            System.out.println(test());
        }
    
        private static int test() {
            int a = 1;
            try {
                return a;
            } catch (Exception e) {
                return a;
            } finally {
                a ++;
            }
        }
    }
    

    返回结果
    在这里插入图片描述
    由于返回栈中的值没有变,所以修改是没有用的

    但是如果我的返回栈中返回的是对象就不一样了,因为对象是存在堆中的,它的引用是存在栈中的,我们在finally里面修改修改的是堆里面的内容,所以返回值会变。代码如下

    public class TryCatchDemo {
    
        public static void main(String[] args) {
            System.out.println(test());
        }
        
        private static User test() {
            User user = new User("张三");
            try {
                return user;
            } catch (Exception e) {
                return user;
            } finally {
                user.setUserName("李四");
            }
        }
    }
    
    class User {
        private String userName;
        public User(String userName) {
            this.userName = userName;
        }
    
        public String getUserName() {
            return userName;
        }
    
        public void setUserName(String userName) {
            this.userName = userName;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "userName='" + userName + '\'' +
                    '}';
        }
    }
    

    执行结果如下
    在这里插入图片描述
    所以这种情况也得分开,看返回的是值还是引用,所以出现的结果也不一样,当然也有特例,如果你返回的对象是String 虽然是对象,但是它是final修饰的,所以修改不了里面的值,所以返回的结果和值引用是一样的情况。

    展开全文
  • 执行顺序是先执行 try 中代码,此时 try 中代码异常抛出,程序跳转到 catch 中,然后执行 finally 中的语句,最后执行后续语句。 执行顺序是:1 --> 3 --> 4 --> 5 --> 6 注意:如果此时 catch 块中抛出一个...

    序言

    Java 的异常捕捉通常使用 try-catch 捕捉或者 throws 抛出处理。这篇文章就来探讨下 try-catch 的一些事。

    try-catch 和 throws 异常处理

    try-catch 和 throws 处理异常一般按照,如果底层异常就往上层抛出(throws) ,上层异常 try-catch 处理。(PS:这里底层上层是面向对象的编程语言的封装程度相对而言)

    try-catch 和 try-catch-finally

    • 两者最大的区别就是,是否与 finally 结合使用。其实 finally 存在的意义就是为了防止异常中断 try 代码块中程序,直接跳到异常处理之后,相关资源(如 IO、线程等等)没有释放,导致资源浪费或者内存泄漏等等。
    • 通常是在 finally 中关闭相关资源。

    后面就来看下 try-catch-finally 的执行顺序

    try-catch-finally 执行顺序

    举个例子(如下):

    public static void main(String[] args) {
        
        FileInputStream input = new FileInputStream("D:\\File\\Demo.txt");
        try {
            // 1 
            // some code that might throw exceptions
            // 2 
        } catch(IOException e){
            // 3
            // show error message
            // 4
        } finally {
            // 5
            input.close();
        }
        // 6
    }
    

    在上面的这段代码会有3中执行顺序:

    1. try 中代码没有异常抛出

    执行顺序是先执行 try 中的语句,然后执行 finally 中语句,最后执行后续语句。执行顺序就是:1 --> 2 --> 5 --> 6

    1. try 中代码异常,在 catch 中捕获

    执行顺序是先执行 try 中代码,此时 try 中代码异常抛出,程序跳转到 catch 中,然后执行 finally 中的语句,最后执行后续语句。
    执行顺序是:1 --> 3 --> 4 --> 5 --> 6

    注意:如果此时 catch 块中抛出一个异常,程序会自动跳到 finally 中。
    执行顺序为:1 --> 3 --> 5 -->6

    1. try 中代码异常,catch 中无法捕获该异常

    举个栗子,抛出异常为IoException, catch 中设定异常为 SQLException,程序将执行 try 中代码直到异常抛出,最后直接执行 finally 和后续代码。
    执行顺序为:1 --> 5 --> 6

    最后

    我们在使用 try-catch-finally 语句中,牢记其三种情况下的执行顺序,可以减少爬一些不必要的坑。


    2019.09.01 更新

    • 当 finally 中包含 return 会出现一些意想不到的情况。假如利用 return 语句从 try 中退出,再放发前,finally 中的语句会在返回前执行。如果 finally 中也有 return,那么前者的 return 会被覆盖原始返回值。例如,见下:
    /**
     * 该方法返回 r 的值
     */ 
    public static int fun(int n) {
        try {
            int r = n * n;
            return r;
        } catch (Exception e) {
            if( n == 2) {
                return 0;
            }
        }
    } 
    

    如果调用 fun(2) ,那么 try 中计算结果是 4 , 并执行 return 语句。然而,在方法真正返回之前,还要执行 finally 的语句,finally 中语句使得方法返回 0 , 这个返回值覆盖了原来的返回值 4。


    人若无名,专心练剑!

    ####### 觉得文章还不错的童鞋,可以留下你的点赞和评论。

    展开全文
  • 执行代码捕获异常后,进入catch块,try中出现异常代码处后面的代码不会再继续执行。 catch块:用于处理处理try中捕获的异常。 可以有多个catch块,进入一个catch块后,执行完毕后,如果有finally块,则进入...
  • try/catch-finally的执行顺序可以分为:有return和没有return来讨论 一、无return 1.如果没有捕捉到异常,执行try代码块,而不会执行catch的代码块,最后执行finally代码块。其执行顺序:try-->fin...
  • try,catch,finally执行顺序分析

    千次阅读 2019-02-14 22:02:12
    的情况下,try、catch、finally后的执行顺序 例: 情况1:try{ return} finally{ } 先执行try中代码块,再执行finally 中代码,再执行try中return先执行try中代码块,再执行finally 中代码,再执行try中...
  • 我们在做题的时候,时长会遇到关于try的题型,会让你判断他们的执行顺序,今天我给大家总结一下,他们的执行顺序,希望大家一定要仔细看 我们先看一个例子 public abstract class Test { public static void main...
  • 3、finally是在return后面的表达式运算后执行的(此时并没有返回运算后的值,而是先把要返回的值保存起来,不管finally中的代码怎么样,返回的值都不会改变,任然是之前保存的值),所以函数返回值是在finally执行前...
  • try catch finally 执行顺序结论 1、不管有没有出现异常,finally块中代码都会执行; 2、当try和catch中有return时,finally仍然会执行; 3、finally是在return后面的表达式运算后执行的(此时并没有返回运算后的值...
  • finally的执行顺序优先于return,而且不管报错与否一定会执行,所以在可能出错的io操作中,在finally中关闭io流。 case 3  try{ } catch{ return; } finally{ }  public int condition3(){ try { ...
  • try-catch-finally 在JS中的执行顺序

    千次阅读 2019-09-21 15:57:49
    看到一篇文章,介绍 try-catch-finally 的执行顺序,在此记录一下。回头再试试Java中是不是也这样。
  • Java中try、catch、finally语句块的执行顺序

    千次阅读 多人点赞 2018-05-03 21:12:03
    执行顺序: a) 执行try块,并执行其中return表达式; b) 执行finally块; c) 执行finally中return 表达式;d) 返回finally中return表达式结果(PS:由于finally中有return语句则直接返回退出) 场景4:try{return;...
  • 主要介绍了C#中的try catch finally用法,以实例形式分析了try catch finally针对错误处理时的不同用法,具有一定的参考借鉴价值,需要的朋友可以参考下
  • try catch finally的执行顺序

    千次阅读 2017-11-02 21:39:43
    通过编写一些常见的例子来更深入的理解try、catch、finally的执行顺序,代码如下: import java.util.Scanner; /* * 通过sum函数返回的值来确定return了哪个 * 0:默认返回 * 1:finally的返回值 * 2:通用异常...
  •  昨天一个朋友出去面试,遇到这么一道题:“C# catch里有return,finally里还执行吗?” 个人实践小结:  1、不管有木有出现异常,finally块中代码都会执行。  2、当try和catch中有return时,finally仍然会执行。...
  • finally 语句块是在 try 或者 catch 中的 return 语句之前执行的。更加一般的说法是,finally 语句块应该是在控制转移语句之前执行,控制转移语句除了 return 外,还有 break 和 continue。另外,throw 语句也属于...
  • 异常处理方式之一:try-catch-finally 格式 try{ //可能出现异常的代码 }catch(异常类型1 变量名){ //处理异常的方式1 ...finally可选,如果有finally,那finally中的代码一定会执行。 问题:如果tr
  • 已知:try/catch-finally 最后函数节数肯定会执行finally内容。如果try中没有异常,不会执行catch,如果有异常,先执行catch. 代码1 public class try_catch_finally { static int res = 0; public static void ...
  • 3、finally是在return后面的表达式运算后执行的(此时并没有返回运算后的值,而是先把要返回的值保存起来,管finally中的代码怎么样,返回的值都不会改变,任然是之前保存的值),所以函数返回值是在finally执行前...
  • try-catch-finally执行顺序验证(左边是.java文件,右边是.class文件) 提示: try-catch-finally的return在编译阶段做的优化,参考.class文件可以知道return的是哪个值。 总结: 对于return x,无论x是基本类型还是引用...
  • try { try { //你的过程代码 return; } catch(Exception ex) { //错误处理代码1 ... //必执行代码1 } } catch(Exception ex) { //错误处理代码2 return; } finally { //必执行代码2 }
  • try catch finally 执行顺序深究

    千次阅读 2018-12-04 17:23:39
    疑问:明明执行了finally里面的 x=3 语句,返回的结果为什么是1尼,在这里读者可能会产生一个疑问,是否finally就对try里面的变量不产生影响尼,我们看下面一个例子: Test1.1: public static String[] ...
  • 就是说try里所用程序步骤都执行完毕,就等return的时候,finally开始执行。这样最后try里的return就会被覆盖掉。 [code="java"] package com; public class Test { public static void main(String[]...
  • 在每个阶段中,.Net运行库顺序执行try块,查找合适的处理程序; 在每个阶段中,当退出catch块后,就会执行对应finally块中的任何清理代码,但不执行finally块外部的代码,知道找到合适的catch处理程序,并执行为止...
  • 那么我们可以把释放资源的语句放到try-catch后执行,当前的程序不管是在执行完try语句块还是catch语句块,都会顺序执行到下面释放资源的语句。 int count = 0; //初始化资源 try{  count++;  if
  • 例题1 ...执行,且 finally 里的修改语句可能影响也可能不影响 try 或 catch 中 return 已经确定的返回值,若 finally 里也有 return 语句则覆盖 try 或 catch 中的 return 语句直接返回。

空空如也

空空如也

1 2 3 4 5 ... 13
收藏数 244
精华内容 97
关键字:

trycatchfinally执行顺序