Dojo学习笔记(9. dojo.graphics.color & dojo.uri.Uri)

模块：dojo.graphics.color

下面是dojo里定义的颜色名称
dojo.graphics.color.named.white //白色
dojo.graphics.color.named.black //黑色
dojo.graphics.color.named.red //红色
dojo.graphics.color.named.green //绿色
dojo.graphics.color.named.blue //蓝色
dojo.graphics.color.named.navy //海军蓝
dojo.graphics.color.named.gray //灰色
dojo.graphics.color.named.silver//银色

dojo.graphics.color.Color

颜色类

Usage Example:

var color = new dojo.graphics.color.Color(dojo.graphics.color.named.black); //定义一个黑色的颜色对象
var color = new dojo.graphics.color.Color(0,0,0); //定义一个黑色的颜色对象
var color = new dojo.graphics.color.Color(0,0,0,1.0); //定义一个黑色的颜色对象
var color = new dojo.graphics.color.Color([0,0,0,1.0]); //定义一个黑色的颜色对象
var color = new dojo.graphics.color.Color('rgb(0,0,0)'); //定义一个黑色的颜色对象
var color = new dojo.graphics.color.Color('#000000'); //定义一个黑色的颜色对象

dojo.graphics.color.Color.toRgb

Usage Example:

color.toRgb();  //返回一个[0,0,0]的数组
color.toRgb(true); //返回一个[0,0,0,1.0]的数组

dojo.graphics.color.Color.toRgba

Usage Example:

color.toRgba();  //返回一个[0,0,0,1.0]的数组

dojo.graphics.color.Color.toHex
dojo.graphics.color.Color.toString

Usage Example:

color.toHex();  //返回"#000000"
color.toString(); //返回"#000000"

dojo.graphics.color.Color.toCss

Usage Example:

color.toCss();  //返回"rgb(0,0,0)"

dojo.graphics.color.Color.blend

混合另一个颜色得到一个新颜色

Usage Example:

color.blend('#ffffff', 1); //返回[255,255,255]
color.blend('#ffffff', -1); //返回[0,0,0]
color.blend('#ffffff', 0); //按1比1混合黑色和白色，返回[127,127,127]
颜色参数可以为颜色的任意形式，比如数组，字符串等

or

dojo.graphics.color.blend([0,0,0], [255,255,255], 0); //will return [127,127,127]
dojo.graphics.color.blend("#000000", "#ffffff", 0); //will return "#7f7f7f"
若第一个参数为字符串，则返回值也会返回字符串

dojo.graphics.color.Color.blendHex

Usage Example:

dojo.graphics.color.blendHex("#000000", "#ffffff", 0); //will return "#7f7f7f"

dojo.graphics.color.extractRGB

将输入转换为RGB数组

dojo.graphics.color.hex2rgb

将输入的字符串转换为RGB数组

dojo.graphics.color.rgb2hex

将输入的RGB数组转换为字符串

dojo.graphics.color.Color.fromArray

Usage Example:

var color = dojo.graphics.color.Color.fromArray([0,0,0,1.0]);

模块：dojo.uri.Uri

dojo.uri.Uri

专门用来处理URI(统一资源标识符)的类

Usage Example:

uri = (new dojo.uri.Uri("http://myserver/dojo/", "guide.html")).toString(); //uri will be "http://myserver/dojo/guide.html"
uri = (new dojo.uri.Uri("http://myserver/dojo/", "../guide.html")).toString(); //uri will be "http://myserver/guide.html"

