IE 意外处理：有我当关，万错莫开

YES东

摘自：天极网
9 T9 m: b& W. C; o) l7 b   
　
你了解“意外处理”这个概念吗？意外处理是高级编程语言（比如 C++、 Java 以及 VBScript）的一个重要功能，它负责控制当应用程序发生错误时，应该执行什么操作。独立的 JavaScript 并不支持意外处理，这导致一些编程人员更喜欢使用 VBScript 而不是 JavaScript。但是自从出现了IE5，JavaScript 的这方面功能得以补充且增强。通过向语法中增加意外处理功能，Microsoft 将 JavaScript 提升到 C++ 和 Java 的语言标准。我们有理由相信：一些 VBScript 编程人员将很快转移到 JavaScript 的阵营中。
0 {$ ]8 V  |& Q" V! P, k　　详细的内容是：
如何编写一个 JavaScript 导致意外的意外处理代码
如何编写一个用户导致意外的意外处理代码
如何在应用程序中编写用户导致意外的意外处理代码
JavaScript 、C++ 和 Java 的意外处理区别
JavaScript 和 VBScript 的意外处理区别
+ C2 U" M0 n( N: w7 i如何避开 JavaScript 和 VBScript 之间的矛盾
# R5 H; a, `- A4 ?　　在许多编程语言中，当试图执行一个非法指令时，代码都会导致一个运行时间意外。我们可能经历的一个最微不足道的非法操作就是“除以0”错误。JavaScript 不会执行这一操作，它将给结果变量赋值为无穷大。其它的非法操作对于其它编程语言也很普遍，包括 JavaScript。访问一个空指针或一个空对象也是一个例子，访问一个超出数组合法范围的数组元素是另一个例子。
2 X7 G7 h1 K3 U, p1 o　　对于开发人员而言，通常是争取避免发生系统错误的。系统信息通常很含糊，一般的用户看不懂。事实上，系统错误将严重影响一个程序员的声誉，因为它们是臭虫（Bug）的清楚明白的证据。我们希望在代码中查找这些错误，在它们攻击操作系统之前发现它们以避免产生错误信息。在代码中查找意外会造成代码臃肿。当语言不支持意外处理时，将正常的代码流和错误查找混合在一起在所难免。以下的代码将查找两个错误 － 访问一个空对象和超出范围的数组元素：
4 J+ l1 h  y* k& l3 ?* q4 I8 n& Vvar newObject = createObject(dataPiece1, dataPiece2, dataPiece3);
5 ]+ P2 T1 k" u& X( x) J) Fif (newObject == null) {
7 Q! x# a/ \* |* g  // do something here when the object was not created
  y1 v5 d) n( o' g, m0 m% z  W  ...
& j2 U( {) [  f+ i- {3 {6 E' n}
/ d6 M$ {: O1 r) c7 W* N$ relse {
  // getElementIndex return an index or -1 for an error
+ l* l6 s8 v) L' ]0 ~: i( y# P  var index = newObject.getElementIndex();
  if (index == -1) {
7 J: ~9 x: K4 B    // handle the error case
; K) u5 n9 z% J! d    ...
  }
  else {
- R3 c+ D- l) q5 ]; y  {
   // finally, you can do something with index
2 u9 J  z9 t! q1 H! m' `  o   ...
  }
3 i: D. r9 F. V0 j0 m　　在 JavaScript 中支持意外处理的关键所在（在其它语言中也是一样，本文后面将做解释）是 try...catch 语句。 Try 这个关键字引导着一块可能会引起意外的正常处理代码，Catch 关键字引导着一块意外处理代码。一旦 try 这个区中引发了一个意外，程序流程的控制就切换到跟随它的第一个 catch 区域。但是一旦由 JavaScript 引发（这正是程序员所反对的），就没有机制能够断定错误的类型。以下是用来模拟上面流程的 try...catch 代码区：
% ]: z. H8 a  U8 f  |, F# ytry {
- T! b" ^; p8 B  var newObject = createObject(dataPiece1, dataPiece2, dataPiece3);
  var index = newObject.getElementIndex();
! A  J/ T5 i: S" `% ?' g    // do something with index
$ b! p" T( x+ z7 Y+ b. z. F. ~$ r}
catch {
5 K' L$ X* h0 n& o  alert("System Error; Call your sw vendor");
2 ?$ j% F6 a, B; u) @}
' o6 E8 u% g7 {) U, Z% g　　下面是另一个例子，可以在你的计算机上实际运行：
< HTML>
< HEAD>
* s" e4 A; i/ ?$ u/ K( i< TITLE> example 1 < /TITLE>
< /HEAD>
< BODY>
< IMG SRC="doc.gif">
< SCRIPT LANGUAGE="JavaScript1.2">
< !--
# E: a3 |. }1 {. e( w* J( dtry {
- P) U. v& o: b( J) f, L+ O/ Z3 P) a: F  for (image=0; image <  document.images.length + 2; image++) {
. r$ }% K3 ~& {6 c    alert(document.images[image].border);
  }
