js如何处理网络异常

‘壹’ 电脑弹出JavaScript警告“无法获取修改密码强度信息，网络异常”，校园网就上不去了，怎么办

可能是修改密码后延迟问题 建议先用网页登录, 大概 半天的时间在用客户端登陆 客户端的密码同时也要修改

‘贰’ javascript中异步操作的异常怎么处理

一、JavaScript异步编程的两个核心难点
异步I/O、事件驱动使得单线程的JavaScript得以在不阻塞UI的情况下执行网络、文件访问功能，且使之在后端实现了较高的性能。然而异步风格也引来了一些麻烦，其中比较核心的问题是：
1、函数嵌套过深
JavaScript的异步调用基于回调函数，当多个异步事务多级依赖时，回调函数会形成多级的嵌套，代码变成

金字塔型结构。这不仅使得代码变难看难懂，更使得调试、重构的过程充满风险。
2、异常处理
回调嵌套不仅仅是使代码变得杂乱，也使得错误处理更复杂。这里主要讲讲异常处理。
二、异常处理
像很多时髦的语言一样，JavaScript 也允许抛出异常，随后再用一个try/catch
语句块捕获。如果抛出的异常未被捕获，大多数JavaScript环境都会提供一个有用的堆栈轨迹。举个例子，下面这段代码由于'{'为无效JSON
对象而抛出异常。
?

12345678

function JSONToObject(jsonStr) { return JSON.parse(jsonStr);}var obj = JSONToObject('{');//SyntaxError: Unexpected end of input//at Object.parse (native)//at JSONToObject (/AsyncJS/stackTrace.js:2:15)//at Object.<anonymous> (/AsyncJS/stackTrace.js:4:11)

堆栈轨迹不仅告诉我们哪里抛出了错误，而且说明了最初出错的地方：第4 行代码。遗憾的是，自顶向下地跟踪异步错误起源并不都这么直截了当。
异步编程中可能抛出错误的情况有两种：回调函数错误、异步函数错误。
1、回调函数错误
如果从异步回调中抛出错误，会发生什么事？让我们先来做个测试。
?

1234567

setTimeout(function A() { setTimeout(function B() { setTimeout(function C() { throw new Error('Something terrible has happened!'); }, 0); }, 0);}, 0);

上述应用的结果是一条极其简短的堆栈轨迹。
?

12

Error: Something terrible has happened!at Timer.C (/AsyncJS/nestedErrors.js:4:13)

等等，A 和B 发生了什么事？为什么它们没有出现在堆栈轨迹中？这是因为运行C 的时候，异步函数的上下文已经不存在了，A 和B 并不在内存堆栈里。这3
个函数都是从事件队列直接运行的。基于同样的理由，利用try/catch
语句块并不能捕获从异步回调中抛出的错误。另外回调函数中的return也失去了意义。
?

1234567

try { setTimeout(function() { throw new Error('Catch me if you can!'); }, 0);} catch (e) {console.error(e);}

看到这里的问题了吗？这里的try/catch 语句块只捕获setTimeout函数自身内部发生的那些错误。因为setTimeout
异步地运行其回调，所以即使延时设置为0，回调抛出的错误也会直接流向应用程序。
总的来说，取用异步回调的函数即使包装上try/catch 语句块，也只是无用之举。（特例是，该异步函数确实是在同步地做某些事且容易出错。例如，Node
的fs.watch(file,callback)就是这样一个函数，它在目标文件不存在时会抛出一个错误。）正因为此，Node.js
中的回调几乎总是接受一个错误作为其首个参数，这样就允许回调自己来决定如何处理这个错误。
2、异步函数错误
由于异步函数是立刻返回的，异步事务中发生的错误是无法通过try-catch来捕捉的，只能采用由调用方提供错误处理回调的方案来解决。
例如Node中常见的function (err, ...)
{...}回调函数，就是Node中处理错误的约定：即将错误作为回调函数的第一个实参返回。再比如HTML5中FileReader对象的onerror函数，会被用于处理异步读取文件过程中的错误。
举个例子，下面这个Node 应用尝试异步地读取一个文件，还负责记录下任何错误（如“文件不存在”）。
?