RFC规定的URI语法：[scheme:][//authority][path][?query][#fragment]
authority语法：[user-info@]host[:port]

比如我们定义一个uri

var uri = new dojo.uri.Uri("http://user:password@myserver:80/dojo/", "guide.html?page=1#top");

则uri的属性如下：

authority: 服务器名 "user:password@myserver:80"
fragment: 片断名 "top"
host: 主机名 "myserver"
password: 密码 "password"
path: 路径 "/dojo/guide.html"
port: 端口 80
query: 参数 "page=1"
scheme: 模式 "http"
uri: 完整的地址 "http://user:password@myserver:80/dojo/guide.html?page=1"
user: 用户名 "user:" 似乎有点问题，多了一个冒号

Dojo学习笔记(8. dojo.event & dojo.event.topic & dojo.event.browser)

模块：dojo.event

终于进入有名的dojo事件处理系统的学习了，学习前建议读者先去补习一下AOP的相关知识

dojo.event.connect

绑定指定的方法到指定的对象的方法上

Usage Example:

简单绑定1

function doOnClick1()
{
 alert("Clicked!");
}
dojo.event.connect(dojo.byId("inputTest"),"onclick","doOnClick1");

简单绑定2

obj = { doOnClick2: function(){ alert("Clicked!");}}
dojo.event.connect(dojo.byId("inputTest"),"onclick",obj,"doOnClick2");

如果存在需要进行多个事件的绑定的时候，你就会看到dojo的方便之处了

obj2 = { doOnClick2: function(){alert("Clicked!");}}
dojo.event.connect(dojo.byId("inputTest"),"onclick",obj,"doOnClick2");
dojo.event.connect(dojo.byId("inputTest"),"onclick",obj2,"doOnClick2");

connect可以对任何对象的方法进行绑定，而不是只能针对DOM对象

dojo.event.connect(obj,"doOnclick2","doOnClick1"); //在调用obj.doOnclick2()后调用doOnClick1()

dojo.event.connectBefore

dojo.event.connect默认是后绑定，connectBefore则是早绑定，绑定的方法将在指定方法前执行，用法与connect一致

dojo.event.connectAround

Usage Example:

function aroundTest(invocation){
  //此处可以增加代码，比如检查参数(invocation.args)
  var result = invocation.proceed();
  //此处可以增加代码，比如修改结果(result)
  return result;
}
dojo.event.connectAround(dojo.byId("inputTest"),"onclick","aroundTest");

dojo.event.connectOnce
说起这个函数，还真的是让我想了半天，直觉上我就把它想象成executeOnce，结果测试的结果让我差点想不通
connectOnce就是指保证只绑定一次，来避免重复绑定会导致的重复执行的问题

dojo.event.disconnect

解除绑定，调用参数与connect一致，即可解除之前的绑定操作

dojo.event.log

在执行指定对象的指定方法后自动记录日志

Usage Example:

dojo.event.log(obj, "doOnClick"); //当调用obj.doOnClick时记录下日志"DEBUG:  ([object Object]).doOnClick : "

你也可以这样写：

dojo.event.log({srcObj: obj, srcFunc: "doOnClick"});

dojo.event.kwConnect

kwConnect可以做到更加灵活的绑定，比如可以设置延迟执行绑定

Usage Example:

dojo.event.kwConnect({
  srcObj: dojo.byId("inputTest"),
  srcFunc: "onclick",
  adviceObj: obj,
  adviceFunc: "doOnclick2",

  type: "before", //默认为"after"，可选: "before", "around"，注意：type是用来决定adviceFunc的行为的，如果为"around"，则aroundFunc将失效
  aroundObj: null,
  aroundFunc: null, //如果指定了aroundFunc，则其将对adviceFunc进行拦截，但是当type为"around"时，则aroundFunc将不会执行
  once: false, //默认为false，允许重复绑定
  delay: 3000, //延时3秒后执行adviceFunc
  rate: 0, //这个从源代码没有看懂起什么作用
  adviceMsg: false //这个从源代码没有看懂起什么作用
});

dojo.event.kwDisconnect

用来解除使用kwConnect指定的绑定

模块：dojo.event.topic

Topic机制与Advice机制都能够实现事件的绑定，但是显然,Topic更适合处理多重绑定。
发布主题，然后由用户订阅的机制就是一个典型的观察者模式

dojo.event.topic.registerPublisher

注册主题发布器

Usage Example:

dojo.event.topic.registerPublisher("myTopic", obj, "doOnClick2");

dojo.event.topic.subscribe

订阅主题

Usage Example:

dojo.event.topic.subscribe("myTopic", "test"); //执行obj.doOnClick2()以后会自动执行test()

dojo.event.topic.unsubscribe

取消订阅主题

Usage Example:

dojo.event.topic.unsubscribe("myTopic", "test");

dojo.event.topic.destroy

删除主题，此主题所有的订阅都将失效

Usage Example:

dojo.event.topic.destroy("myTopic");

模块：dojo.event.browser

dojo.event.browser.addListener

增加监听器

Usage Example:

function listener()
{
  alert("ok");
}
dojo.event.browser.addListener(document, 'mousedown', listener); //事件名称可以加上"on"，也可以没有"on"
dojo.event.browser.addListener(document, 'onmousedown', listener, true); //capture为真表示不受上层元素的事件控制

dojo.event.browser.removeListener

清除监听器(这个方法似乎是无效的)

dojo.event.browser.callListener

调用监听器

Usage Example:

dojo.event.browser.callListener(listener, document);

dojo.event.browser.stopPropagation

阻止Event传播

Usage Example:

dojo.event.browser.stopPropagation();

dojo.event.browser.preventDefault

将当前事件的返回值设置为false

Usage Example:

dojo.event.browser.preventDefault();

dojo.event.browser.keys

键定义:
  KEY_BACKSPACE: 8,
  KEY_TAB: 9,
  KEY_ENTER: 13,
  KEY_SHIFT: 16,
  KEY_CTRL: 17,
  KEY_ALT: 18,
  KEY_PAUSE: 19,
  KEY_CAPS_LOCK: 20,
  KEY_ESCAPE: 27,
  KEY_SPACE: 32,
  KEY_PAGE_UP: 33,
  KEY_PAGE_DOWN: 34,
  KEY_END: 35,
  KEY_HOME: 36,
  KEY_LEFT_ARROW: 37,
  KEY_UP_ARROW: 38,
  KEY_RIGHT_ARROW: 39,
  KEY_DOWN_ARROW: 40,
  KEY_INSERT: 45,
  KEY_DELETE: 46,
  KEY_LEFT_WINDOW: 91,
  KEY_RIGHT_WINDOW: 92,
  KEY_SELECT: 93,
  KEY_F1: 112,
  KEY_F2: 113,
  KEY_F3: 114,
  KEY_F4: 115,
  KEY_F5: 116,
  KEY_F6: 117,
  KEY_F7: 118,
  KEY_F8: 119,
  KEY_F9: 120,
  KEY_F10: 121,
  KEY_F11: 122,
  KEY_F12: 123,
  KEY_NUM_LOCK: 144,
  KEY_SCROLL_LOCK: 145

dojo.event.browser.currentEvent

最近一次的Event，其属性包括：

altKey  //检查alt键的状态，当alt键按下时，值为 true
button  //检查按下的鼠标键，0 没按键，1 按左键，2 按右键，3 按左右键，4 按中间键，5 按左键和中间键，6 按右键和中间键，7 按所有的键
  //这个属性仅用于onmousedown, onmouseup, 和 onmousemove 事件。对其他事件，不管鼠标状态如何，都返回 0（比如onclick）
clientX  //返回鼠标在窗口客户区域中的X坐标
clientY  //返回鼠标在窗口客户区域中的Y坐标
ctrlKey  //检查ctrl键的状态，当ctrl键按下时，值为 true
fromElement //检测 onmouseover 和 onmouseout 事件发生时，鼠标所离开的元素
keyCode  //检测键盘事件相对应的内码，仅当type为keydown,keyup,keypress时才有效
offsetX  //检查相对于触发事件的对象，鼠标位置的水平坐标
offsetY  //检查相对于触发事件的对象，鼠标位置的垂直坐标
propertyName //设置或返回元素的变化了的属性的名称，你可以通过使用 onpropertychange 事件，得到 propertyName 的值
screenX  //检测鼠标相对于用户屏幕的水平位置
screenY  //检测鼠标相对于用户屏幕的垂直位置
shiftKey //检查shift键的状态，当shift键按下时，值为true
srcElement //返回触发事件的元素
srcFilter //返回触发 onfilterchange 事件的滤镜
toElement //检测 onmouseover 和 onmouseout 事件发生时，鼠标所进入的元素
type  //返回没有“on”作为前缀的事件名，比如click, mousedown
x  //返回鼠标相对于css属性中有position属性的上级元素的x轴坐标。如果没有css属性中有position属性的上级元素，默认以BODY元素作为参考对象
y  //返回鼠标相对于css属性中有position属性的上级元素的y轴坐标。如果没有css属性中有position属性的上级元素，默认以BODY元素作为参考对象
target  //同srcElement
currentTarget
layerX  //同offsetX
layerY  //同offsetY
pageX  //无水平滚动条的情况下与clientX同
pageY  //无水平滚动条的情况下与clientY同
relatedTarget // 仅当type为mouseover,mouseout时才有效
keys  //与dojo.event.browser.keys相同，仅当type为keydown,keyup,keypress时才有效
charCode //键值，仅当type为keypress时才有效

dojo.event.browser.isEvent

判断指定对象是否为event对象

Usage Example:

dojo.event.browser.isEvent(dojo.event.browser.currentEvent); //当dojo.event.browser.currentEvent不为null时返回true

模块：dojo.dom

dojo.dom.isNode

测试指定对象是否为节点

Usage Example:

dojo.dom.isNode(dojo.byId('edtTitle'));

dojo.dom.getUniqueId

取得唯一id

Usage Example:

dojo.dom.getUniqueId();  //will return dj_unique_#

dojo.dom.firstElement = dojo.dom.getFirstChildElement

取得指定节点下的第一个满足指定Tag条件的子节点

Usage Example:

dojo.dom.firstElement(parentNode, 'SPAN');

dojo.dom.lastElement = dojo.dom.getLastChildElement

取得指定节点下的最后一个满足指定Tag条件的子节点

Usage Example:

dojo.dom.lastElement(parentNode, 'SPAN');

dojo.dom.nextElement = dojo.dom.getNextSiblingElement

取得指定节点的下一个满足指定Tag条件的子节点

Usage Example:

dojo.dom.nextElement(node, 'SPAN');

dojo.dom.prevElement = dojo.dom.getPreviousSiblingElement

取得指定节点的前一个满足指定Tag条件的子节点

Usage Example:

dojo.dom.prevElement(node, 'SPAN');

dojo.dom.moveChildren

把指定节点下的所有子节点移动到目标节点下，并返回移动的节点数

Usage Example:

dojo.dom.moveChildren(srcNode, destNode, true); //仅移动子节点，srcNode中的文字将被丢弃
dojo.dom.moveChildren(srcNode, destNode, false);//包括文字和子节点都将被移动到目标节点下

dojo.dom.copyChildren

把指定节点下的所有子节点复制到目标节点下，并返回复制的节点数

Usage Example:

dojo.dom.moveChildren(srcNode, destNode, true); //仅复制子节点，srcNode中的文字将被忽略
dojo.dom.moveChildren(srcNode, destNode, false);//包括文字和子节点都将被复制到目标节点下

dojo.dom.removeChildren

删除指定节点下的所有子节点，并返回删除的节点数

Usage Example:

dojo.dom.moveChildren(node);

dojo.dom.replaceChildren

用指定的新节点替换父节点下的所有子节点

Usage Example:

dojo.dom.replaceChildren(node, newChild); //目前还不支持newChild为数组形式

dojo.dom.removeNode

删除指定的节点

Usage Example:

dojo.dom.removeNode(node);

dojo.dom.getAncestors

返回指定节点的父节点集合

Usage Example:

dojo.dom.getAncestors(node, null, false); //返回所有的父节点集合（包括指定的节点node）
dojo.dom.getAncestors(node, null, true); //返回最近的一个父节点
dojo.dom.getAncestors(node, function(el){/* 此处增加过滤条件 */return true}, false); //返回所有满足条件的父节点集合

dojo.dom.getAncestorsByTag

返回所有符合指定Tag的指定节点的父节点集合

Usage Example:

dojo.dom.getAncestorsByTag(node, 'span', false); //返回所有的类型为SPAN的父节点集合
dojo.dom.getAncestorsByTag(node, 'span', true);  //返回最近的一个类型为SPAN的父节点

dojo.dom.getFirstAncestorByTag

返回最近的一个符合指定Tag的指定节点的父节点

Usage Example:

dojo.dom.getFirstAncestorByTag(node, 'span'); //返回最近的一个类型为SPAN的父节点

dojo.dom.isDescendantOf

判断指定的节点是否为另一个节点的子孙

Usage Example:

dojo.dom.isDescendantOf(node, ancestor, true); //判断node是否为ancestor的子孙
dojo.dom.isDescendantOf(node, node, false); //will return true
dojo.dom.isDescendantOf(node, node, true); //will return false

dojo.dom.innerXML

返回指定节点的XML

Usage Example:

dojo.dom.innerXML(node);

dojo.dom.createDocument

创建一个空的文档对象

Usage Example:

dojo.dom.createDocument();

dojo.dom.createDocumentFromText

根据文字创建一个文档对象

Usage Example:

dojo.dom.createDocumentFromText('<?xml version="1.0" encoding="gb2312" ?><a>1</a>','text/xml');

dojo.dom.prependChild

将指定的节点插入到父节点的最前面

Usage Example:

dojo.dom.prependChild(node, parent);

dojo.dom.insertBefore

将指定的节点插入到参考节点的前面

Usage Example:

dojo.dom.insertBefore(node, ref, false); //如果满足要求的话就直接退出
dojo.dom.insertBefore(node, ref, true);

dojo.dom.insertAfter

将指定的节点插入到参考节点的后面

Usage Example:

dojo.dom.insertAfter(node, ref, false); //如果满足要求的话就直接退出
dojo.dom.insertAfter(node, ref, true);

dojo.dom.insertAtPosition

将指定的节点插入到参考节点的指定位置

Usage Example:

dojo.dom.insertAtPosition(node, ref, "before");//参考节点之前
dojo.dom.insertAtPosition(node, ref, "after"); //参考节点之后
dojo.dom.insertAtPosition(node, ref, "first"); //参考节点的第一个子节点
dojo.dom.insertAtPosition(node, ref, "last");  //参考节点的最后一个子节点
dojo.dom.insertAtPosition(node, ref); //默认位置为"last"

dojo.dom.insertAtIndex

将指定的节点插入到参考节点的子节点中的指定索引的位置

Usage Example:

dojo.dom.insertAtIndex(node, containingNode, 3);  //把node插入到containingNode的子节点中，使其成为第3个子节点

dojo.dom.textContent

设置或获取指定节点的文本

Usage Example:

dojo.dom.textContent(node, 'text'); //设置node的文本为'text'
dojo.dom.textContent(node); //返回node的文本

dojo.dom.hasParent

判断指定节点是否有父节点

Usage Example:

dojo.dom.hasParent(node);

dojo.dom.isTag

判断节点是否具有指定的tag

Usage Example:

var el = document.createElement("SPAN");
dojo.dom.isTag(el, "SPAN"); //will return "SPAN"
dojo.dom.isTag(el, "span"); //will return ""
dojo.dom.isTag(el, "INPUT", "SPAN", "IMG"); //will return "SPAN"

模块：dojo.io.IO

dojo.io.bind

处理请求取回需要的数据并处理

这个函数是AJAX中最为重要和有用的函数，dojo.io.bind这个类是用来处理客户端与服务器间通讯的，需要通讯的参数由对象dojo.io.Request所定义，具体通讯的方法则由另外一个对象Transport所提供。

因此，我们如果需要与服务器通讯，则应该定义一个Request对象，其中包括服务器地址及回调函数，例子中Requset都是以匿名对象方式定义的

虽然我们可以定义一个自己的Transport，但是显然不如直接利用现成的Transport方便。

Dojo里提供了一个同时兼容IE和Firefox的dojo.io.XMLHTTPTransport，但是这个对象位于 dojo.io.BrowserIO，因此，一般require dojo.io.IO时，还应该require dojo.io.BrowserIO

Usage Example:

  dojo.io.bind({
    url: "http://localhost/test.html", //要请求的页面地址
    mimetype: "text/html", //请求的页面的类型，应该设置为与你请求页面类型对应的mimetype，默认为 "text/plain"
    method："GET", //默认为"GET"
    sync: false, //默认为异步执行
    useCache: false, //默认为不使用页面缓存，注意这里的缓存并不是浏览器的缓存，而是Dojo自身所维护的页面缓存
    preventCache: false, //默认为启用浏览器缓存，否则将通过自动增加不同的参数来确保浏览器缓存失效
    timeoutSeconds: 3000,  //3秒后超时，如果为0则永不超时

    load: function(type, data, evt) { alert(data); }, //type should be "load", data is that we wanted
    error: function(type, error) { alert(error.message); }, //error is dojo.io.Error
    timeout: function(type) { alert("请求超时！"); }
  });

  你也可以用一个handle来处理所有的事件

  dojo.io.bind({
    url: "http://localhost/test.html", //要请求的页面地址
    mimetype: "text/html", //请求的页面的类型，应该设置为与你请求页面类型对应的mimetype
    timeoutSeconds: 3000,  //3秒后超时，如果为0则永不超时
    handle: function(type, data, evt){
      if(type == "load") { alert(data); } //data is that we wanted
      else if (type == "error") { alert(data.message); } //data is the error object
      else { ; } //other events maybe need handled
    }
  });
 
  如果没有在Request中指定所用的transport，则Dojo会自动的在已注册的transports中寻找能够处理这个Request的transport，如果不能找到，则返回指定的Request。下面是一个指定了transport的例子:

  dojo.io.bind({
    url: "http://localhost/test.html", //要请求的页面地址
    mimetype: "text/html", //请求的页面的类型，应该设置为与你请求页面类型对应的mimetype
    timeoutSeconds: 3000,  //3秒后超时，如果为0则永不超时
    transport: "XMLHTTPTransport",

    load: function(type, data, evt) { alert(data); }, //type should be "load", data is that we wanted
    error: function(type, error) { alert(error.message); }, //error is dojo.io.Error
    timeout: function(type) { alert("请求超时！"); }
  });

  你还可以利用bind来得到一个JavaScript所定义的对象（注意mimetype必须要定义为"text/javascript"）

  testObj = dojo.io.bind({
    url: "http://localhost/test.js", //test.js里定义了一个对象
    mimetype: "text/javascript", //请求的页面的类型，应该设置为与你请求页面类型对应的mimetype
    timeoutSeconds: 3000,  //3秒后超时，如果为0则永不超时
    handle: function(type, data, evt){
      if(type == "load") { alert(data); } //data is a object or value
      else if (type == "error") { alert(data.message); } //data is the error object
      else { ; } //other events maybe need handled
    }
  });
 
  下面是一个Post的例子:
 
  dojo.io.bind({
    url: "http://localhost/test.aspx", //要提交的页面地址
    mimetype: "text/html", //请求的页面的类型，应该设置为与你请求页面类型对应的mimetype
    timeoutSeconds: 3000,  //3秒后超时，如果为0则永不超时
    method: "POST",
    formNode: dojo.byId("myForm"), //指定提交的Form名称

    load: function(type, data, evt) { alert(data); }, //type should be "load", data is that we wanted
    error: function(type, error) { alert(error.message); }, //error is dojo.io.Error
    timeout: function(type) { alert("请求超时！"); }
  });

  另一个Post的例子(without Form to post):

  dojo.io.bind({
    url: "http://localhost/test.aspx", //要提交的页面地址
    mimetype: "text/html", //请求的页面的类型，应该设置为与你请求页面类型对应的mimetype
    timeoutSeconds: 3000,  //3秒后超时，如果为0则永不超时
    method: "POST",
    content: {a: 1, b: 2}, //要提交的数据

    load: function(type, data, evt) { alert(data); }, //type should be "load", data is that we wanted
    error: function(type, error) { alert(error.message); }, //error is dojo.io.Error
    timeout: function(type) { alert("请求超时！"); }
  });

dojo.io.queueBind

  有时，我们需要一次发出多个网页请求，则应该使用dojo.io.queueBind，因为浏览器可能只允许同时发出有限个数的请求，如果是使用dojo.io.bind的话，则有可能会申请不到新的XMLHttp对象而导致出错。

  用法与dojo.io.bind是一样的。

dojo.io.argsFromMap

  用来把对象转换为URL的参数形式
 
Usage Example:

  dojo.io.argsFromMap({a:1,b:2,c:3}); //will return "c=3&b=2&a=1"
  dojo.io.argsFromMap({name:"名称",value:"值"},"utf"); //will return "value=%E5%80%BC&name=%E5%90%8D%E7%A7%B0", 有中文的话应该指定utf格式，否则dojo.string.encodeAscii返回的编码是很怪异的
  dojo.io.argsFromMap({a:1,b:2,c:3}, "utf", "c"); //will return "b=2&a=1&c=3"，最后一个参数可以控制指定名称的值出现在最后
 

dojo.io.setIFrameSrc

  设置IFrame的Src
 
Usage Example:

  dojo.io.setIFrameSrc(dojo.byId("myFrame"), "http://localhost/test.htm"); //myFrame打开指定的网页
  dojo.io.setIFrameSrc(dojo.byId("myFrame"), "http://localhost/test.htm", true); //myFrame打开指定的网页，并覆盖浏览器的历史记录

TODO: 补充一个kwArgs的例子，我之前在网上看见过，可是现在无论如何也找不到相关的页面了，只好以后在举例了

模块：dojo.io.BrowserIO

基本上就提供了dojo.io.XMLHTTPTransport这个对象

XMLHTTPTransport一般能够满足我们的需求，但是其有几个限制：它不能传输文件，不能够成功执行跨域名的远程请求，并且不支持 file:// 这样的协议

因此，根据应用要求，我们可能会需要选用其它的transport: dojo.io.IframeTransport, dojo.io.repubsubTranport, dojo.io.ScriptSrcTransport, ShortBusTransport

dojo.io.IframeTransport，用法与xmlhttp是一样的，其优点就是可以跨域，不存在任何的安全问题
如果 Request指定的mimetype是text或javascript，返回的内容应该是放在第一个textarea里的内容，如果指定的 mimetype是html，则IFrame里的html则是需要的内容。因为浏览器兼容的原因，IframeTransport不能正确处理返回类型为 XML的请求。

关于Rpc，这个类似于Remoting的东西，也将在以后对其进行介绍。

模块：dojo.string.common / dojo.string
dojo.string.common 和 dojo.string 是一样的，只要require其中一个就可以使用以下方法
dojo.string.trim
去掉字符串的空白
Usage Example:
s = " abc ";
dojo.string.trim(s);      //will return "abc"
dojo.string.trim(s, 0);      //will return "abc"
dojo.string.trim(s, 1);      //will return "abc "
dojo.string.trim(s, -1);//will return " abc"

dojo.string.trimStart
去掉字符串开头的空白
Usage Example:
s = " abc ";
dojo.string.trimStart(s);      //will return "abc "
dojo.string.trimEnd
去掉字符串结尾的空白
Usage Example:
s = " abc ";
dojo.string.trimEnd(s);            //will return " abc"
dojo.string.repeat
生成由同一字符(串)重复组成的字符串
Usage Example:
dojo.string.repeat("a", 4); //will return "aaaa"
dojo.string.repeat("1234", 3, "-"); //will return "1234-1234-1234"
dojo.string.pad
使用字符补齐字符串
Usage Example:
dojo.string.pad("100", 6);            //will return "000100"
dojo.string.pad("100", 6, "0", 1);      //will return "000100"
dojo.string.pad("100", 6, "0", -1);      //will return "100000"
dojo.string.padLeft
使用字符补齐字符串开头
Usage Example:
dojo.string.padLeft("100", 6);            //will return "000100"
dojo.string.padRight
使用字符补齐字符串结尾
Usage Example:
dojo.string.padRight("100", 6);            //will return "100000"

模块：dojo.lang.common / dojo.lang
dojo.lang.common 和 dojo.lang 是一样的，只要require其中一个就可以使用以下方法

dojo.lang.mixin
将一个对象的方法和属性增加到另一个对象上
Usage Example:
var s1 = {name: "TestObj", test1: function(){alert("this is test1!");}}
var s2 = {value: 1000, test2: function(){alert("this is test2!");}}
var d = {};
dojo.lang.mixin(d, s1, s2); //执行后d就具备了s1和s2的所有属性和方法
d.test1();
dojo.lang.extend
为指定类的原型扩展方法与属性
Usage Example:
TestClass = function() {};
dojo.lang.extend(TestClass, {name: "demo", test: function(){alert("Test!");}});
var o = new TestClass();  //TestClass本来是没有test方法的，但是extend以后就有test方法了
o.test();
dojo.lang.find=dojo.lang.indexOf
查找指定对象在指定数组中的位置
Usage Example:
var arr = [1,2,3,3,2,1];
dojo.lang.find(arr, 2);                  //will return 1
dojo.lang.find(arr, 2, true);            //will return 1
dojo.lang.find(arr, "2", true);            //will return -1
dojo.lang.find(arr, "2", false);      //will return 1
dojo.lang.find(arr, 2, true, true);      //will return 4
dojo.lang.findLast=dojo.lang.lastIndexOf
查找指定对象在指定数组中的位置，从后往前查
Usage Example:
var arr = [1,2,3,3,2,1];
dojo.lang.findLast(arr, 2);                  //will return 4
dojo.lang.findLast(arr, 2, true);            //will return 4
dojo.lang.findLast(arr, "2", true);            //will return -1
dojo.lang.findLast(arr, "2", false);            //will return 4
dojo.lang.inArray
查找指定对象是否在指定数组中
Usage Example:
var arr = [1,2,3];
dojo.lang.inArray(arr, 1);      //will return true
dojo.lang.inArray(arr, 4);      //will return false
dojo.lang.isObject
判断输入的类型是否为对象
Usage Example:
dojo.lang.isObject(new String());      //will return true
dojo.lang.isObject("123"));      //will return false
dojo.lang.isArray
判断输入的类型是否为数组
Usage Example:
dojo.lang.isArray({a:1,b:2});      //will return false
dojo.lang.isArray([1,2,3]);      //will return true
dojo.lang.isFunction
判断输入的类型是否为函数
Usage Example:
dojo.lang.isFunction(function() {});      //will return true
dojo.lang.isString
判断输入的类型是否为字符串
Usage Example:
dojo.lang.isString("");      //will return true
dojo.lang.isString(0);      //will return false
dojo.lang.isAlien
判断输入的类型是否为系统函数
Usage Example:
dojo.lang.isAlien(isNaN);      //will return true
dojo.lang.isBoolean
判断输入的类型是否为布尔类型
Usage Example:
dojo.lang.isBoolean(2>1);      //will return true