7 X( O9 X0 _& A0 f}
  ?! Q7 R4 c5 \9 b+ |3 S) lcatch (kuku) {
2 P9 d3 N5 p8 v3 ^: `# z+ k   alert("We have experienced a JavaScript error");
}
// -->
< /SCRIPT>
< /BODY>
< /HTML>
　　这个例子中执行的意外是访问数组边界外的一个数组元素。在页面(doc.gif) 上，图形数是length (1)，所以使用的最大指针是length+1 (2)。请注意传递给 catch （捕捉）区的变量kuku。JavaScript允许传递任何变量类型，在以后的页面中将做解释。虽然我们并不使用这个变量，但你必须要指定一个。
处理程序员导致的意外
8 h) ^: n9 H% Z; ~: c( H　　并不是所有的意外都由 JavaScript 导致，还有一些是由程序员有意制造的。事实上，好的软件工程师把包含大量意外代码的使用作为简化代码的一种方式。其中的原因在于：这样处理后，正常处理流就同查错部分分开了，从而使代码可读性更强，更易于维护和修改。每当要处理一个特定错误时，就可以制造一个意外。你不必使用 if...else 就能在正常流和意外处理流之间切换。一旦一个意外已经发生，流控制就切换到下一个 catch（捕捉）区，在那里进行判断和错误处理。由于程序员完全明白哪个意外是他自己制造的，因此他可以设计这样一个机制，很容易地计算出哪个是意外并向用户提供有用的信息。
　　下面这个简单的例子说明了你可以使用的意外处理机制：
; x6 z0 ~- f3 }& O* a6 t+ e< HTML>
< HEAD>
< TITLE> example 1 < /TITLE>
< /HEAD>
< BODY>
< SCRIPT LANGUAGE="JavaScript1.2">
< !--
" E" I7 h+ s/ b. ?function createException(msgNum, msgText) {
  this.messageNumber = msgNum;
  this.messageText = msgText;
& S* s( h7 i% g/ a# T- o, B1 b: O}
4 k( a* J; E. lfunction triggerException() {
  exceptionObj = new createException(1, "error blablabla");
  throw exceptionObj;
6 q# h6 I0 Q% P6 z, [}
3 i1 R0 z) `6 P7 P5 ^3 _function raiseException() {
  try {
    triggerException();
6 v; X5 a: e. T5 r- t  }
  catch (exceptionObj) {
2 M8 N; d9 }( i3 L    if (exceptionObj instanceof createException) {
! R7 D3 r; |! b8 i$ h      alert("Call the programmer ASAP")
    }
$ A' e/ ~# z3 b3 U3 x& k    else {
      throw exceptionObj;
    }
  }
3 g: q+ Z# i. n$ h; ]6 X6 V) |}
5 L" e; d$ K; [raiseException();
: b+ T/ o6 U' A( X+ @// -->
+ g9 I0 ]- y. e0 A< /SCRIPT>
< /BODY>
< /HTML>
0 k/ Z# X  _2 Y3 v0 M7 t　　主程序只有一行脚本：raiseException()。正如函数名所表示的，这个程序的唯一目的就是要生成一个意外。raiseException() 函数的主体部分包含 try...catch 语句：
function raiseException() {
  try {
    triggerException();
  }
% F# ^& g/ Q. c( x  catch (exceptionObj) {
    if (exceptionObj instanceof createException) {
      alert("Call the programmer ASAP")
    }
. p9 f% b6 b- e: a9 i7 \+ F& B    else {
      throw exceptionObj;
( b& w, ^( k1 \/ ~    }
) e( N; B# ~; G5 |; Q  }
}
0 M4 p* i& R) h; m) M: d9 l& K8 p　　try 代码区创建一个意外对象并触发它：
4 ~, Z) _. X3 u( t) ?5 g) e( N0 Qfunction triggerException() {
) E0 J5 n1 ]2 o! X& @  exceptionObj = new createException(1, "error blablabla");
  throwexceptionObj;
