Error js内置错误 js处理错误流程 Throw语句
Exceptional Exception Handling in JavaScript MDN资料
Anything that can go wrong, will go wrong. Murphy’s law is even applicable to software development. For non-trivial programs, it’s not a matter of if, but when something will go wrong. Standards non-compliance, unsupported features, and browser quirks are just a few sources of potential problems facing web developers. Given all of the things that can go wrong, JavaScript has a surprisingly simple way of dealing with errors(js处理错误的方式很简单,仅仅是程序停下来) ― it just gives up and fails silently. At least, that’s the behavior seen by the user. In reality, there is a lot going on under the hood.
When a JavaScript statement generates an error, it is said to throw an exception.(在js中,程序产生错误,叫做抛出异常) Instead of proceeding to the next statement, the JavaScript interpreter checks for exception handling code. If there is no exception handler, then the program returns from whatever function threw the exception. This is repeated for each function on the call stack until an exception handler is found or until the top level function is reached, causing the program to terminate.
Error Objects
When an exception occurs, an object representing the error is created and thrown(当异常发生时,一个表示错误的对象就会被创建和抛出). The JavaScript language defines seven types of built-in error objects. These error types are the foundation for exception handling. Each of the error types is described in detail below.
The Error
constructor creates an error object. Instances of Error
objects are thrown when runtime errors occur. The Error
object can also be used as a base object for user-defined exceptions.
Syntax
new Error([message[, fileName[, lineNumber]]])
message
- Optional. Human-readable description of the error(对错误的描述).
fileName
- Optional. The value for the
fileName
property on the createdError
object. Defaults to the name of the file containing the code that called theError()
constructor.(发生错误的文件名) lineNumber
- Optional. The value for the
lineNumber
property on the createdError
object. Defaults to the line number(发生错误的代码行数) containing theError()
constructor invocation.
standard built-in error types(七种标准的内置错误)
Error
The “Error” type is used to represent generic exceptions(一般错误). This type of exception is most often used for implementing user defined exceptions. The topic of creating user defined exceptions will be revisited later in this article. “Error” objects are instantiated by calling their constructor as shown in the following example.
var error = new Error("error message");
“Error” objects contain two properties, “name” and “message”. The “name” property specifies the type of exception (in this case “Error”). The “message” property provides a more detailed description of the exception. The “message” gets its value from the string passed to the exception’s constructor. The remaining exception types represent more specific types of errors, but they are all used in the same fashion as the generic “Error” type.
RangeError
Creates an instance representing an error that occurs when a numeric variable or parameter(数值变量或数值参数不在有效范围内) is outside of its valid range.
“RangeError” exceptions are generated by numbers that fall outside of a specified range. For example, JavaScript numbers have a toFixed() method which takes a “digits” argument representing the number of digits to appear after a decimal point. This argument is expected to be between 0 and 20 (although some browsers support a wider range). If the value of “digits” is outside of this range, then a “RangeError” is thrown. This scenario is shown in the following example.
ReferenceError
A “ReferenceError” exception is thrown when a non-existent variable(当要获取一个“不存在”的变量时) is accessed. These exceptions commonly occur when an existing variable name is misspelled. In the example below, a “ReferenceError” occurs when “bar” is accessed. Note that this example assumes that “bar” does not exist in any active scope when the increment operation is attempted.
SyntaxError
A “SyntaxError” is thrown when the rules(js规则错了,即语法错误) of the JavaScript language are broken. Developers who are familiar with languages such as C and Java are used to encountering syntax errors during the compilation process. However, because JavaScript is an interpreted language, syntax errors are not identified until the code is executed. Syntax errors are unique as they are the only type of exception that cannot be recovered from. The following example generates a syntax error because the “if” statement is missing a closing curly brace.
TypeError
Creates an instance representing an error that occurs when a variable or parameter is not of a valid type(参数或变量不是有效的类型).
A “TypeError” exception occurs when a value is not of the expected type. Attempting to call a non-existent object method is a common cause of this type of exception. The following example creates an empty object named “foo” and then attempts to invoke its bar() method. Since bar() is not defined, a “TypeError” is thrown upon the attempted invocation.
URIError
A “URIError” exception is thrown by methods such as encodeURI() and decodeURI() when they encounter a malformed URI(即这两个函数碰到了无效的参数). The following example generates a “URIError” while attempting to decode the string “%”. The “%” character represents the beginning of a URI escape sequence. Since nothing follows the “%” in this example, the string is an invalid escape sequence, and therefore a malformed URI component.
EvalError
“EvalError” exceptions are thrown when the eval() function is used improperly. These exceptions are not used in the most recent version of the EcmaScript standard. However, they are still supported in order to maintain backwards compatibility with older versions of the standard.
Handling Exceptions(处理错误的过程)
Now that we know what exceptions are, it’s time to learn how to stop them from crashing our programs(js是通过try...catch...finally..处理错误,来以免错误把程序给搞崩溃). JavaScript handles exceptions via the “try…catch…finally” statement. A generic example statement is shown below.
try {
// attempt to execute this code
} catch (exception) {
// this code handles exceptions
} finally {
// this code always gets executed
}
The first part of a “try…catch…finally” statement is the “try” clause. The “try” clause is mandatory(try是必须的,把可能出错的代码块放在try里面), and is used to delimit a block of code that the programmer suspects could generate an exception. The “try” clause must be followed by one or both of the “catch” and “finally” clauses.
The “catch” Clause
The second part of “try…catch…finally” is the “catch” clause. The “catch” clause is a block of code that is only executed(只有try部分抛出了异常,catch部分的代码才会执行) if an exception occurs in the “try” clause. Although the “catch” clause is optional, it isn’t possible to truly handle an exception without one. This is because the “catch” clause stops the exception from propagating through the call stack, allowing the program to recover. If an exception occurs within the “try” block, then control is immediately passed to the “catch” clause. The exception that occurred(控制权和异常对象都会被传递给catch部分) is also passed to the “catch” block for processing. The following example shows how a “catch” clause is used to handle a “ReferenceError”. Note that the “ReferenceError” object is available in the “catch” clause via the “exception” variable.
try {
foo++; // ReferenceError
} catch (exception) {
var message = exception.message; // handle the exception
}
Complex applications can generate a variety of exceptions. In such cases, the “instanceof” operator can be used to differentiate between the various types of exceptions. In the following example, assume that the “try” clause can generate several types of exceptions. The corresponding “catch” clause uses “instanceof” to handle “TypeError” and “ReferenceError” exceptions separately from all other types of errors.
try {
// assume an exception occurs
} catch (exception) {
if (exception instanceof TypeError) {
// Handle TypeError exceptions
} else if (exception instanceof ReferenceError) {
// Handle ReferenceError exceptions
} else {
// Handle all other types of exceptions
}
}
The “finally” Clause
The last component of the “try…catch…finally” statement is the optional “finally” clause. The “finally” clause is a block of code that is executed after the “try” and “catch” clauses, regardless of any errors(不管是否抛出异常). The “finally” clause is useful for including clean up code (closing files, etc.) that needs to be executed no matter what. Note that the “finally” clause is even executed if an exception occurs that is not caught. In such a scenario, the “finally” clause is executed and then(如果没有catch,在这种情况下抛出的异常会在finally部分执行完之后才抛出) the thrown exception proceeds normally.
One interesting note about the “finally” clause is that it will be executed even if the “try” or “catch” clause executes a “return” statement. For example, the following function returns false because the “finally” clause is the last thing to execute.
function foo() {
try {
return true;
} finally {
return false;
}
}
Throwing Exceptions
JavaScript allows programmers to throw their own exceptions via the appropriately named “throw” statement. This concept can be somewhat confusing to inexperienced developers. After all, developers strive to write code that is free of errors, yet the “throw” statement intentionally introduces them. However, intentionally throwing exceptions can actually lead to code that is easier to debug and maintain(抛出异常相对js直接停下,会更容易调试和维护). For example, by creating meaningful error messages it becomes easier to identify and resolve problems.
Several examples of the “throw” statement are shown below. There is no restriction on the type of data that can be thrown as an exception. There is also no limit on the number of times that the same data can be caught and thrown. In other words, an exception can be thrown, caught, and then thrown again.
throw true;
throw 5;
throw "error message";
throw null;
throw undefined;
throw {};
throw new SyntaxError("useful error message");
While the “throw” statement can be used with any data type, there are certain benefits to using the built-in exception types. Firefox, for example, gives special treatment to those objects by adding debugging information such as the filename and line number where the exception occurred.
As an example scenario, assume that a division operation occurs somewhere in your application. Division can be a nuisance because of the possibility of division by zero. In JavaScript, such an operation results in “NaN”. This can lead to confusing results that are tricky to debug. Things would be much simpler if the application complained loudly about the division by zero. The following “if” statement accomplishes this for us by throwing an exception.
if (denominator === 0)
throw new Error("Attempted division by zero!");
Of course, it might be more appropriate to use a “RangeError” as shown below.
if (denominator === 0)
throw new RangeError("Attempted division by zero!");
Error js内置错误 js处理错误流程 Throw语句的更多相关文章
- 有用的内置Node.js APIs
前言 在构建你的第一个Node.js应用程序时,了解node开箱即用的实用工具和API是很有帮助的,可以帮助解决常见的用例和开发需求. 有用的Node.js APIs Process:检索有关环境变量 ...
- 【ES6】改变 JS 内置行为的代理与反射
代理(Proxy)可以拦截并改变 JS 引擎的底层操作,如数据读取.属性定义.函数构造等一系列操作.ES6 通过对这些底层内置对象的代理陷阱和反射函数,让开发者能进一步接近 JS 引擎的能力. 一.代 ...
- JS内置对象的原型不能重定义?只能动态添加属性或方法?
昨天马上就快下班了,坐在我对面的同事突然问我一个问题,我说“爱过”,哈哈,开个玩笑.情况是这样的,他发现JS的内置对象的原型好像不能通过字面量对象的形式进行覆盖, 只能动态的为内置对象的原型添加属性或 ...
- JS内置对象有哪些?
JS内置对象分为数据封装类对象和其他对象 数据封装类对象:String,Boolean,Number,Array,和Object; 其他对象:Function,Arguments,Math,Date, ...
- js课程 2-8 js内置对象有哪些
js课程 2-8 js内置对象有哪些 一.总结 一句话总结:JS中内置了17个对象,常用的是Array对象.Date对象.正则表达式对象.string对象.Global对象. 1.js常用对象有哪些? ...
- 4、js内置函数
前言:上一篇我介绍了函数的基本概念,和一些简单的Demo.其实很多函数是js内置的,我们无需自己去写,直接拿过来用即可.内置函数分为全局函数和js内置对象的函数区别:全局函数不属于任何一个内置对象.理 ...
- 4月5日--课堂笔记--JS内置对象
JavaScript 4.5 一. JS内置对象 1.数组Array a)创建语法1:var arr=new Array(参数); i. 没有参数:创建一个初始容量为0的数组 ii. ...
- JS内置对象-String对象、Date日期对象、Array数组对象、Math对象
一.JavaScript中的所有事物都是对象:字符串.数组.数值.函数... 1.每个对象带有属性和方法 JavaScript允许自定义对象 2.自定义对象 a.定义并创建对象实例 b.使用函数来定义 ...
- js 内置对象和方法 示例
JS内置函数不从属于任何对象,在JS语句的任何地方都可以直接使用这些函数.JS中常用的内置函数如下: 1.eval(str)接收一个字符串形式的表达式,并试图求出表达式的值.作为参数的表达式可以采用任 ...
- 5月15日上课笔记-js中 location对象的属性、document对象、js内置对象、Date事件对象、
location的属性: host: 返回当前主机名和端口号 定时函数: setTimeout( ) setInterval() 二.document对象 getElementById(); 根据ID ...
随机推荐
- hdu1205(类似 分布垃圾数列)
Problem Description A Fibonacci sequence is calculated by adding the previous two members the sequen ...
- Hackers’ Crackdown-----UVA11825-----DP+状态压缩
题目地址:http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem& ...
- iOS 测试驱动开发
测试驱动开发是敏捷开发的一部分,它一般有“red-green- refactor”步骤 iOS测试驱动开发的工具 一. OCUnit 是Xcode自带的测试工具 其使用步骤分为 1 建立测试的Targ ...
- oralce 10g 官方认证的操作系统版本
oralce 10g 官方认证的操作系统版本 Operating system x86 Red Hat Enterprise Linux AS/ES 3 (Update 4 ...
- Mybatis-Spring SqlSessionTemplate 源码解析
在使用Mybatis与Spring集成的时候我们用到了SqlSessionTemplate 这个类. <bean id="sqlSession" class="or ...
- NodeJS stream 一:Buffer
当年是看了朴灵的九浅一深 NodeJS 入门的 Node, 朴大大的书讲实践很少更多的篇幅用在了讲原理上,道理听了那么多,后来开始在前端工程领域使用 NodeJS 却处处掣肘,总结原因发现 NodeJ ...
- Golang爬虫示例包系列教程(一):pedaily.com投资界爬虫
Golang爬虫示例包 文件结构 自己用Golang原生包封装了一个爬虫库,源码见go get -u -v github.com/hunterhug/go_tool/spider ---- data ...
- java基础练习 11
import java.util.Scanner; public class Eleventh { /*给一个不多于5位的正整数,要求:一.求它是几位数,二.逆序打印出各位数字. (5 分数)*/ p ...
- Factory Pattern(工厂模式)
1.工厂模式简介 工厂模式,专门负责将大量有共同接口的类实例化(用来生产对象).其定义为定义一个用于创建对象的接口,让子类决定实例化那一个类.工厂方法使一个类的实例化延迟到其子类. 工厂模式拥有以下几 ...
- SpringMVC 学习-上传文件分解器 CommonsMultipartResolver 类
Spring 组件 CommonsMultipartResolver 类的主要作用是配置文件上传的一些属性,也可以控制上传文件的大小. 在 springmvc-servlet.xml 配置文件中: & ...