dojo.lang.isNumber
判断输入的类型是否为数值，根据注释所说，此函数使用不太可靠，但是可替换使用的系统函数isNaN也不太可靠


dojo.lang.isUndefined
判断输入是否为未定义，根据注释所说，此函数有可能会导致抛出异常，推荐使用 typeof foo == "undefined" 来判断

模块：dojo.lang.extras
dojo.lang.setTimeout
延迟指定时间后执行指定方法
Usage Example:
function onTime(msg)
{
dojo.debug(msg)
}
dojo.lang.setTimeout(onTime, 1000, "test"); //1秒后会输出调试信息"test"
dojo.lang.setTimeout(dojo, "debug", 1000, "test"); //1秒后会输出调试信息"test"

dojo.lang.getNameInObj
获得指定项目在指定对象中的名称
Usage Example:
dojo.lang.getNameInObj(dojo, dojo.debug);      //will return "debug"
dojo.lang.shallowCopy
返回指定对象的浅表复制副本
Usage Example:
dojo.lang.shallowCopy({});    //will return a 空对象
dojo.lang.firstValued
返回第一个存在定义的参数
Usage Example:
var a;
dojo.lang.firstValued(a,2,3);      //will return 2

以上全部是自己阅读源代码写的总结，如有错误，还请指明。