& f3 ?$ k& V3 W8 b}
) ]' |+ V5 C8 Q  j1 d% C4 R3 C/ _0 ^意外对象
$ r6 m% n+ X# ^+ W( i9 U! W1 Y　　意外对象是一个规则的 JavaScript 对象。这时我们将对象命名为 exceptionObj，把它命名为 kuku 也可以。这个意外对象的目的是把数据从 try 代码区运送到 catch 代码区，以将其破译并向用户报告错误的细节。无论你希望意外对象包含多少属性和方法都可以。在我们的例子中定义了两个属性：错误的信息数和其文本信息。对象创建函数是规则的JavaScript：
0 w+ x) m# w; H( q& M: ^0 mfunction createException(msgNum, msgText) {
" x9 ]( k& a/ O5 z$ r; Y  this.messageNumber = msgNum;
  this.messageText = msgText;
7 J3 ^% Y1 w0 L4 a7 R7 A}

catch（捕捉）代码区只有一个参数，可以是任何数据类型。传递到 catch 代码区的对象与错误数和错误信息相通讯。注意首先要进行对象类型确认：
if (exceptionObj instanceof createException)
　　为了区别 JavaScript 和程序员查出的错误，这种确认是必要的。正如它的名字所说明的，catch 代码区捕捉相关的 try 代码区出来的所有意外。为了让用户获得正确的错误信息，我们需要确定意外是由 JavaScript 导致的（例如访问超出范围的数组元素）还是由程序员导致的。最好的方法是证实意外对象是否与我们创建它们所用的对象属于同一类型。如果类型相匹配，我们就可以肯定意外是要我们去处理的。在这里的例子中，仅向用户显示了一个信息：
if (exceptionObj instanceof createException) {
  alert("Call the programmer ASAP")
$ l+ l8 A; c  I" v" l}
8 [6 G( ~* i6 Y* t8 O　　如果类型不匹配，我们就继续向上制造意外。意外处理是嵌套的。你可以将一个 try...catch 语句放在另一个 try 代码区里，这样每当从第一个 catch 代码区制造一个意外时，它就被其母 catch 代码区所捕捉。在我们的例子中，由于没有更高层次的 try...catch 语句，因此意外就由操作系统所处理。操作系统负责处理那些以前没有被更低层次的 catch 代码区处理过的意外。下面是我们例子中的意外抛出：
else {
) L- x1 G. @7 \) o+ u% y  throw exceptionObj;
}
) V  y- X& v- K　　下面我们来增强一点脚本功能。在上面的脚本中，我们指定了信息数以及创建意外对象时的描述：
exceptionObj = new createException(1, "error blablabla");
　　但是这时 triggerException() 和 raiseException() 函数只适用于一种意外类型。为了让它们更通用一些，我们将错误数和文本参数增加到上面的两个函数中：
< HTML>
< HEAD>
< TITLE> example 1 < /TITLE>
< /HEAD>
< BODY>
< SCRIPT LANGUAGE="JavaScript1.2">
% L2 H0 Z% A$ v8 `< !--
8 f2 t- N; f1 O0 P/ h8 X$ Zfunction createException(msgNum, msgText) {
. x. h9 N, D# R+ z$ a9 b  this.messageNumber = msgNum;
' S+ a/ L2 S! G$ {/ ^: m  this.messageText = msgText;
}
function triggerException(messageNum, messageTxt) {
/ r" A- v/ ?% }8 X0 m; l* J  exceptionObj = new createException(messageNum, messageTxt);
/ m6 `# Q* c5 e8 F6 Z) U  throw exceptionObj;
/ ]7 ]* z# Z  ?( n}
3 F$ H4 }- H) Q) E9 z9 Xfunction raiseException(num, message) {
4 V; x* H5 X5 a/ P9 y. i5 x, e9 v! v  try {
    triggerException(num, message);
$ ]1 f. K7 g+ Q  }
3 n, ]5 u  o4 @1 K  catch (exceptionObj) {
* P% Y" u% _) c" S& }) J    if (exceptionObj instanceof createException) {
      alert("Call the programmer ASAP")
    }