1234567

var fs = require('fs'); fs.readFile('fhgwgdz.txt', function(err, data) { if (err) { return console.error(err); }; console.log(data.toString('utf8'));});

客户端JavaScript 库的一致性要稍微差些，不过最常见的模式是，针对成败这两种情形各规定一个单独的回调。jQuery 的Ajax
方法就遵循了这个模式。
?

1234

$.get('/data', { success: successHandler, failure: failureHandler});

不管API 形态像什么，始终要记住的是，只能在回调内部处理源于回调的异步错误。
三、未捕获异常的处理
如果是从回调中抛出异常的，则由那个调用了回调的人负责捕获该异常。但如果异常从未被捕获，又会怎么样？这时，不同的JavaScript环境有着不同的游戏规则……
1. 在浏览器环境中
现代浏览器会在开发人员控制台显示那些未捕获的异常，接着返回事件队列。要想修改这种行为，可以给window.onerror
附加一个处理器。如果windows.onerror 处理器返回true，则能阻止浏览器的默认错误处理行为。
?

123

window.onerror = function(err) { return true; //彻底忽略所有错误};

在成品应用中， 会考虑某种JavaScript 错误处理服务， 譬如Errorception。Errorception
提供了一个现成的windows.onerror 处理器，它向应用服务器报告所有未捕获的异常，接着应用服务器发送消息通知我们。
2. 在Node.js 环境中
在Node 环境中，window.onerror 的类似物就是process 对象的uncaughtException 事件。正常情况下，Node
应用会因未捕获的异常而立即退出。但只要至少还有一个uncaughtException 事件处理
器，Node 应用就会直接返回事件队列。
?

123

process.on('uncaughtException', function(err) { console.error(err); //避免了关停的命运！});

但是，自Node 0.8.4 起，uncaughtException 事件就被废弃了。据其文档所言，对异常处理而言，uncaughtException
是一种非常粗暴的机制，请勿使用uncaughtException，而应使用Domain 对象。
Domain 对象又是什么？你可能会这样问。Domain 对象是事件化对象，它将throw 转化为'error'事件。下面是一个例子。
?

123456789

var myDomain = require('domain').create();myDomain.run(function() { setTimeout(function() { throw new Error('Listen to me!') }, 50);});myDomain.on('error', function(err) { console.log('Error ignored!');});

源于延时事件的throw 只是简单地触发了Domain 对象的错误处理器。
Error ignored!
很奇妙，是不是？Domain 对象让throw
语句生动了很多。不管在浏览器端还是服务器端，全局的异常处理器都应被视作最后一根救命稻草。请仅在调试时才使用它。
四、几种解决方案
下面对几种解决方案的讨论主要集中于上面提到的两个核心问题上，当然也会考虑其他方面的因素来评判其优缺点。
1、Async.js
首先是Node中非常着名的Async.js，这个库能够在Node中展露头角，恐怕也得归功于Node统一的错误处理约定。

而在前端，一开始并没有形成这么统一的约定，因此使用Async.js的话可能需要对现有的库进行封装。
Async.js的其实就是给回调函数的几种常见使用模式加了一层包装。比如我们需要三个前后依赖的异步操作，采用纯回调函数写法如下：
?

12345678910111213141516

asyncOpA(a, b, (err, result) => { if (err) { handleErrorA(err); } asyncOpB(c, result, (err, result) => { if (err) { handleErrorB(err); } asyncOpB(d, result, (err, result) => { if (err) { handlerErrorC(err); } finalOp(result); }); });});

如果我们采用async库来做：
?async.waterfall([ (cb) => { asyncOpA(a, b, (err, result) => { cb(err, c, result); }); }, (c, lastResult, cb) => { asyncOpB(c, lastResult, (err, result) => { cb(err, d, result); }) }, (d, lastResult, cb) => { asyncOpC(d, lastResult, (err, result) => { cb(err, result); }); }], (err, finalResult) => { if (err) { handlerError(err); } finalOp(finalResult);});

可以看到，回调函数由原来的横向发展转变为纵向发展，同时错误被统一传递到最后的处理函数中。

其原理是，将函数数组中的后一个函数包装后作为前一个函数的末参数cb传入，同时要求：
每一个函数都应当执行其cb参数;cb的第一个参数用来传递错误。我们可以自己写一个async.waterfall的实现：
?let async = { waterfall: (methods, finalCb = _emptyFunction) => { if (!_isArray(methods)) { return finalCb(new Error('First argument to waterfall must be an array of functions')); } if (!methods.length) { return finalCb(); } function wrap(n) { if (n === methods.length) { return finalCb; } return function (err, ...args) { if (err) { return finalCb(err); } methods[n](...args, wrap(n + 1)); } } wrap(0)(false); }};

Async.js还有series/parallel/whilst等多种流程控制方法，来实现常见的异步协作。
Async.js的问题：
在外在上依然没有摆脱回调函数，只是将其从横向发展变为纵向，还是需要程序员熟练异步回调风格。

错误处理上仍然没有利用上try-catch和throw，依赖于“回调函数的第一个参数用来传递错误”这样的一个约定。
2、Promise方案
ES6的Promise来源于Promise/A+。使用Promise来进行异步流程控制，有几个需要注意的问题，

把前面提到的功能用Promise来实现，需要先包装异步函数，使之能返回一个Promise：
?

12345678910

function toPromiseStyle(fn) { return (...args) => { return new Promise((resolve, reject) => { fn(...args, (err, result) => { if (err) reject(err); resolve(result); }) }); };}

这个函数可以把符合下述规则的异步函数转换为返回Promise的函数：
回调函数的第一个参数用于传递错误，第二个参数用于传递正常的结果。接着就可以进行操作了：
?

123456789101112131415

let [opA, opB, opC] = [asyncOpA, asyncOpB, asyncOpC].map((fn) => toPromiseStyle(fn)); opA(a, b) .then((res) => { return opB(c, res); }) .then((res) => { return opC(d, res); }) .then((res) => { return finalOp(res); }) .catch((err) => { handleError(err); });

通过Promise，原来明显的异步回调函数风格显得更像同步编程风格，我们只需要使用then方法将结果传递下去即可，同时return也有了相应的意义：

在每一个then的onFullfilled函数（以及onRejected）里的return，都会为下一个then的onFullfilled函数（以及onRejected）的参数设定好值。
如此一来，return、try-catch/throw都可以使用了，但catch是以方法的形式出现，还是不尽如人意。
3、Generator方案
ES6引入的Generator可以理解为可在运行中转移控制权给其他代码，并在需要的时候返回继续执行的函数。利用Generator可以实现协程的功能。
将Generator与Promise结合，可以进一步将异步代码转化为同步风格：
?

1234567891011

function* getResult() { let res, a, b, c, d; try { res = yield opA(a, b); res = yield opB(c, res); res = yield opC(d); return res; } catch (err) { return handleError(err); }}

然而我们还需要一个可以自动运行Generator的函数：
?

2324252627282930

function spawn(genF, ...args) { return new Promise((resolve, reject) => { let gen = genF(...args); function next(fn) { try { let r = fn(); if (r.done) { resolve(r.value); } Promise.resolve(r.value) .then((v) => { next(() => { return gen.next(v); }); }).catch((err) => { next(() => { return gen.throw(err); }) }); } catch (err) { reject(err); } } next(() => { return gen.next(undefined); }); });}

用这个函数来调用Generator即可：
?

1234567

spawn(getResult) .then((res) => { finalOp(res); }) .catch((err) => { handleFinalOpError(err); });

可见try-catch和return实际上已经以其原本面貌回到了代码中，在代码形式上也已经看不到异步风格的痕迹。
类似的功能有co/task.js等库实现。
4、ES7的async/await
ES7中将会引入async function和await关键字，利用这个功能，我们可以轻松写出同步风格的代码，

同时依然可以利用原有的异步I/O机制。
采用async function，我们可以将之前的代码写成这样：
?

12345678910111213

async function getResult() { let res, a, b, c, d; try { res = await opA(a, b); res = await opB(c, res); res = await opC(d); return res; } catch (err) { return handleError(err); }} getResult();

和Generator & Promise方案看起来没有太大区别，只是关键字换了换。
实际上async
function就是对Generator方案的一个官方认可，将之作为语言内置功能。
async function的缺点：
await只能在async function内部使用，因此一旦你写了几个async function，或者使用了依赖于async
function的库，那你很可能会需要更多的async function。
目前处于提案阶段的async
function还没有得到任何浏览器或Node.JS/io.js的支持。Babel转码器也需要打开实验选项，并且对于不支持Generator的浏览器来说，还需要引进一层厚厚的regenerator
runtime，想在前端生产环境得到应用还需要时间。
以上就是本文的全部内容，希望对大家的学习有所帮助。

‘叁’ jquery或者js如何判断当前网络是否畅通，我的页面是给手机用的

代码逻辑如下：

jQuery.ajax({
url:"",
dataType:"",
type:"",
success:function(data){
//...调用成功代码
},
error:function(XMLHttpRequest,textStatus,errorThrown){
alert(XMLHttpRequest.status);//查看请求状态
//调用失败代码
}
});

通过ajax的error参数判断当前网络状况。

‘肆’ 怎么用js脚本判断自动检测网络连接是否正常

用AJAX

‘伍’ 使用JS在浏览器中判断当前网络连接状态的几种方法

通过navigator.onLine判断当前网络状态：
if(navigator.onLine){

...}else{ ...}

非常简单，但是并不准确-根据MDN的描述：

navigator.onLine只会在机器未连接到局域网或路由器时返回false，其他情况下均返回true。

也就是说，机器连接上路由器后，即使这个路由器没联通网络，navigator.onLine仍然返回true。

‘陆’ 如何更好地用JavaScript中的异常抛出

虽然最近几年JavaScript有了很多进步，但是相比于其它语言的开发者，JavaScript开发者仍然只有少得可怜的调试工具。因此在JavaScript中throw
error就显得比其它语言更有价值。我们可以用throw关键字来抛出一个对象。我们可以抛出任何类型的对象，不过Error对象是最常用的：

throw new Error("Something bad happened.")

当我们用这样的方式抛出错误，而这个错误又不被try-catch捕获时，浏览器就会用其通常的方式显示上面的错误信息(Something
bad
happened)。在IE里会在浏览器的左下角出现一个小图标，当双击图标时会弹出一个带着上面错误提示的对话框；安装有Firebug插件的火狐浏览器会在控制台显示错误信息；Safar和Chrome会在Web

Inspector中显示；Opera会在错误控制台显示。一句话，它们会像你没有抛出错误时一样处理。但不同的是它会通过浏览器向你提供具体的信息，而不是一个发生错误的行列号。你可以为错误信息加入任何需要的信息，来帮你成功解决问题。我建议在错误信息中提供发生错误的函数名称以及错误原因。看下面这个函数：

function addClass(element, className){

element.className += " " + className;

}

这个函数的功能是向一个给定的element加入新的CSS
class(这在JavaScript中非常普遍)。但如果element是null的时候会发生什么？你会得到一个这样的错误提示“object
expected”，很隐晦。然后你需要查看执行堆栈(如果浏览器支持这个功能)来准确定位错误的源头。如果我们抛出一个错误调试就变得简单了：

function addClass(element, className){

if (element != null && typeof element.className == "string"){

element.className += " " + className;

} else {

throw new Error("addClass(): First arg must be a DOM element.");

}

}

先不讨论如何精确的判断对象是否是一个DOM
element，这个方法现在能够在非法的element参数传入时提供一个更明确的错误信息。看到了如此详尽的错误描述你就能立刻找到错误的源头了。我习惯把throw
error看作是贴一个任务贴纸，告诉我错误的原因。

懂得了如何throw error只是事情的一半；懂得何时throw
error则是另一半。因为JavaScript并不对参数进行类型检查，许多开发者都错误的认为他们应该在所有的函数中进行该检查。那样的话是不实际的，而且会降低脚本的执行效率。问题的关键在于找到最有可能出错的代码部分，并且只在那里throw
error。一句话就是只在已经发生error的地方throw error。

如果一个函数只被一个已知的实体调用，那么错误检查基本上是没有必要的(例如私有函数就是这样)；如果你不能事先确定所有函数被调用的地点，那么你需要进行错误检查并throw自己的error。throw
error最好的地方是功能函数，那些是脚本环境基本组成部分的，而且可以在任意地点被调用的函数。JavaScript的库函数就是这样的例子。

所有JavaScript的库函数都应当为已知的错误条件从它们的公共接口throw
error。对于YUI，jQuery以及Dojo等等，我们无法确定会在何时何处调用它们的库函数。所以当你犯错时对你进行提示就是这些库函数的任务。为什么呢？因为你不可能到库函数内部去找出错误所在。error的调用堆栈应当终止于库函数接口，不要再深入。没有什么比在12层函数嵌套中寻找错误更遭的事了；库函数开发人员有责任预防这种事情的发生。

这一条同样适用于私有的JavaScript库函数。许多Web应用程序都有它们自己专属的JavaScript库，可能是通过这些库来构建的，也可能是用库来代替公共的操作。库函数的作用是降低开发难度，这是通过向人们提供其抽象表达而不是复杂的实现细节来实现的。throw
error可以让这些复杂的实现隐藏在安全的地方不被开发者发现。

JavaScript同样提供了try-catch语句，用来在浏览器处理之前捕获被throw的error。开发者常常会为到底是仅仅throw
error还是用try-catch将其捕获而犹豫不决。我们应当只在程序栈的最底层throw
error，就像前面提到的，最典型的就是JavaScript库函数。所有应用程序都应当在逻辑上具有处理error的能力，因此应当在底层模块中捕获error。

在应用程序逻辑中我们总是知道为什么要调用某个函数，因此它们非常适合处理error。有一点要引起注意，就是永远不要在try-catch结构中使用空的catch语句；你应当用某种方法处理错误。这钟处理在开发中和最终生产时会有些不同，但必须进行处理。当错误发生时，不应当仅仅将其包裹在try-catch里不管——这是掩盖错误而不是解决错误。
在JavaScript中throw error是一门艺术。在代码中找到适当的throw error的地点会花费一些时间。不过一旦你找到了这些地点，你的调试时间就会大大降低，而你对代码的满意度会获得提升。

‘柒’ 很抱歉,您的电脑或所在的局域网络有异常的访问,此刻我们无法响应您的请求.

目前，当某个IP段在短时间内向网络发出大量连接请求，即会受到网络局域网异常访问屏蔽策略的限制。

有两个方法可以解决：
1.PHP抓取页面受限的破解方法
在使用PHP抓取网络知道问题页时，由于PHP程序抓取速度过快，导致被屏蔽，采用以下的方式解决
抓取页面需采用fsockopen方式，使用file_get_contents无法设置请求头
fsockopen函数的使用方法请自行查阅，例子中的geturlcont函数为自定义函数，核心即为fsockopen，geturlcont函数的原型
geturlcont($url, $referer = "" ,$cookie),$url为待抓取的页面的url，$referer为传递的referer参数(主要用于防止抓到的是网络首页)，$cookie为重要的一个参数，用于破解局域网异常访问屏蔽功能
2.Chrome扩展直接跳转方案

在另一个程序中，不需要抓取页面内容，但会同时打开数十页的网络页面，同样可能会造成短时间内请求过多导致的屏蔽，解决方法是通过Chrome扩展的js注入功能实现

附（网络屏蔽页的代码）：

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>网络--您的访问出错了</title>
<style>
body{text-align:center;margin-top:3px}
#wrap{width:650px;text-align:left;margin:auto}
#logo{float:left;margin:0 3px 0 0}
#logo img{border:0}
#title{float:left;width:510px}
#intitle{margin:20px 0 0 0;background-color:#e5ecf9;width:100%;font-weight:bold;font-size:14px;padding:3px 0 4px 10px}
#content{clear:left;padding-top:60px;line-height:200%}
#vf{margin-top:10px}
#vf img{float:left;border:1px solid #000}
#kw{font:16px Verdana;height:1.78em;padding-top:2px}
#vf form{float:left;margin:12px 0 0 5px;padding:0}
#ft{text-align:center}
#ft,#ft a{color:#666;font-size:14px}
</style>
</head>
<body>
<div id="wrap">
<div id="logo"><a href="http://www..com"><img alt="到网络首页" title="到网络首页" src="http://www..com/img/logo-yy.gif" width="137" height="46"></a></div>
<div id="title"><div id="intitle">您的访问出错了</div></div>
<div id="content">很抱歉，您的电脑或所在的局域网络有异常的访问，此刻我们无法响应您的请求。 <br>请输入以下验证码，即可恢复使用。</div>
<div id="vf">
<img src="http://verify..com/cgi-bin/genimg?" width="120" height="40">
<form action="http://verify..com/verify">
<input type="hidden" name="url" value="http://..com/question/519848902?oldq=1&vf_tf=1">
<input type="hidden" name="vcode" value="">
<input type="hidden" name="id" value="1359359285">
<input type="hidden" name="di" value="530e060fe3c68f3d">
<input type="text" size="6" maxlength="10" name="verifycode" id="kw">
<input type="submit" value="提交">
</form>
</div>
<div style="clear:left;height:90px"></div>
<div id="ft">© 2012 Bai <a href="http://www..com/ty/index.html">免责声明</a></div>
</div>
<script>
(function(){
var rfr = window.document.location.href,
p = encodeURIComponent(rfr),
img = new Image(),
imgzd = new Image(),
re = /\/vcode\?http:\/\/(\S+)\./ig,r="";
img.src = "http://nsclick..com/v.gif?pid=201&pj=vcode&path="+p+"&t="+new Date().getTime();
r = re.exec(rfr);
if(r&&r[1]){imgzd.src = "http://"+r[1]+"..com/v.gif?fr=vcode&url="+p+"&t="+new Date().getTime();}

})();
</script>
</body>
</html>

‘捌’ 您的电脑或所在的局域网络有异常的访问，此刻我们无法响应您的请求。 请输入以下验证码，即可恢复使用。

如果是电信或联通的ADSL用户，重新拨号一下应该就没问题了。

网络可能是检测到有来自这个公共IP中的异常访问。

哈哈，如果你是铁通用户，那就恭喜你啦！因为铁通用户的数据都是经过铁通NAT转发过去的，也就是说同一个地区很多可能会共用一个ip（尽管你是公网IP，但是经过nat转发之后，服务器看到的是那个公用ip），这样无论你如何输入验证码，网络可能都会判断有异常访问的！

‘玖’ JavaScript警告1.1.1.3无法获取修改密码强度信息，网络异常。怎么处理

内网升级改造的问题，属于系统原因，需要联系内网总机处理。

‘拾’ Node.js 中的未捕获异常怎么解决

1. 未捕获异常带来的问题

由于 Node.js 的单线程特性，未捕获异常是一个应用开发过程中值得注意的问题。Node.js 遵循错误第一，数据第二的回调模式。我们经常在看到这样的例子：当回调函数返回一个错误对象，那就立即抛出这个错误。

如果你运行这个程序，而且假设你没有somefile.txt这个文件，一个错误将被抛出。

这将导致进程崩溃进而影响到整个APP。
这是有意为之，Node.js 不打算把你的应用和服务分隔开。

2. 怎样处理未捕获异常

处理未捕获异常的最佳方式是什么呢？有非常多方法：

• 你的应用不应该有未捕获错误，这很疯狂。

• 你应该让你的应用在崩溃后找到未捕获异常，然后修复它们，这也很疯狂。

• 对错误视而不见，不处理它—这是大多数人做的，然而这糟透了。

• 你应该让你的应用在崩溃后打印出错误日志，然后借用upstart,forever,monit之类的东西重启进程。这个方法很实用。

• 【译者注：现已废弃】你应该开始使用 Domains 模块来处理错误，这是必由之路，虽然这还是 Node.js 的一个试验性功能。

现在我们来详细展开这些方法。

3. 一个没有未捕获异常的应用

“没有未捕获异常的应用”这个概念对我来说很怪异，任何应用在某个时刻都会有异常而且可能是未捕获的异常。如果你坚持这个观点并把错误扔给用户，那么我觉得你要做好半夜接到电话被告知服务崩溃掉了的准备。

4. 使你的应用崩溃

The only defence I can find in this opinion is the fail fast argument. You are going to fix your application quickly if it unavailable. If an application without uncaught exceptions is denial letting your application crash is acceptance. But you are still pushing exception handling onto your users.（原谅我实在想不出怎么翻译这段，如果你有好的想法，请尽快联系我！）

5. 假装没看见错误？

很多人这样做：

1
<p style="margin-bottom: 7px;">process.on('uncaughtException',function(err) {<br> console.log(err);<br>})<br></p>

这很糟糕，当一个未捕获异常被抛出，你应该意识到你的应用处在一个不正常的状态，这种情况下你无法可靠地运行你的程序。

最初提出 process.on 事件的Felix Geisendörfer现在倡议去除它。

6. 应用崩溃，打印日志，然后重启

通过这个方法你可以让你的应用在发生未捕获异常时立即崩溃，然后利用forever或upstart这样的工具（几乎可以）立即重启。Node.js 将会把异常写入STERR所以你可以把异常重定向到一个日志文件稍晚再通过它拿到错误。这种方法的缺点是，对于错误发生在你的代码之外的i/o，不能提供一种优雅的方法来处理临时停电或者网络i/o出错的场景。这真是一个利器！— 重启应用并重试。如果你把这种策略与cluster mole相结合，node 可以自动重启任何抛出错误的 children 并且打印出错误。



varcluster = require('cluster');varworkers = process.env.WORKERS || require('os').cpus().length;if(cluster.isMaster) {console.log('start cluster with %s workers', workers);for(vari = 0; i < workers; ++i) {varworker = cluster.fork().process;console.log('worker %s started.', worker.pid);}cluster.on('exit',function(worker) {console.log('worker %s died. restart...', worker.process.pid);cluster.fork();});}else{varhttp = require('http');http.createServer(function(req, res) {res.end("Look Mum! I'm a server! ");}).listen(3000,"127.0.0.1");}process.on('uncaughtException', function (err) {console.error((new Date).toUTCString() + 'uncaughtException:', err.message)console.error(err.stack)process.exit(1)})

7. 使用Domains模块【译者注：现已废弃】

Domains是Node.js v0.8版本中新增的一个试验性特性，它使得异常处理变得更加灵活和精确。下面是刚才那个文件不存在的例子，通过使用domains你可以为一个特定的 domain 触发 error 事件，你还可以针对不同的场景使用不同的异常处理。这使得你根据异常的发生地点来对应地处理它们。如果退出进程像是用榔头敲碎坚果，那么这就像一把精确的手术刀为你提供对程序完全的控制。



vardomain = require('domain');vard = domain.create();varfs = require('fs');d.on('error',function(err) {console.error(err);});d.run(function() {fs.readFile('somefile.txt',function(err, data) {if(err)throwerr;console.log(data);});});

8. 结论

如果你在产品环境运行 Node.js 你起码应该对如何处理异常有一个想法。目前为止我相信当异常被抛出时，大多数人只是重启应用（也许是优雅地重启），Domains为应用提供了一种更聪明的面对异常的能力，异常处理器可能会选择简单的清理、关闭某些连接，最坏的情况下，退出进程。关键点就在于你有了选择。