这里所说的基础对象和方法是指的不Require任何包就能够调用的对象和方法

匿名函数

在开始前，我想介绍一下js里的匿名函数，这个在阅读dojo的源代码的时候，会发现到处都有匿名函数

;(function(){
alert(123);
})();
//前面的分号是一个空语句，是可以不要的

匿名函数。一个匿名函数就是一个没有名字的函数。

你可以认为他们是一次性函数。当你只需要用一次某个函数时，他们就特别有用。通过使用匿名函数，没有必要把函数一直放在内存中，所以使用匿名函数更加有效率。

当然你也可以根本不定义函数，但是使用匿名函数可以把你的代码分段，就像C#中的#region一样

dojo.byId

非常有用的一个方法，与prototype.js的著名的$一样

似乎以前的版本还有dojo.byIdArray, 不过最新的版本已经找不到这个函数了(除了src\compat\0.2.2.js)

如果有多个元素具有指定的id，则返回的是一个集合

Usage Example:

 dojo.byId("divTest");
 dojo.byId("divTest", document);
 dojo.byId(document.getElementById("divTest"));

dojo.version

dojo的版本，可以取得major, minor, patch, flag和revision

这个对象没什么太大用处，除非你要根据dojo的版本选择执行你的代码

dojo.raise

抛出一个异常