9 d$ i% ^( j$ Z$ Z( P. W9 b    else {
      throw exceptionObj;
$ s, b) ~8 @# m5 N+ e    }
  }
}
6 `# n4 U" ~) B0 {. Z. G9 ^5 nraiseException(1, "Doc JavaScript Column 36");
// -->
( ], s. h& b' y9 {  f6 c  L< /SCRIPT>
< /BODY>
# N! S3 K6 V* M; v2 F/ c< /HTML>
程序员制造的意外：一个真实的例子（一）
　　现在，我们使用前面页面中的意外处理函数来处理一个更加实际的例子。假设你的一个页面中有一个
< IMG> 标记，程序接收一些属性名并提取出相应的图形对象属性值。意外有可能是由访问不正确的属性和范围以外的数组元素引起的。下面是完整的代码：
< HTML>
< HEAD>
5 ^, n& g+ ?2 j1 x< TITLE> example 1 < /TITLE>
8 }3 @* h6 v9 J8 C1 a< /HEAD>
< BODY>
< IMG SRC="doc.gif">
< SCRIPT LANGUAGE="JavaScript1.2">
% K# k& j0 ]9 Z' ?& l& `< !--
3 S! q, m4 d8 t2 [2 Q) [7 xfunction createException(msgNum, msgText) {
  this.messageNumber = msgNum;
$ [# ?' _( I' ]( S  this.messageText = msgText;
}
. v* n2 c- c$ ]  ~( C# i2 vfunction triggerException(messageNum, messageTxt) {
  exceptionObj = new createException(messageNum, messageTxt);
+ X( k7 v8 S) @; v$ N- D/ ^  throw exceptionObj;
1 V! G/ G/ {* v1 D- p5 z7 Q}
function raiseException(num, message) {
  try {
    triggerException(num, message);
  }
" B7 ^1 z6 s$ F2 _  catch (exceptionObj) {
    if (exceptionObj instanceof createException) {
2 J' t8 O9 Z0 T8 q+ q% H% N      alert("Call the programmer ASAP")
+ u/ B+ t) e$ ~% T; B' ]    }
    else {
      throw exceptionObj;
    }
  }
}
5 g* |9 n0 w9 F5 w# ~+ DfieldNames = new Array("border", "complete", "height", "hspace",
; o5 S, ~2 [0 ], M% X"lowsrc", "name", "src", "vspace", "width");
" D) }  S/ d8 H- z+ P+ i$ T& atry {
  for (image=0; image <  document.images.length + 1; image++) {
    for (i=0; i <  fieldNames.length; i++) {
' p% Y; x: M* N8 A2 M( U( ?      if (document.images[image] == null)
2 R+ z" @( ]/ g6 }( T3 `# k, D  t9 l9 _triggerException( 98, "illegal access to images array");
/ M) X" ]) h, g  k      if (eval("document.images[image]." + fieldNames) != null)
alert(fieldNames + " is " + eval("document.images[image]." + fieldNames))
      else triggerException(i, "field name " + fieldNames  + " is not legal");
' ~) D- w$ c$ g: |    }
  }
