.net语言中有委托这个概念，委托的本质可以说是面向对象语言中安全的函数指针，javascript语言标准中虽然没有委托概念，但是却可以使用委托。因为在javascript是一个基于对象的语言，函数也是对象，所以自然就可以作为参数传递，于是也就可以使用委托机制。

这里举一个委托在异步调用中例子，来说明委托的用法，例子是对XmlHttp的简单封装：

<script type="text/javascript">
<!--
/*
* XmlHttp 类
*/
var XmlHttp = function() {
    var o = null;
    
    var readyStateChange = function(processResponseProc) {
        if (o.readyState == 4) {
            if (o.status == 200) {
                processResponseProc(o.responseText);
            } else {
                processResponseProc(null);
            }
        }
    };

    return {
        /*
        * init 方法
        *
        * 返回值
        * 如果初始化成功则返回true，否则返回false
        *
        * 说明
        * 初始化XmlHttp对象，
        */
        init : function() {
            if (o == null) {
                if (window.XMLHttpRequest) {
                    try {
                        o = new XMLHttpRequest();
                    } catch (ex) {
                        return false;
                    }
                } else if (window.ActiveXObject) {
                    try {
                        o = new ActiveXObject("Msxml4.XMLHttp");
                    } catch (ex) {
                        try {
                            o = new ActiveXObject("Msxml2.XMLHttp");
                        } catch (ex) {
                            try {
                                o = new ActiveXObject("Microsoft.XMLHttp");
                            } catch (ex) {
                                return false;
                            }
                        }
                    }
                }
            }

            return true;
        },

        /*
        * get 方法
        *
        * 参数
        * url - 要请求的url
        * processResponse - 处理返回结果委托
        *
        * 返回值
        * 如果请求发起成功则返回true,否则返回false
        *
        * 说明
        * 发起http请求
        */
        get : function(url, processResponse) {
            try {
                o.open("GET", url, true);
                o.onreadystatechange = function() { readyStateChange(processResponse); };
                o.send();
                return true;
            } catch (ex) {
                return false;
            }
        },

        /*
        * post 方法
        *
        * 参数
        * url - 要请求的url
        * data - 发送的数据，注意这里值必须是urlencode过的
        * processResponse - 处理返回结果委托
        *
        * 返回值
        * 如果请求发起成功则返回true,否则返回false
        *
        * 说明
        * 发起post请求
        */
        post : function(url, data, processResponse) {
            processResponseProc = processResponse;
            try {
                o.open("POST", url, true);
                o.onreadystatechange = function() { readyStateChange(processResponse); };
                o.setRequestHeader("Content-Length", data.length);
                o.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
                o.send(data);
                return true;
            } catch (ex) {
                return false;
            }
        }
    };
};

var xmlhttp = new XmlHttp();
if (xmlhttp.init()) {
    xmlhttp.get("http://pstgroup.blogspot.com/", function(response) {
        if (response != null) {
            document.write(response);
        }
    });
}
//-->
</script>

这里get和post方法都是异步调用，都需要传入有一个processResponse参数，这个参数是http返回内容处理函数，也就是我们所说的委托概念，对象内部会在http请求返回后回调该函数来处理返回的内容，委托这个词很形象，XmlHttp类并不知道调用者要对返回结果干些什么，于是就委托给这个传递近来的函数来做。

委托可以很好的降低不同功能之间的耦合，这个例子使用委托就符合Open-Close原则，如果有新的处理返回结果的需求可以很容易扩展，不用改动现有代码，比如我们的新需求是alert返回结果：

var xmlhttp = new XmlHttp();
if (xmlhttp.init()) {
    xmlhttp.get("http://pstgroup.blogspot.com/", function(response) {
        if (response != null) {
            alert(response);
        }
    });
}

委托之所以适合异步调用，是因为异步调用符合委托的使用场景：调用者A调用被调用者B，由于调用过程是异步的，不会立刻返回结果，所以B在拿到返回结果时，有需要依赖于A来处理结果。当在类设计时发现类之间双向互相依赖的情况时，可以考虑使用委托。