dojo.errorToString

将异常转换为字符串

Usage Example:

 try
 {
    dojo.raise("打印失败", new Error("文件不存在"));
 }
 catch(e)
 {
    alert(dojo.errorToString(e));
 }

dojo.render

系统环境对象

如果dojo.html.ie为true的话

dojo.html.ie50         返回true说明浏览器是IE 5.0
dojo.html.ie55         返回true说明浏览器是IE 5.5
dojo.html.ie60         返回true说明浏览器是IE 6.0
dojo.html.ie70         返回true说明浏览器是IE 7.0

dojo.addOnLoad

可以加载指定函数到window.load时执行，好处就是可以很方便的在window.load时执行多个函数

Usage Example:

 dojo.addOnLoad(init);                    //init是一个函数
 dojo.addOnLoad(myObject, init);       //init是myObject对象的一个方法

dojo.require

如果你想调用一个模块的对象的时候，你应该首先用dojo.require来请求这个模块，dojo会根据你的请求自动取得相应的js文件，并加载到内存中，这样你才能调用或创建其中的对象

dojo会自动维护已加载的模块列表，所以是不会重复加载模块的

Usage Example:

 dojo.require("dojo.event");

dojo.requireIf=dojo.requireAfterIf

可以根据指定的条件来决定是否加载指定的模块