& y/ C0 a2 G4 v}
, G! i- s* V  ^8 {* }* v9 {" Pcatch (exceptionObj) {
  if (exceptionObj instanceof createException) {
    if (exceptionObj.messageNumber > 0 && exceptionObj.messageNumber <  9)
alert("Problem in property: " + exceptionObj.messageText)
6 V/ c4 x; r  R% X9 @, U8 P0 y    else if (exceptionObj.messageNumber <  = 98
" H+ g1 j- q( e. V( _/ c&& exceptionObj.messageNumber  >= 97)
1 R2 F; g# U( |" y alert("Problem in images array: " + exceptionObj.messageText)
           else raiseException(99, "Catch All");;
1 X. w2 [/ q& O" q7 R  }
, t% V" a$ {! b* k$ y) S! P}
; U+ _! J  j& b% S) d//raiseException(1, "Doc JavaScript Column 36");
// -->
< /SCRIPT>
< /BODY>
< /HTML>
0 u$ p( m  D% ?' H1 W, T: n3 b" }程序员制造的意外：一个真实的例子（二）
. }- Z0 k% t& }6 Q　　首先我们定义数组 fieldNames。Try 代码区包括两个嵌套循环，外面一个在页面的图形之间循环：
for (image=0; image <  document.images.length + 1; image++) {
　　里面的循环在 fieldNames 元素之间循环：
for (i=0; i <  fieldNames.length; i++) {
　　我们在循环内部检查2个意外。第一检验是否有访问范围外数组元素的尝试。当有一个无效尝试时，我们起动一个意外：
if (document.images[image] == null)
# _1 C9 f9 C- R1 m( {! @" ], ?triggerException( 98, "illegal access to images array");
　　第二个检验打印相关对象属性的值或当域名与任何对象的域名都不匹配时，起动一个意外：
if (eval("document.images[image]." + fieldNames) != null)
alert(fieldNames + " is " + eval("document.images[image]." + fieldNames))
      else triggerException(i, "field name " + fieldNames  + " is not legal");
　　catch（捕捉）代码区对意外对象进行解密。首先我们检验对象是否是正确的类型：
if (exceptionObj instanceof createException) {
　　前面已经解释过，这种检验对于区分 JavaScript 错误和用户错误是至关重要的。一旦我们知道它是一个用户导致的意外后，我们就检验错误数是否在1—9之间，并打印一个适当的信息：
if (exceptionObj.messageNumber > 0 && exceptionObj.messageNumber <  9)
alert("Problem in property: " + exceptionObj.messageText)
0 `9 H! W+ v+ }1 x" [5 R0 P　　我们检验错误数是否是97或98，并打印一个与意外相关的信息：
/ [5 A7 l* Y; I8 Lelse if (exceptionObj.messageNumber <  = 98
) d) A7 f  w- Q. b( c" J9 r5 K$ t) @&& exceptionObj.messageNumber  >= 97)
' d( ?! d( {8 P6 I6 Z! I' calert("Problem in images array: " + exceptionObj.messageText)
2 t" D  F3 x+ G; t  h　　如果意外对象不与任何错误类型相匹配，我们就触发一个用操作系统处理的普通意外：
" I5 \4 l; W! _" Y- [2 Lelse raiseException(99, "Catch All")
　　一定要记住，如果你不处理这个意外，别人就会处理。操作系统会处理所有没人理会的意外。
与 Java、 C++ 之比较
8 i# a8 w" s' ~  c, h' S( R　　请不要吃惊，你会发现：Java 和 C++ 的意外处理语法与 JavaScript 的非常相似。同 JavaScript 中一样，它们也是以 try..catch 语句为中心的。主要的区别在于 catch 的变量。就象前面页面中所解释的一样，在 JavaScript 中这个变量可以是任何数据类型，可以是一个对象、一个字符串、一个整数或任何其它被支持的类型。实际上，JavaScript 不支持类型声明，所以就无法声明 catch 的变量类型。在 Java 中，catch 的变量是 Java 类的一个例示，将标准 Java 扩展成可导致的类。Catch 语句应该是这样的：
catch (objectType exception)
6 w& l3 \7 u+ W" M/ E+ B7 V　　其中意外是一个 objectType 类型的对象。C++ 就不是那么限制了，Catch 的变量可以是标准 C++ 意外类的一个例示，或者是任何 C++ 类型：
% u3 [0 |! i! V" T* d+ ^& f) ncatch (char *message)
　　由于在 JavaScript 中没有类型声明，在每个 try 代码区它只支持一个 catch 代码区。在前面页面中已经显示了，当我们的意外处理要依赖于变量类型时，我们就使用 instanceOf 函数来检查它是否是正确的类型。在 C++ 和 Java 中，对每一个 try 代码区你可以使用多个 catch 代码区。每个 catch 代码区负责处理适当类型的意外。假如你想处理 char 类型和 myException 类型的意外：
: B; L  [, Z: E3 L) B- m* |try {
2 n" H) r$ h9 r! P6 P5 p2 H. }   // following function can throw exceptions of type char or myException
   doSomeThingUseful();
6 [4 h" |1 e+ }) S}
# ]/ ?9 [- D) m. j6 Z1 w& dcatch (char *exceptionString) {
   // handle the case  that exception is a string
0 a& [2 [# J0 I/ M, n9 |}
" d0 [& M" e7 vcatch (myException exceptionObject)
   // handle the case that exception is an instance of type myException
, J, ^, U/ }2 A7 Z3 K: ]}
5 O" G( l  B. z2 f: n+ q/ J- J　　在 JavaScript 中，你要用这些代码行：
try {
   // following function can throw exceptions of type char or myException
& @) [% E! T4 P  j% a7 E   doSomeThingUseful();
3 ]/ @5 j/ T: ?# @4 X6 V2 e}
( m5 m9 \4 o$ }* b# f; V/ Y" Ycatch (exception) {
5 l4 F9 G" c7 V; O/ f   // verify exception is of myExceptionObject type
2 o8 \5 ^2 N1 d7 l- k: l& c   if (exception instanceOf myExceptionObject) {
     if (exception.kind == "string") {
2 H) t6 O9 w" F4 g: Z! H% @       // handle the sting exception
     }
1 j! v4 ?8 _9 Z0 ~     else if (exception.kind == "myException") {
8 E% L# T( m9 b% b$ _# {6 e' p       // handle the object exception
     }
, H) Y0 l1 f. \1 q, J) s; N}
　　另一个区别是 Java 和 C++ 支持意外 catch-all（全捕捉），也就是在一个 catch 代码区捕捉全部的意外。在 Java 中的语法是：
- _2 r0 {: z& R" Q2 scatch (Throwable t) {
  // Handle all cases
}
　　其中 Throwable 是一个事先定义的 Java 类。在 C++ 中相应的 catch-all 语法是：
catch ( ... ) {
# N2 I; Z/ {, c+ c7 f0 T3 y  // Handle all cases
}
　　正如上面所说过的，由于 JavaScript 只支持一个 catch 代码区，根据定义，所有的意外都是由同一个 catch 代码区捕捉的。你应该使用：
; r2 e, B, s8 {1 a, Ocatch ( exception ) {
  // Handle all exceptions
% Q* v( {0 F* h8 T/ X  q2 t$ {}
　　同样的区别在 C++、 Java 和 JavaScript 的导致语句中也存在。在三种语言中语法是一样的：
throw exceptionObject;
　　由于 Java 只能捕捉 Throwable 类型的意外， exceptionObject 必须是这种类型。C++ 和 JavaScript 可以抛出任何数据类型，包括字符串、整数、对象等。
　　C++ 和 Java 在意外向上繁殖的方式上与 JavaScript 也不同。如果一个意外不在 C++ 或 Java 中处理，那么在调用方案中，它就自动被提升到一个更高层次，如调用函数、主程序或浏览器。在 JavaScript 中，如果你希望一个更高层次处理这个意外的话，就不得不自己来提升这个意外。前面页中已经显示过，你应该使用这个简单的语法：
* Y+ `6 U7 v' j- athrow exceptionObj;
　　最后一个区别是 C++ 和 Java 不支持 try..catch 代码区的嵌套。而在 JavaScript 中，你可以将一个 try...catch 语句装在另一个语句的 try 或 catch 区内。
与 VBScript 相比较
　　VBScript 对意外处理的支持程度要低于 JavaScript 的新意外处理方式。如果到现在还因为喜欢其错误处理而坚持使用VBScript 的话，你就没有充分的理由了，因为 JavaScript 现在可以处理意外了。VBScript 意外处理的原理很简单，调用函数然后检验是否有错误。
9 p3 S: O" z7 x+ b  |: p( F2 y　　JavaScript 是用 catch 语句来捕捉意外的，而 VBScript 是用 On Error 语句来捕捉的。省略掉 On Error 语句会将所有意外传播到浏览器，浏览器随之向用户显示一个错误对话框。事实上， JavaScript 也有这种行为。如果不使用 try...catch 语句，所有意外都会由浏览器来处理并向用户显示一个错误信息。前面已经解释过，用户并不十分清楚他该向哪里去，因此必须要赶在浏览器之前对意外进行处理。如果考虑为用户处理意外，这样的 Web 站点就属于等级较高的。
　　On Error 语句很直观：
8 t- V7 ~1 f$ {! r( {) fOn Error Resume Next
6 L7 i' [& S, W2 I　　这个语句只是打开了错误处理。如果接下来的行中的任何位置出现了意外，运行就从紧接着出错行的那行程序继续执行，出错行指的是你调用了引起意外的函数的行。在 JavaScript 中与此相当的是 try...catch 语句：
try {
  // Exceptions in this block will be handled by the following catch block.
! B) V# I; x1 j; `0 m# P  // Any exception will quit this block and switch control to the catch block
" T: k) D+ m5 _1 x7 e& {3 F}
& v, c8 C. F$ B1 y' ]9 Z3 o) scatch (exceptionObj) {
  // Handle exception from the try block above
  // Code in this block will be executed before the line immediately
  //             following the culprit line that caused the exception
}
　　在 VBScript 和 JavaScript 中捕捉意外的主要区别是：一旦你打开了错误处理，在 VBScript 中就不能将其关闭。在VBScript中，错误处理只能在函数结束时才能关闭。而在 JavaScript 中，你可以将你想要打开错误处理的那个语句区包含在 try 代码区内。简单地说，在VBScript 和 JavaScript 中，你都可以控制一个区的开始。而只有在 JavaScript 中你才能控制一个区的结束。在 VBScript 中，区的结束就是函数的结束。
$ a5 p# S6 J) J, K' }& \8 F, L: ^　　在 VBScript 中处理意外比捕捉它们要复杂得多。在每个可疑语句之后，你都要明确地检查错误：
` turn on error handling
On Error Resume Next
; n5 \0 s( L3 ~- }( B` clear the Err object
Err.Clear
- h% B" ~: d0 m. n. S3 @0 v' O- k` The following statement or procedure call might cause an exception
Kuku()
` Check if an exception was raised
6 m: W# H) i4 l2 TIf Err.Number >  0 then
6 D, i/ i* G" U$ E5 P. I- i9 r  ` handle the exception here
End If
　　你已经注意到了 Err 对象。 VBScript 中的意外处理就是以它为基础的。它有6个属性是由最近的意外设置的： Number（数量）、 Description（描述）、 Source（来源）、 HelpFile（帮助文件）、 HelpContext（帮助上下文）、 LastDLLError（上一个DLL错误）。 JavaScript 的 Error 对象共享这些属性中的两个：