Usage Example:

 dojo.requireIf(dojo.html.ie, "dojo.html");   //如果dojo.html.ie为true，才会加载dojo.html模块

dojo.provide

除非你要开发自己的模块，不然是用不到这个方法的，你可以这句看成是向系统注册这个模块名称

Usage Example:

 dojo.provide("dojo.custom");

dojo.exists

判断指定对象是否具有指定名称的方法

Usage Example:

 dojo.exists(dojo, "exists"); //will return true

dojo.hostenv.getText

返回指定url的内容

PS: 由于浏览器的安全限制，因此只能用于取得同域名的url的内容，否则会报告权限不够

Usage Example:

 aSync = false; //同步，确保返回内容不为null
 silent = true; //不抛出错误
 s = dojo.hostenv.getText("http://www.google.com/", aSync, silent); //返回Google的首页的HTML
 alert(s);

dojo.debug

输出调试信息，如果在djConfig中指定了debugContainerId，则输出到指定的console容器中，否则直接document.write

所有的调试信息均以 DEBUG: 开头

Usage Example:

 dojo.debug("这是调试信息");

dojo.hostenv.println

与dojo.debug类似，不同的是，输出内容没有 DEBUG:

Usage Example:

 dojo.hostenv.println("这是一般的输出信息");

dojo.debugShallow

输出指定对象的全部信息(Shallow说明并不会遍历到下一级别的对象属性)以供调试

Usage Example:

 dojo.debugShallow(dojo.render.html);

djConfig是dojo内置的一个全局设置对象，其作用是可以通过其控制dojo的行为

首先我们需要在引用dojo.js前声明djConfig对象，以便在加载dojo.js的时候才能够取得所设置的值，虽然在0.3版本以后dojo支持在加载后设置，但是强烈建议你把声明djConfig的代码作为第一段script

一个完整的djConfig对象定义如下（值均为dojo的默认值）

<script type="text/javascript">
var djConfig = {
    isDebug: false,
    debugContainerId: "",
    bindEncoding: "",
    allowQueryConfig: false,
    baseScriptUri: "",
    parseWidgets: true
    searchIds: [],
    baseRelativePath: "",
    libraryScriptUri: "",
    iePreventClobber: false,
    ieClobberMinimal: true,
    preventBackButtonFix: true,
};
</script>

isDebug是一个很有用的属性，顾名思义，如果设置为真，则所有dojo.Debug的输出有效，开发时应该设置为true，发布时应该设置为false

debugContainerId同样也是与调试有关的，如果不指定的话，调试信息将会直接利用 document.write输出，这样可能会破坏页面的整体布局，所以你可以指定任何一个可以作为容器的html元素的id作为调试信息输出容器

allowQueryConfig，这个属性指明 dojo是否允许从页面url的参数中读取djConfig中的相关属性，当值为true时，dojo会优先从url参数中读取djConfig的其他属性，比如: http://server/dojoDemo.htm?djConfig.debugContainerId=divDebug

baseScriptUri，一般不需要设置，dojo会自动根据你引用dojo.js的路径设置这个值，比如，<script type="text/javascript" src="../dojo/dojo.js"></script>，自动获取的值便是 ../dojo/
ps: 如果你有多个工程需要同时引用dojo.js的话，建议也把dojo当作一个独立的工程，引用的时候采用绝对路径就可以了

parseWidgets，这个是可以控制dojo是否自动解析具有dojoType的html元素为对应的widget，如果你没有使用任何Widget，建议设置为false以加快dojo的加载速度

searchIds，这是一个字符串数组，定义了所有需要解析为widget的html元素的ID，如果ID不在其中的html元素是不会被解析的，当数组为空数组时，则所有具有dojoType的元素都会被解析

还有一个bindEncoding，是用来设置默认的bind请求的编码方式

至于其它的属性，不是用处不大，就是不知道有什么作用

在实际开发中，可以把djConfig的定义放在一个js文件里，并将其作为第一个引用的js文件，这样应该是最方便的。

Dojo学习笔记(1. 模块与包)

Intro:

Dojo是一个非常强大的面向对象的JavaScript的工具箱, 建议读者能够去补充一下JavaScript下如何使用OO进行编程的, 这对于你以后阅读Dojo Source有很大的用处

请大家下载dojo 0.3.1, 以下的说明均针对此版本

翻译自http://manual.dojotoolkit.org/WikiHome/DojoDotBook/BookUsingDojo


Getting Started

1: 把Dojo加入到我们的Web程序中

1. 标志

<script type="text/javascript">
 djConfig = { isDebug: false };
</script>

djConfig是Dojo里的一个全局对象, 其作用就是为Dojo提供各种选项, isDebug是最常用的属性之一, 设置为True以便能够在页面上直接看到调试输出, 当然其中还有些属性与调试有关, 这里就不罗索了

2. 引用 dojo 的启动代码

<script type="text/javascript" src="/yourpath/dojo.js" />

这样你就引用了dojo的代码, 并可以直接使用其中部分常用的对象, 下载下来的dojo.js是压缩(remove comments and space)后的代码, 要阅读的话,建议阅读dojo.js.uncompressed.js, dojo.js大概有127K, 而未压缩前有211K, ok, 为什么会这么大呢, 原来其已经把部分常用的模块整合进dojo.js里, 因此显得大了一点, build.txt里就说明了默认的dojo.js包含了哪些模块

3. 声明你所要用到的包

<script type="text/javascript">
  dojo.require("dojo.math");
  dojo.require("dojo.io.*");
  dojo.require("dojo.widget.*");
</script>

 你就把这些代码当成是java的import语句或C#中的using语句一样, 如果你不require的话, 而模块本身又没有整合在dojo.js中, 是会出现脚本错误的喔

2. 针对不同需求提供的预整合包

Dojo 本身是由许多模块所组合而成的, 但是由于用户需求的多样性, dojo针对不同的需求而提供了不同的版本, 用户在下载dojo的时候就看见可以选择很多的版本, 比如Ajax版和Widget版, 每个版本最重要的区别就在于dojo.js文件, 但是除此之外, 每一个版本都是全功能的, dojo.js根据版本的不同而整合进了不同的模块

3. 直接获取Dojo的最新源代码

首先你必须安装 Subversion, 当Subversion在你的电脑上能够正常工作后,你就可以通过如下命令下载dojo的源代码:

svn co http://svn.dojotoolkit.org/dojo/trunk/

这会在你的当前目录下创建一个 trunk 的目录; 如果你希望直接Get到当前目录, 用这个命令:

svn co http://svn.dojotoolkit.org/dojo/trunk/ .

或者你希望Get到当前目录下的 MyDir 目录, 用这个命令:

svn co http://svn.dojotoolkit.org/dojo/trunk/ MyDir

模块与包

模块

Dojo的代码被划分为逻辑单元称之为模块, 这有点类似于Java中的package,除了dojo的模块能够包含类 (类似于java中的classes)和简单函数

比如: 模块"dojo.html"包含了一系列的函数, 比如dojo.html.getContentBox(), 模块"dojo.dnd"包含了一系列的HtmlDragObject的类

注意名称约定, 函数的首字母为小写字母,类的首字母为大写

模块也可以称之为"命名空间"

包

在多数情况下, dojo的模块只需要定义在一个文件就可以了, 但有时, 一个模块可能划分到多个文件, 比如: 模块dojo.html, 本来是定义在一个文件中, 可是由于功能的增强, 文件逐渐变大, 我们不得不将其拆分为多个文件, 这主要是为性能考虑, 以便浏览器可以只下载其需要用到的代码, 不幸的是其实现细节对于dojo的用户看起来不那么透明, 你必须知道你想要用到的功能到底是包含在哪个文件, 然后才能require并使用它

这样的每一个文件都称之为一个包

dojo.require("dojo.html.extras")

 将引用文件 src/html/extras.js, 这将定义模块 dojo.html 的若干(并非所有)函数

据我所知, 尽管单个文件可以定义包里的多个类, 单个脚本文件不能定义多个模块 (在Java可以等效于在一个文件中定义2个类), 并且, 包的名称和模块的名称可以不同, 比如: 包dojo.widget.Button定义了dojo.widget.html.Button

基本上你应该这样认为, 包和模块尽管密切相关, 但是是两个完全不同的实体

为什么会有模块和包这样的概念?

为什么会有模块和包这样的概念? 为了满足你的应用程序只需要加载其所用到的东西的需求, 充分利用模块化设计的优点, dojo维护了最小的足印以便仍能提供你所需要的功能, 为什么要你的用户浪费时间去下载用不到的JavaScript, 当一个包就是一个js文件时, 一个模块本质上就是一个命名空间, 比如: dojo.style 或 dojo.html.extras
多数简单情况下, 一个包包含了一个模块, 但更常见的是, 一个模块可能被拆分为几个包文件

利用包和模块, 将能确保你能够交付最相关的功能代码, 最小程度的减少代码的膨胀和消除由此带来的不好的用户体验,这就是模块设计的主要目标, 通过模块化, 你能够引入自定义模块(你自己拥有的 JavaScript 工具), 并且维护模块对于核心代码库基本不会产生什么影响

另外, Dojo的模块系统也提供了内建的机制来使用代码提供命名空间, 比如, 通过模块dojo.event定义的Dojo的事件系统

怎样引用

设置引用语句

你怎样才能知道该引用哪个包到dojo.require()?

1. 模块

首先, 确定你要使用什么模块, 这个例子我们假定你要使用 dojo.lfx.html

2. 包

搜索代码后你发现dojo.lfx.html定义在2个文件:

• src/lfx/html.js
• src/lfx/extras.js

根据你要用到的功能, 你可以 

dojo.require("dojo.lfx.html");

或 

dojo.require("dojo.lfx.html");
dojo.require("dojo.lfx.extras");

通配符

新用户可能会对dojo.lfx.*这样就可以替代上面2句而感到诧异, 实际上, __package__.js 中已经定义了通配符可以代替的语句, 并且这样可以让dojo根据当时的环境而决定加载具体的模块

这个函数是AJAX中最为重要和有用的函数，dojo.io.bind这个类是用来处理客户端与服务器间通讯的，需要通讯的参数由对象dojo.io.Request所定义，具体通讯的方法则由另外一个对象Transport所提供。

因此，我们如果需要与服务器通讯，则应该定义一个Request对象，其中包括服务器地址及回调函数，例子中Requset都是以匿名对象方式定义的

虽然我们可以定义一个自己的Transport，但是显然不如直接利用现成的Transport方便。

Dojo里提供了一个同时兼容IE和Firefox的dojo.io.XMLHTTPTransport，但是这个对象位于 dojo.io.BrowserIO，因此，一般require dojo.io.IO时，还应该require dojo.io.BrowserIO

Usage Example:

  dojo.io.bind({
    url: "http://localhost/test.html", //要请求的页面地址
    mimetype: "text/html", //请求的页面的类型，应该设置为与你请求页面类型对应的mimetype，默认为 "text/plain"
    method："GET", //默认为"GET"
    sync: false, //默认为异步执行
    useCache: false, //默认为不使用页面缓存，注意这里的缓存并不是浏览器的缓存，而是Dojo自身所维护的页面缓存
    preventCache: false, //默认为启用浏览器缓存，否则将通过自动增加不同的参数来确保浏览器缓存失效
    timeoutSeconds: 3000,  //3秒后超时，如果为0则永不超时

    encoding: “utf-8″, //默认是ascii

    load: function(type, data, evt) { alert(data); }, //type should be "load", data is that we wanted
    error: function(type, error) { alert(error.message); }, //error is dojo.io.Error
    timeout: function(type) { alert("请求超时！"); }
  });

  你也可以用一个handle来处理所有的事件

  dojo.io.bind({
    url: "http://localhost/test.html", //要请求的页面地址
    mimetype: "text/html", //请求的页面的类型，应该设置为与你请求页面类型对应的mimetype
    timeoutSeconds: 3000,  //3秒后超时，如果为0则永不超时
    handle: function(type, data, evt){
      if(type == "load") { alert(data); } //data is that we wanted
      else if (type == "error") { alert(data.message); } //data is the error object
      else { ; } //other events maybe need handled
    }
  });
 
  如果没有在Request中指定所用的transport，则Dojo会自动的在已注册的transports中寻找能够处理这个Request的transport，如果不能找到，则返回指定的Request。下面是一个指定了transport的例子:

  dojo.io.bind({
    url: "http://localhost/test.html", //要请求的页面地址
    mimetype: "text/html", //请求的页面的类型，应该设置为与你请求页面类型对应的mimetype
    timeoutSeconds: 3000,  //3秒后超时，如果为0则永不超时
    transport: "XMLHTTPTransport",

    load: function(type, data, evt) { alert(data); }, //type should be "load", data is that we wanted
    error: function(type, error) { alert(error.message); }, //error is dojo.io.Error
    timeout: function(type) { alert("请求超时！"); }
  });

  你还可以利用bind来得到一个JavaScript所定义的对象（注意mimetype必须要定义为"text/javascript"）

  testObj = dojo.io.bind({
    url: "http://localhost/test.js", //test.js里定义了一个对象
    mimetype: "text/javascript", //请求的页面的类型，应该设置为与你请求页面类型对应的mimetype
    timeoutSeconds: 3000,  //3秒后超时，如果为0则永不超时
    handle: function(type, data, evt){
      if(type == "load") { alert(data); } //data is a object or value
      else if (type == "error") { alert(data.message); } //data is the error object
      else { ; } //other events maybe need handled
    }
  });
 
  下面是一个Post的例子:
 
  dojo.io.bind({
    url: "http://localhost/test.aspx", //要提交的页面地址
    mimetype: "text/html", //请求的页面的类型，应该设置为与你请求页面类型对应的mimetype
    timeoutSeconds: 3000,  //3秒后超时，如果为0则永不超时
    method: "POST",
    formNode: dojo.byId("myForm"), //指定提交的Form名称

    load: function(type, data, evt) { alert(data); }, //type should be "load", data is that we wanted
    error: function(type, error) { alert(error.message); }, //error is dojo.io.Error
    timeout: function(type) { alert("请求超时！"); }
  });

  另一个Post的例子(without Form to post):

  dojo.io.bind({
    url: "http://localhost/test.aspx", //要提交的页面地址
    mimetype: "text/html", //请求的页面的类型，应该设置为与你请求页面类型对应的mimetype
    timeoutSeconds: 3000,  //3秒后超时，如果为0则永不超时
    method: "POST",
    content: {a: 1, b: 2}, //要提交的数据

    load: function(type, data, evt) { alert(data); }, //type should be "load", data is that we wanted
    error: function(type, error) { alert(error.message); }, //error is dojo.io.Error
    timeout: function(type) { alert("请求超时！"); }
  });

dojo.io.queueBind

  有时，我们需要一次发出多个网页请求，则应该使用dojo.io.queueBind，因为浏览器可能只允许同时发出有限个数的请求，如果是使用dojo.io.bind的话，则有可能会申请不到新的XMLHttp对象而导致出错。

  用法与dojo.io.bind是一样的。

dojo.io.argsFromMap

  用来把对象转换为URL的参数形式
 
Usage Example:

  dojo.io.argsFromMap({a:1,b:2,c:3}); //will return "c=3&b=2&a=1"
  dojo.io.argsFromMap({name:"名称",value:"值"},"utf"); //will return "value=%E5%80%BC&name=%E5%90%8D%E7%A7%B0", 有中文的话应该指定utf格式，否则dojo.string.encodeAscii返回的编码是很怪异的
  dojo.io.argsFromMap({a:1,b:2,c:3}, "utf", "c"); //will return "b=2&a=1&c=3"，最后一个参数可以控制指定名称的值出现在最后
 

dojo.io.setIFrameSrc

  设置IFrame的Src
 
Usage Example:

  dojo.io.setIFrameSrc(dojo.byId("myFrame"), "http://localhost/test.htm"); //myFrame打开指定的网页
  dojo.io.setIFrameSrc(dojo.byId("myFrame"), "http://localhost/test.htm", true); //myFrame打开指定的网页，并覆盖浏览器的历史记录

TODO: 补充一个kwArgs的例子，我之前在网上看见过，可是现在无论如何也找不到相关的页面了，只好以后在举例了

模块：dojo.io.BrowserIO

基本上就提供了dojo.io.XMLHTTPTransport这个对象

XMLHTTPTransport一般能够满足我们的需求，但是其有几个限制：它不能传输文件，不能够成功执行跨域名的远程请求，并且不支持 file:// 这样的协议

因此，根据应用要求，我们可能会需要选用其它的transport: dojo.io.IframeTransport, dojo.io.repubsubTranport, dojo.io.ScriptSrcTransport, ShortBusTransport

dojo.io.IframeTransport，用法与xmlhttp是一样的，其优点就是可以跨域，不存在任何的安全问题
如果 Request指定的mimetype是text或javascript，返回的内容应该是放在第一个textarea里的内容，如果指定的 mimetype是html，则IFrame里的html则是需要的内容。因为浏览器兼容的原因，IframeTransport不能正确处理返回类型为 XML的请求。