fixopen

CSS和表格

fixopen — Fri, 29 Feb 2008 22:37:04 +0800

作者: fixopen 链接：http://fixopen.javaeye.com/blog/166290 发表时间: 2008年02月29日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

今天看了hax的blog，不知道哪个项里面提到了CSS面对表格的col的时候的尴尬。后来深入思考了一下，发现这其实是一个本质性的困难。而且问题并不是出现在CSS上，而是出现在XML上。

由于XML要求任何一个元素（除了根元素）都必须有且只有一个父元素，这就导致XML的table模型有些不自然，因为，一个cell显然是一个row的子，但是我们也可以说它同时也是col的子，可是由于XML（DOM）强制的树状模型，导致这个没有办法实现。这可以说是层次型数据和关系型数据的一个典型分野。在关系型数据库中，col可以认为是描述row数据的数据，也就是元数据，或者叫做关系。想要真正的解决这个问题，也就是说，想要XML能够自然的描述table，显然需要打破只有一个父这个局限性，对于table来说，需要两个父，因为table是二维的。但是，一放纵未免再放纵，能够有两个父显然就要想到为什么不能有多个父……，这显然超出了XML最初的预想，也超出了层次型数据模型的能力，什么时候能够把层次型模型和关系型模型无缝的融合起来（还有网状数据模型，跟现在的Web本身一样：），什么时候table在XML描述就没有问题了。

上面提出的这个方案可以说有点太迂远，不适合作为真正的解决方案推荐给网页设计者们。我们考虑一个可以实现的。

本质上CSS只是给出一个或者一些元素的外观，所以，它本身不受层次和关系模型的困扰。而就算CSS中的C是层次型生效的，也不影响我们对一个元素规定多个样式，它们会叠加起来的。

就像很难用一个类型体系（分类体系）把知识组织起来一样，从CSS的表现角度来说，Web Page上的元素也很难分类一个特定的类，它们总是有可能隶属于不同的类，比如：它们可以归为高亮（强调）类，也可以同时归为楷体（内容）类。幸运的是，CSS从来没有限制自己的叠加，虽然它大多数情况下思考的角度是子继父样，然后叠加自己特有的样子，但是毕竟它提供了一个叠加的机制，这样我们就可以随意的叠加了。

现在的问题是，如果规定了col的样式，如何应用到隶属于col的cell上？我们看过委员会的解释，知道不能采用子继父样这个通用的CSS Render机制，是不是就没有办法了呢？

不是。仔细考虑col的本质，col规定了table的结构信息，也就是说，它其实规定了row中数据的元数据。规定col的样式的意义是什么？

这不禁让我们想起了一系列相关的元素，规定head的样式的意义是什么？规定base font的意义是什么？规定title的意义是什么？这些元素归根结底都是元数据。对于它们的规定要影响到它们影响到的数据才行。所以，规定base font的样式应该影响到font的样式，而规定col的样式应该影响到row（进而影响到cell）的样式。

焦点集中到“查找一个元素可以应用的样式”这一个步骤上，我们也只需要改变这一个步骤，能够区分出XML（XHTML）中的元数据和数据，并且能够理解元数据所描述或者关联的数据，就可以把该元数据的样式应用到其所描述的数据上。

这个方案应该是比较完善的，并且是可以扩展的。我想，除了XML本身的层次结果以外，元数据和数据这个层次结构（显然可以层层叠加，也是一个潜在的无限层次的树）也是一个重要的考虑维度，并且潜在的对于元素的外观的影响应该比XML本身的层次结构影响更大。

不知道W3C会不会增加这个看起来比较复杂的方案？

它们最初的方案似乎是改进table模型，但是，其实不仅仅是table模型本身，所有的数据都潜在的有这样一个问题。尤其是那些自说明文档，它们常常是自包含的，也就是说，是数据和元数据存放在一起的。所以，必须有一套机制用来指定这个层次关系。

之所以有这样的多个维度的层次关系，原因还是上面说的【很难用一个类型体系（分类体系）把知识组织起来】，不仅仅对于表现有影响，实际上，对数据的影响是通过对表现的影响展现出来了而已。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

TimerAgent

fixopen — Tue, 13 Nov 2007 16:38:01 +0800

作者: fixopen 链接：http://fixopen.javaeye.com/blog/140290 发表时间: 2007年11月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

一个定时器队列
实现了一个高性能的定时器队列处理系统，基本的实现思路是把所有的定时器请求按超时的前后顺序排入队列中，然后不断的查看是否开始的定时器超时已经到达，如果到达则调用回调处理函数。
这个定时器队列依赖于时间处理的函数和线程，这两个都是平台相关的，不过幸运的是我把他们包装起来了，也就意味着这儿有一个简单的线程包装库。同时有一个小小的可用的可池化的线程的实现。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

一个简单的目录遍历器

fixopen — Tue, 13 Nov 2007 15:46:36 +0800

作者: fixopen 链接：http://fixopen.javaeye.com/blog/140275 发表时间: 2007年11月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

只适合在Windows系统下[包括WinCE]使用。主要是因为依赖于Windows平台的CString和FindFirstFile、FindNextFile以及FindClose系列函数。其实对于CString的依赖并不是必要的，只是方便了Find*系列函数的调用而已。
examples里面是一些使用这个简单遍历器的例子。包括删除目录中所有文件，复制到另一个目录，生成vector或者一个别的表达等等。
StringOp实现了std::string和CString之间的转换。
当然，我知道，boost实现了一个更漂亮的目录访问器，并且显然功能更强，适应性更好，但是由于我想到我仍然不得不在自己的平台上实现一个目录遍历器，因此我觉得它可能仍然是有用的。我就没有办法把boost的实现在WinCE上编译通过，它的代码如同天书般晦涩，我知道这是由于要适应多个平台导致的，可是这仍然阻止不了我不喜欢读它。希望你能喜欢这个简单的实现，虽然有很多限制，但是在相应平台上立即可用的一个小巧实现。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

一点实用代码

fixopen — Tue, 13 Nov 2007 13:33:10 +0800

作者: fixopen 链接：http://fixopen.javaeye.com/blog/140195 发表时间: 2007年11月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

有限状态机
实现了一个确定型的有限状态机，可以向它注册状态跃迁规则和动作，然后在事件发生的时候通知它，别的都由它实现了。动作的原型是一个void (*)(void* params)的函数指针。
FSM的实现不依赖于任何超越标准C++的内容，也就是说，它可以使用在任何支持标准C++的环境中。顺便说一下，我在WinCE和Windows上都使用过它。

HTML2TEXT
一个简单的例子使用有限状态机，它能够实现快速的把HTML文件转换为TEXT文件，具体的说，就是把标签（头尾tag）去掉，同时其属性也被去掉，把注释内容去掉，把脚本和内嵌样式单中的内容去掉，把实体引用转换为实体代表的内容本身。该例子只是为了展现有限状态机的使用方式，没有考虑HTML中的标签的大小写的问题，如果要考虑也不会复杂多少。
HTML2TEXT的实现也完全是标准语言和库实现的，只是采用了*_s之类的安全的函数，在某些环境下不可实现，不过可以简单的替换成没有_s的相应版本。

实现的基本描述：
顺次的扫描HTML文件（当作一个以零结尾的内存区域），碰到标签<字符，开始忽略其内容，碰到>字符，重新开始记录。碰到时重新开始记录，同时，碰到时重新开始，style也是一样的处理方式，状态机的状态相当少，包括Normal、Tag、Comment、Style、Script、Entity、End，状态机的开始状态是Normal，最后状态是End，中间可以在这些状态之间跳转。可能的事件包括： eFindScriptBegin，eFindScriptEnd，eFindStyleBegin，eFindStyleEnd， eFindCommentBegin，eFindCommentEnd，eFindTagStart，eFindTagStop， eFindEntityStart，eFindEntityStop，eFindEnd。它们都很清晰直白，尤其是参看了initFSM_的时候更是如此。它的输出文件也是一个以零终止的内存区域，不需要由客户分配，在析构该对象时自动释放。

其中比较差的一点是我对Parameter结构的使用，我是特意这样演示的，主要是想展现对于FSM灵活的使用方式，其实最常见也最实用的方式是只使用this作为参数。

显然，HTML2TEXT可以非常容易得扩展成一个完整的HTML Parse【可以加上DOM支持】，再加上HTML Render【包括CSS的支持】，Javascript支持和HTTP支持，就是一个Web Browser了。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

合适的地方使用合适的技术

fixopen — Wed, 06 Jun 2007 18:24:22 +0800

作者: fixopen 链接：http://fixopen.javaeye.com/blog/87428 发表时间: 2007年06月06日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

在合适的地方使用合适的技术，我想这一点没有人会反对。而且大多数人都会觉得做到这一点极端简单，无需乎强调。大家可能会觉得问题倒是在于怎么断定什么是合适的技术这个问题。

但其实这两个问题（1、使用合适的技术，2、判定技术是否合适）并没有明确的分界线。因为显然如果不能判定技术是否合适，我们就不能使用合适的技术。

现在说一下我判断技术是否合适的基本原则。1、要经过时间的考验。2、要有比较严密的理论基础。3、技术本身的流行度高。

看看软件开发过程中涉及到的问题。1、理解问题域。这个过程叫做什么业务建模也罢，叫做什么需求分析也罢，主要的目的就是理解问题域。2、设定解决方案。这个区间承上启下，是一个关键环节。它一方面影响到问题的解决，一方面也反过来影响到问题的理解。因为解决方案是一个人对问题理解和知识结构做输入产生的输出，而知识结构跟问题理解是一个扯不清的互相关联的参数。3、实际的解决问题。好多人认为，这个环节比较简单，其实不然，这个环节要把一个世界里的东西投射到另一个世界里（从现实世界到计算机世界），这里面就会涉及到如何投射的问题，而如何投射显然依赖于：问题模型、计算机模型。大多数人会认为这两个中前一个已经完成了，而后一个很简单，所以投射不会很复杂，可事实上绝对不是如此，原因是：我们一般并不会把问题模型直接投射到裸的（原始的）计算机模型，而是投射到被各种装备大大增强了的计算机模型上，比如，我们不会直接处理硬盘的数据读写，而可能是考虑把数据放入数据库系统等等。显然，这个投射过程严重依赖于我们对于目标机器的设想和假定。也依赖于我们个人占有的信息量或者叫做知识量。4、各种偶发事件的处理。这里面主要包括信息的翻译失真，投射的不匹配导致的困难，经济压力和时间压力等等。

所以，我们一定要在合适的地方使用合适的技术，才能满足在特定性价比的情况下制造出产品——软件系统。

关于问题与和解决方案，属于特定的领域的专业知识，有其特殊性，我大体上不涉及，我只关注实际的解决问题这个环节。我们知道，工作主要来源于投射，而投射的工作量依赖于问题域和解空间的差异性的大小。差异越小，同质化越强，投射越简单，反之亦反。

这就要求我们引出一个概念叫做DSL。这个概念的引入主要是想弥补我们的翻译（投射）的巨大鸿沟，通过一个或者多个中间翻译站，我们可以比较自然和直观的在人脑复杂度承受范围之内解决复杂问题。

到现在为止，我们都在说形而上的理论，现在我们从形而下的实践开始，两头逼近，搞出个结论。

对于任何软件系统，都会牵扯到：输入输出、处理、状态（或数据）存储（或者叫做永久化）。处理各不相同，可重用的一些方面也已经被总结出来了，比如：事务，身份认证和安全，冗余备份和分布，处理过程（或者运行轨迹）的记录等等，这些是处理中可以重用的部分，总体来说，处理可以重用的比输入输出和状态存储少的多。

对于输入输出，根据其对象不同，可以分为：跟人类的交互，跟机器（网络节点、别的进程等等）的交互两大类。根据其内容的不同，可以分为实体信息的交互和控制信息的交互。我们对于实体信息，总结的和可重用的东西比较多，比如：实体信息包括数字、字符（串）、图形图像、声音、视频以及混合信息，它们的传输、存储、解析翻译（Codec）和获取生成都是可以重用的部件。而对于控制信息，其定义就有点杂乱，投射到人类交互这个层面，会有好多称作Control的可重用部件用来表达人和软件系统交换的控制信息，投射到机器交互这个层面，显然就是我们不同的【网络】通信协议了，它们主要是维持和管理控制实体信息交互而采用的，一般称作信令。

对于状态存储，现在比较自然和流行的包括三类，二进制内存存储，二进制或者文本的【xml】文件存储，二进制的数据库存储。其实（文本可以认为是一种特化的二进制）。对于这些实体信息或者叫做状态，它们的操纵和处理可重用的地方非常大。

上面简要分析了最低层次的（相对而言）的Domain，对于这些Domain，我们有没有对应的DSL呢？

有的，显然，数据领域是SQL、XQuery，处理领域有无数种计算机编程语言，它们都比较合格，尤其是提供了OO能力和Aspect能力以后，用来描述处理一般没有什么困难，而表现领域（输入输出领域）呢？我认为还是有的，比如：适合图形表现的SVG，适合控制表现的XForms，适合多种实体信息表现的XHTML2（注意其中的object），适合视频表现的Flash，这些都是该领域的特定语言，可以非常自然高效的表达希望表达的信息。

从这个低层次的分析我们就发现，我们现在把问题空间投射到解空间的方法并不是最好，甚至可以说是相当的差，而近来有些公司已经意识到这一点，比如 Microsoft，Adobe，Sun，它们分别推出了XAML，MXML，JavaFX，用来为输入输出层提高生产率。问题不在于它们的技术，而在于：1、它们都期望绑定程序员，2、它们的技术都有一定的壁垒，3、现在它们还都不够流行。所以，我个人认为如果提供一个基于标准（XHTML、 XForms、SVG+Other）的表现层运行时，会有很大的竞争力。当然，我的市场敏感度极低，大家自己分辨吧。

有些程序员总是固守着自己的那一块小地盘，期待着所有的事情都用一个办法搞定，这不是不行，只是不够好而已。采用多种DSL构造Application，一个潜在的问题是这些不同的DSL定义的部件组装在一起的问题。ORM部分的解决了数据领域和业务领域的组装问题，而新出现的表现层Runtime期待着解决业务领域和输入输出领域的组装。

软件开发的前途看来还是比较光明的。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

依赖顺序是罪恶

fixopen — Fri, 16 Feb 2007 19:23:30 +0800

作者: fixopen 链接：http://fixopen.javaeye.com/blog/54690 发表时间: 2007年02月16日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

C和C++语言是流行和常用的依赖于顺序的语言。C++略为有点改进，在类范围内部不依赖于顺序。依赖于顺序是一种惩罚，是一种不重视程序员感受的表现，并且在深层次要求采用采用声明和实现分开，因而也就不能维持DRY原则。违背DRY会导致维护复杂。
我详细说明一下为什么依赖顺序是罪恶的。
大家都知道抽象是一种强大的能力，但是，依赖于顺序强迫我们只能从低层次的细节开始，这跟现如今流行的IDE的智能完成一样。我们不得不把所有的细节描述完备，才能构造更大的构件。
我还是用一个实例来说明吧。
我为了练习的目的，试图写一个HTTP Client，自然，我是从阅读RFC规范开始的。通过扫描RFC的目录和快速掠过其内容，我们发现HTTP是一个请求响应模式的简单协议，其请求和响应都是所谓的Message，显然，只要我们能解析和构造这个Message，我们就大致完成任务。
于是就有了：

namespace Http
{
    class Message
    {
    public:
        MessageHeader headers;
        CRLF crlf;
        MessageBody body;
        std::string toString(void)
        {
            return headers.toString() + crlf.toString() + body.toString();
        }
    };

    class MessageHeader
    {
    public:
        std::vector fields;
        std::string toString(void)
        {
            std::string result;
            for (int i = 0; i < fields.size(); ++i)
            {
                result += fields[i].toString();
            }
            return result;
        }
    };

    class Field
    {
    public:
        FieldName name;
        Colon colon;
        FieldValue value;
        CRLF crlf;
        std::string toString(void)
        {
            return name.toString() + colon.toString() + value.toString() + crlf.toString();
        }
    };

    class FieldName
    {
    public:
        FieldNameValue name;
        std::string toString(void)
        {
            std::string result;
            switch (name)
            {
            case CacheControl:
                result = "Cache-Control";
                break;
                ......
            }
            return result;
        }

        FieldNameValue fromString(std::string fieldName)
        {
            FieldNameValue result;
            if (fieldName == "Cache-Control")
                result = CacheControl;
            else if (...)
                ...
            return result;
        }
    };

    enum FieldNameValue
    {
        //generic headers
        CacheControl,
        Connection,
        Date,
        Pragma,
         ......
}

我想，上面的代码非常的直接了当。几乎不需要解释，类似于递归下降法制作解析器，而事实上，确实是下降的，但是递归没有，因为HTTP的Message格式还没有那么强大和灵活。稍微有点奇特的是FieldName和FieldNameValue这一对，它们合作构成了我设想的枚举，这也说明了C/C++语言的枚举并不强大到可以作为一个抽象机制使用，当然，这不是我们焦点。暂且不论。

由于其中的toString都是很简单的，所以我准备把它们做成内联函数，这个无可厚非，我们看看就是这个要求是怎么导致我们需要扭曲我们的代码的。

首先需要说明的是：上面的代码不能通过C++编译器的编译。原因很简单：编译器看到MessageHeader被使用的时候还没有发现其定义，会给出一大堆抱怨。怎么办？我们给出一个前向声明吧。也很简单，在使用之前声明一下就行了：class MessageHeader。把它加在使用之前的任意地方，编译器就应该不说话了吧。

哦，还是不行，原因是：对了，它要求必须有完整的类定义才能定义该类的对象，别忘了，C++是值语义的语言。好吧，我们改造成指针……，类型后面加上*，一连串的.变成->，应该没有问题了吧（如果你做过实际的项目，你就知道：这个修改的代价是非常高的，不过区分指针和原始对象不是我们批判的焦点，这里不再深入）。啊……还是不行，原因仍然很简单，就算可以定义指针而不是真正的对象，我们仍然不不能够调用该指针对象的方法，原因是：我（编译器）没有看到类型的定义，怎么知道有没有该方法可以调用呢？

现在我们的选择有三个，但是都不够优雅。
一、我们调整类型定义的顺序，把低层次的构件往前挪。
二、我们把成员函数的实现挪到最后，这时候它已经看到所有的定义了。
三、这是二的彻底化，干脆移动其实现到另一个文件。
方法一的缺陷就是，我们不再能够自然的从上而下看出我们设计的脉络。这跟我看HTTP的RFC一个缺陷是一样的，HTTP的RFC就不是采用自上而下描述的，而是先描述了一些基础的构件，在描述了整体结构，看得人晕头转向，另外，协议中有大量的用途和功能分析，我不是说这不好，但是作为协议这让人分神。可以把功能或者需求放在开始诱导大家构思HTTP应该怎样设计。而不是放在HTTP协议都描述了以后才描述功能。
方法二和方法三本质上是一样的，但是方法三的可维护性就更差一些了，因为所有的修改都得涉及到两个文件，而且，方法三不再能够是inline的，这个代价让我觉得非常不快。而方法二确实仍保持inline，但是，一旦修改我还是得从头到尾的查找。让我写两遍相同的函数头也让我不爽。
而最本质的原因就是：我没有办法让一个决策（函数签名）在一个地方说明，必须出现在两个地方，这是对DRY或者叫做SPOT原则的公然违反，它们会导致大量的微妙的问题和产生难以维护的代码。
C++在很大程度上鼓励我们采用第三种方案，这也是C++中的正统方案，只要我们坚持顺序依赖，我们就不得不倾向于这种方案。顺序依赖把维持依赖关系的责任推给了程序员而不是编译器自己去解决，这当然简化了编译器，但是却使得程序员的日子更艰难。那么，顺序依赖究竟应该是谁的责任呢？是该由程序员处理的呢，还是该由编译器处理的？
我们先大而化之描述一下依赖。依赖表示一个构件（这儿的构件包括函数，类，全局变量，源文件等等任意可以用来搭建整个系统的部分）对别的构件的使用。我们很自然很直观的能感受到，只要我们使用了别的构件，编译器显然知道我们的构件依赖于那些使用的构件，所以，让程序员维持依赖是不必要的。
但是还有一个问题：构件A依赖于构件B，这个编译器知道，但是构件B在哪儿？这个编译器不知道。显然，我们需要而且也只需要在某个地方描述一下这个构件跟位置的映射，我们的编译器就可以工作了。如果我们把这种映射放在任何构件里面，这样势必会导致这种映射关系描述上的重复，导致大量的维护问题。显然，最适合描述构件跟位置的映射关系的地方是工程的配置文件。它是整个工程级别的属性。
那么顺序依赖是什么呢？顺序依赖本质上是希望把构件和位置的映射关系消除。它要求所有依赖的东西必须在它之前出现，这样，被依赖方也就自然不需要指定位置了，它就在前面。这个有利于分块编译（不知道大家注意没有，分块编译的用处似乎并不是很大，无论是大工程还是小工程，因为：毕竟编译只是一个阶段，而且维持构件是否是最新编译版本似乎也一点都不难），但是实现分块编译导致需要大量的重复编译，毕竟任何被多次依赖的组件都必须多次被编译。并且分块编译要求类似于Makefile之类的支持环境，现代的语言及其开发环境都完全不支持分块编译了，它们都采用运行时动态装载这个更灵活的模式。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

软件开发的本质

fixopen — Mon, 04 Dec 2006 13:46:36 +0800

作者: fixopen 链接：http://fixopen.javaeye.com/blog/37123 发表时间: 2006年12月04日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

关于这个话题，我似乎说过好多次了。软件系统其实就是现实系统的抽象，就是现实系统的模型。最近，看到一个论点，是这样说的：软件建模（架构）的过程其实就是一个定理证明的过程。我得说，在我看来，这有一定的真理性。但是事实有一定的差异。基本原因是：我们碰到问题的时候，并不总是对问题的解决方案一无所知的，或者更确切的说，对问题的解决方案几乎总是有一定的了解得。这时候，证明的过程其实并不是很明显，反而是表达的过程成了重头戏。
这儿，我在阐述一遍我的观点，软件就是模型，就是抽象。基于上面的描述，软件开发过程也就是构思模型和表达模型的过程。由于表达和构思互相影响，密不可分（大家可以参照语言和思维的关系来理解这一点），所以我只说表达这个方面。我们的模型如何表达现实？
必须解释一下数据的概念了。数据就是表达关系的，关系紧密到一定程度就叫做属性了。一个客体，或者常常被称作对象，物件，就是用其属性描述的。我们描述了客体，也就反映了现实。而客体是数据的集合，所以我们操作数据也就是反映了现实的行为了。对于数据的操作我们有CRUD（Create Read Update Destory）四个，对应于数据库系统的INSERT、SELECT、UPDATE、DELETE四个基本的数据操纵原语。所有的客体的行为，最终都是用CRUD来表达的。所以，只要我们正确地表达了数据，我们就能够正确地表达软件系统。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

Event系统相关接口

fixopen — Sun, 15 Oct 2006 18:43:40 +0800

作者: fixopen 链接：http://fixopen.javaeye.com/blog/27883 发表时间: 2006年10月15日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

interface EventTarget {
void addEventListener(in DOMString type, in EventListener listener, in boolean useCapture);
void removeEventListener(in DOMString type, in EventListener listener, in boolean useCapture);
boolean dispatchEvent(in Event evt) raises(EventException);
};

interface EventListener {
void handleEvent(in Event evt);
};

interface Event {
// PhaseType
const unsigned short CAPTURING_PHASE = 1;
const unsigned short AT_TARGET = 2;
const unsigned short BUBBLING_PHASE = 3;

readonly attribute DOMString type;
readonly attribute EventTarget target;
readonly attribute EventTarget currentTarget;
readonly attribute unsigned short eventPhase;
readonly attribute boolean bubbles;
readonly attribute boolean cancelable;
readonly attribute DOMTimeStamp timeStamp;
void stopPropagation();
void preventDefault();
void initEvent(in DOMString eventTypeArg, in boolean canBubbleArg, in boolean cancelableArg);
};

exception EventException {
unsigned short code;
};
// EventExceptionCode
const unsigned short UNSPECIFIED_EVENT_TYPE_ERR = 0;

interface DocumentEvent {
Event createEvent(in DOMString eventType) raises(DOMException);
};

interface UIEvent : Event {
readonly attribute views::AbstractView view;
readonly attribute long detail;
void initUIEvent(in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in views::AbstractView viewArg, in long detailArg);
};

interface MouseEvent : UIEvent {
readonly attribute long screenX;
readonly attribute long screenY;
readonly attribute long clientX;
readonly attribute long clientY;
readonly attribute boolean ctrlKey;
readonly attribute boolean shiftKey;
readonly attribute boolean altKey;
readonly attribute boolean metaKey;
readonly attribute unsigned short button;
readonly attribute EventTarget relatedTarget;
void initMouseEvent(in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in views::AbstractView viewArg, in long detailArg, in long screenXArg, in long screenYArg, in long clientXArg, in long clientYArg, in boolean ctrlKeyArg, in boolean altKeyArg, in boolean shiftKeyArg, in boolean metaKeyArg, in unsigned short buttonArg, in EventTarget relatedTargetArg);
};

interface MutationEvent : Event {
// attrChangeType
const unsigned short MODIFICATION = 1;
const unsigned short ADDITION = 2;
const unsigned short REMOVAL = 3;

readonly attribute Node relatedNode;
readonly attribute DOMString prevValue;
readonly attribute DOMString newValue;
readonly attribute DOMString attrName;
readonly attribute unsigned short attrChange;
void initMutationEvent(in DOMString typeArg, in boolean canBubbleArg, in boolean cancelableArg, in Node relatedNodeArg, in DOMString prevValueArg, in DOMString newValueArg, in DOMString attrNameArg, in unsigned short attrChangeArg);
};

具体的事件名称和类型如下：
UIEvent:
DOMFocusIn
DOMFocusOut
DOMActivate

MouseEvent:
click
mousedown
mouseup
mouseover
mousemove
mouseout

MutationEvent:
DOMSubtreeModified
DOMNodeInserted
DOMNodeRemoved
DOMNodeRemovedFromDocument
DOMNodeInsertedIntoDocument
DOMAttrModified
DOMCharacterDataModified

HTMLEvents(DocumentEvent):
load
unload
abort
error
select
change
submit
reset
focus
blur
resize
scroll
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

Style&CSS的编程接口

fixopen — Sun, 15 Oct 2006 18:43:06 +0800

作者: fixopen 链接：http://fixopen.javaeye.com/blog/27882 发表时间: 2006年10月15日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

interface StyleSheet {
readonly attribute DOMString type;
attribute boolean disabled;
readonly attribute Node ownerNode;
readonly attribute StyleSheet parentStyleSheet;
readonly attribute DOMString href;
readonly attribute DOMString title;
readonly attribute MediaList media;
};

interface StyleSheetList {
readonly attribute unsigned long length;
StyleSheet item(in unsigned long index);
};

interface MediaList {
attribute DOMString mediaText;
// raises(DOMException) on setting

readonly attribute unsigned long length;
DOMString item(in unsigned long index);
void deleteMedium(in DOMString oldMedium) raises(DOMException);
void appendMedium(in DOMString newMedium) raises(DOMException);
};

interface LinkStyle {
readonly attribute StyleSheet sheet;
};

interface DocumentStyle {
readonly attribute StyleSheetList styleSheets;
};

interface CSSStyleSheet : stylesheets::StyleSheet {
readonly attribute CSSRule ownerRule;
readonly attribute CSSRuleList cssRules;
unsigned long insertRule(in DOMString rule, in unsigned long index) raises(DOMException);
void deleteRule(in unsigned long index) raises(DOMException);
};

interface CSSRuleList {
readonly attribute unsigned long length;
CSSRule item(in unsigned long index);
};

interface CSSRule {
// RuleType
const unsigned short UNKNOWN_RULE = 0;
const unsigned short STYLE_RULE = 1;
const unsigned short CHARSET_RULE = 2;
const unsigned short IMPORT_RULE = 3;
const unsigned short MEDIA_RULE = 4;
const unsigned short FONT_FACE_RULE = 5;
const unsigned short PAGE_RULE = 6;

readonly attribute unsigned short type;
attribute DOMString cssText;
// raises(DOMException) on setting
readonly attribute CSSStyleSheet parentStyleSheet;
readonly attribute CSSRule parentRule;
};

interface CSSStyleRule : CSSRule {
attribute DOMString selectorText;
// raises(DOMException) on setting
readonly attribute CSSStyleDeclaration style;
};

interface CSSMediaRule : CSSRule {
readonly attribute stylesheets::MediaList media;
readonly attribute CSSRuleList cssRules;
unsigned long insertRule(in DOMString rule, in unsigned long index) raises(DOMException);
void deleteRule(in unsigned long index) raises(DOMException);
};

interface CSSFontFaceRule : CSSRule {
readonly attribute CSSStyleDeclaration style;
};

interface CSSPageRule : CSSRule {
attribute DOMString selectorText;
// raises(DOMException) on setting
readonly attribute CSSStyleDeclaration style;
};

interface CSSImportRule : CSSRule {
readonly attribute DOMString href;
readonly attribute stylesheets::MediaList media;
readonly attribute CSSStyleSheet styleSheet;
};

interface CSSCharsetRule : CSSRule {
attribute DOMString encoding;
// raises(DOMException) on setting
};

interface CSSUnknownRule : CSSRule {
};

interface CSSStyleDeclaration {
attribute DOMString cssText;
// raises(DOMException) on setting
DOMString getPropertyValue(in DOMString propertyName);
CSSValue getPropertyCSSValue(in DOMString propertyName);
DOMString removeProperty(in DOMString propertyName) raises(DOMException);
DOMString getPropertyPriority(in DOMString propertyName);
void setProperty(in DOMString propertyName, in DOMString value, in DOMString priority) raises(DOMException);
readonly attribute unsigned long length;
DOMString item(in unsigned long index);
readonly attribute CSSRule parentRule;
};

interface CSSValue {
// UnitTypes
const unsigned short CSS_INHERIT = 0;
const unsigned short CSS_PRIMITIVE_VALUE = 1;
const unsigned short CSS_VALUE_LIST = 2;
const unsigned short CSS_CUSTOM = 3;
attribute DOMString cssText;
// raises(DOMException) on setting

readonly attribute unsigned short cssValueType;
};

interface CSSPrimitiveValue : CSSValue {
// UnitTypes
const unsigned short CSS_UNKNOWN = 0;
const unsigned short CSS_NUMBER = 1;
const unsigned short CSS_PERCENTAGE = 2;
const unsigned short CSS_EMS = 3;
const unsigned short CSS_EXS = 4;
const unsigned short CSS_PX = 5;
const unsigned short CSS_CM = 6;
const unsigned short CSS_MM = 7;
const unsigned short CSS_IN = 8;
const unsigned short CSS_PT = 9;
const unsigned short CSS_PC = 10;
const unsigned short CSS_DEG = 11;
const unsigned short CSS_RAD = 12;
const unsigned short CSS_GRAD = 13;
const unsigned short CSS_MS = 14;
const unsigned short CSS_S = 15;
const unsigned short CSS_HZ = 16;
const unsigned short CSS_KHZ = 17;
const unsigned short CSS_DIMENSION = 18;
const unsigned short CSS_STRING = 19;
const unsigned short CSS_URI = 20;
const unsigned short CSS_IDENT = 21;
const unsigned short CSS_ATTR = 22;
const unsigned short CSS_COUNTER = 23;
const unsigned short CSS_RECT = 24;
const unsigned short CSS_RGBCOLOR = 25;

readonly attribute unsigned short primitiveType;
void setFloatValue(in unsigned short unitType, in float floatValue) raises(DOMException);
float getFloatValue(in unsigned short unitType) raises(DOMException);
void setStringValue(in unsigned short stringType, in DOMString stringValue) raises(DOMException);
DOMString getStringValue() raises(DOMException);
Counter getCounterValue() raises(DOMException);
Rect getRectValue() raises(DOMException);
RGBColor getRGBColorValue() raises(DOMException);
};

interface CSSValueList : CSSValue {
readonly attribute unsigned long length;
CSSValue item(in unsigned long index);
};

interface RGBColor {
readonly attribute CSSPrimitiveValue red;
readonly attribute CSSPrimitiveValue green;
readonly attribute CSSPrimitiveValue blue;
};

interface Rect {
readonly attribute CSSPrimitiveValue top;
readonly attribute CSSPrimitiveValue right;
readonly attribute CSSPrimitiveValue bottom;
readonly attribute CSSPrimitiveValue left;
};

interface Counter {
readonly attribute DOMString identifier;
readonly attribute DOMString listStyle;
readonly attribute DOMString separator;
};

interface ViewCSS : views::AbstractView {
CSSStyleDeclaration getComputedStyle(in Element elt, in DOMString pseudoElt);
};

interface DocumentCSS : stylesheets::DocumentStyle {
CSSStyleDeclaration getOverrideStyle(in Element elt, in DOMString pseudoElt);
};

interface DOMImplementationCSS : DOMImplementation {
CSSStyleSheet createCSSStyleSheet(in DOMString title, in DOMString media) raises(DOMException);
};

interface ElementCSSInlineStyle {
readonly attribute CSSStyleDeclaration style;
};

interface CSS2Properties {
attribute DOMString azimuth;
// raises(DOMException) on setting
attribute DOMString background;
// raises(DOMException) on setting
attribute DOMString backgroundAttachment;
// raises(DOMException) on setting
attribute DOMString backgroundColor;
// raises(DOMException) on setting
attribute DOMString backgroundImage;
// raises(DOMException) on setting
attribute DOMString backgroundPosition;
// raises(DOMException) on setting
attribute DOMString backgroundRepeat;
// raises(DOMException) on setting
attribute DOMString border;
// raises(DOMException) on setting
attribute DOMString borderCollapse;
// raises(DOMException) on setting
attribute DOMString borderColor;
// raises(DOMException) on setting
attribute DOMString borderSpacing;
// raises(DOMException) on setting
attribute DOMString borderStyle;
// raises(DOMException) on setting
attribute DOMString borderTop;
// raises(DOMException) on setting
attribute DOMString borderRight;
// raises(DOMException) on setting
attribute DOMString borderBottom;
// raises(DOMException) on setting
attribute DOMString borderLeft;
// raises(DOMException) on setting
attribute DOMString borderTopColor;
// raises(DOMException) on setting
attribute DOMString borderRightColor;
// raises(DOMException) on setting
attribute DOMString borderBottomColor;
// raises(DOMException) on setting
attribute DOMString borderLeftColor;
// raises(DOMException) on setting
attribute DOMString borderTopStyle;
// raises(DOMException) on setting
attribute DOMString borderRightStyle;
// raises(DOMException) on setting
attribute DOMString borderBottomStyle;
// raises(DOMException) on setting
attribute DOMString borderLeftStyle;
// raises(DOMException) on setting
attribute DOMString borderTopWidth;
// raises(DOMException) on setting
attribute DOMString borderRightWidth;
// raises(DOMException) on setting
attribute DOMString borderBottomWidth;
// raises(DOMException) on setting
attribute DOMString borderLeftWidth;
// raises(DOMException) on setting
attribute DOMString borderWidth;
// raises(DOMException) on setting
attribute DOMString bottom;
// raises(DOMException) on setting
attribute DOMString captionSide;
// raises(DOMException) on setting
attribute DOMString clear;
// raises(DOMException) on setting
attribute DOMString clip;
// raises(DOMException) on setting
attribute DOMString color;
// raises(DOMException) on setting
attribute DOMString content;
// raises(DOMException) on setting
attribute DOMString counterIncrement;
// raises(DOMException) on setting
attribute DOMString counterReset;
// raises(DOMException) on setting
attribute DOMString cue;
// raises(DOMException) on setting
attribute DOMString cueAfter;
// raises(DOMException) on setting
attribute DOMString cueBefore;
// raises(DOMException) on setting
attribute DOMString cursor;
// raises(DOMException) on setting
attribute DOMString direction;
// raises(DOMException) on setting
attribute DOMString display;
// raises(DOMException) on setting
attribute DOMString elevation;
// raises(DOMException) on setting
attribute DOMString emptyCells;
// raises(DOMException) on setting
attribute DOMString cssFloat;
// raises(DOMException) on setting
attribute DOMString font;
// raises(DOMException) on setting
attribute DOMString fontFamily;
// raises(DOMException) on setting
attribute DOMString fontSize;
// raises(DOMException) on setting
attribute DOMString fontSizeAdjust;
// raises(DOMException) on setting
attribute DOMString fontStretch;
// raises(DOMException) on setting
attribute DOMString fontStyle;
// raises(DOMException) on setting
attribute DOMString fontVariant;
// raises(DOMException) on setting
attribute DOMString fontWeight;
// raises(DOMException) on setting
attribute DOMString height;
// raises(DOMException) on setting
attribute DOMString left;
// raises(DOMException) on setting
attribute DOMString letterSpacing;
// raises(DOMException) on setting
attribute DOMString lineHeight;
// raises(DOMException) on setting
attribute DOMString listStyle;
// raises(DOMException) on setting
attribute DOMString listStyleImage;
// raises(DOMException) on setting
attribute DOMString listStylePosition;
// raises(DOMException) on setting
attribute DOMString listStyleType;
// raises(DOMException) on setting
attribute DOMString margin;
// raises(DOMException) on setting
attribute DOMString marginTop;
// raises(DOMException) on setting
attribute DOMString marginRight;
// raises(DOMException) on setting
attribute DOMString marginBottom;
// raises(DOMException) on setting
attribute DOMString marginLeft;
// raises(DOMException) on setting
attribute DOMString markerOffset;
// raises(DOMException) on setting
attribute DOMString marks;
// raises(DOMException) on setting
attribute DOMString maxHeight;
// raises(DOMException) on setting
attribute DOMString maxWidth;
// raises(DOMException) on setting
attribute DOMString minHeight;
// raises(DOMException) on setting
attribute DOMString minWidth;
// raises(DOMException) on setting
attribute DOMString orphans;
// raises(DOMException) on setting
attribute DOMString outline;
// raises(DOMException) on setting
attribute DOMString outlineColor;
// raises(DOMException) on setting
attribute DOMString outlineStyle;
// raises(DOMException) on setting
attribute DOMString outlineWidth;
// raises(DOMException) on setting
attribute DOMString overflow;
// raises(DOMException) on setting
attribute DOMString padding;
// raises(DOMException) on setting
attribute DOMString paddingTop;
// raises(DOMException) on setting
attribute DOMString paddingRight;
// raises(DOMException) on setting
attribute DOMString paddingBottom;
// raises(DOMException) on setting
attribute DOMString paddingLeft;
// raises(DOMException) on setting
attribute DOMString page;
// raises(DOMException) on setting
attribute DOMString pageBreakAfter;
// raises(DOMException) on setting
attribute DOMString pageBreakBefore;
// raises(DOMException) on setting
attribute DOMString pageBreakInside;
// raises(DOMException) on setting
attribute DOMString pause;
// raises(DOMException) on setting
attribute DOMString pauseAfter;
// raises(DOMException) on setting
attribute DOMString pauseBefore;
// raises(DOMException) on setting
attribute DOMString pitch;
// raises(DOMException) on setting
attribute DOMString pitchRange;
// raises(DOMException) on setting
attribute DOMString playDuring;
// raises(DOMException) on setting
attribute DOMString position;
// raises(DOMException) on setting
attribute DOMString quotes;
// raises(DOMException) on setting
attribute DOMString richness;
// raises(DOMException) on setting
attribute DOMString right;
// raises(DOMException) on setting
attribute DOMString size;
// raises(DOMException) on setting
attribute DOMString speak;
// raises(DOMException) on setting
attribute DOMString speakHeader;
// raises(DOMException) on setting
attribute DOMString speakNumeral;
// raises(DOMException) on setting
attribute DOMString speakPunctuation;
// raises(DOMException) on setting
attribute DOMString speechRate;
// raises(DOMException) on setting
attribute DOMString stress;
// raises(DOMException) on setting
attribute DOMString tableLayout;
// raises(DOMException) on setting
attribute DOMString textAlign;
// raises(DOMException) on setting
attribute DOMString textDecoration;
// raises(DOMException) on setting
attribute DOMString textIndent;
// raises(DOMException) on setting
attribute DOMString textShadow;
// raises(DOMException) on setting
attribute DOMString textTransform;
// raises(DOMException) on setting
attribute DOMString top;
// raises(DOMException) on setting
attribute DOMString unicodeBidi;
// raises(DOMException) on setting
attribute DOMString verticalAlign;
// raises(DOMException) on setting
attribute DOMString visibility;
// raises(DOMException) on setting
attribute DOMString voiceFamily;
// raises(DOMException) on setting
attribute DOMString volume;
// raises(DOMException) on setting
attribute DOMString whiteSpace;
// raises(DOMException) on setting
attribute DOMString widows;
// raises(DOMException) on setting
attribute DOMString width;
// raises(DOMException) on setting
attribute DOMString wordSpacing;
// raises(DOMException) on setting
attribute DOMString zIndex;
// raises(DOMException) on setting
};
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

Web Application API

fixopen — Sun, 15 Oct 2006 18:29:55 +0800

作者: fixopen 链接：http://fixopen.javaeye.com/blog/27880 发表时间: 2006年10月15日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

由于Ajax的火爆，所以我会重点介绍与它相关的一些技术。下面的文档已经写了很久了，由于上一篇的尖括号搞的我非常之烦，现在才贴出来，见谅。

我将从Window，XMLHttpRequest等这几个主要接口出发（Document前面已经描述了），描述客户端Javascript编程的主要轮廓。另外，值得注意的是，这个领域的变化仍然非常剧烈，我不保证我描述的东西都可用。无论是现在（我描述的东西还太新）还是以后（而且还没有定型）。

interface XMLHttpRequest {
attribute EventListener onreadystatechange;
readonly attribute unsigned short readyState;
void open(in DOMString method, in DOMString uri);
void open(in DOMString method, in DOMString uri, in boolean async);
void open(in DOMString method, in DOMString uri, in boolean async, in DOMString user);
void open(in DOMString method, in DOMString uri, in boolean async, in DOMString user, in DOMString password);
void setRequestHeader(in DOMString header, in DOMString value) raises(DOMException);
void send(in DOMString data) raises(DOMException);
void send(in Document data) raises(DOMException);
void abort();
DOMString getAllResponseHeaders();
DOMString getResponseHeader(in DOMString header);
attribute DOMString responseText;
attribute Document responseXML;
attribute unsigned short status;
// raises(DOMException) on retrieval
attribute DOMString statusText;
// raises(DOMException) on retrieval
};

interface Item {
readonly attribute boolean exists;
readonly attribute DOMString name;
};

interface IntegerItem : Item {
readonly attribute long value;
};

interface BooleanItem : Item {
attribute boolean value;
};

interface StringItem : Item {
readonly attribute DOMString value;
};

interface ContentItem : Item {
attribute Node nodeArg;
attribute unsigned long offset;
};

interface Match {
// MatchTestGroup
const unsigned short IS_EQUAL = 0;
const unsigned short IS_NOT_EQUAL = 1;
const unsigned short INT_PRECEDES = 2;
const unsigned short INT_PRECEDES_OR_EQUALS = 3;
const unsigned short INT_FOLLOWS = 4;
const unsigned short INT_FOLLOWS_OR_EQUALS = 5;
const unsigned short STR_STARTS_WITH = 6;
const unsigned short STR_ENDS_WITH = 7;
const unsigned short STR_CONTAINS = 8;
const unsigned short SET_ANY = 9;
const unsigned short SET_ALL = 10;
const unsigned short SET_NOT_ANY = 11;
const unsigned short SET_NOT_ALL = 12;

readonly attribute unsigned short test;
};

interface MatchInteger : Match {
readonly attribute DOMString name;
readonly attribute long value;
};

interface MatchBoolean : Match {
readonly attribute DOMString name;
readonly attribute boolean value;
};

interface MatchString : Match {
readonly attribute DOMString name;
readonly attribute DOMString value;
};

interface MatchContent : Match {
readonly attribute DOMString name;
readonly attribute Node nodeArg;
readonly attribute unsigned long offset;
};

interface MatchSet : Match {
readonly attribute Node nodeArg;
void addMatch(in Match add);
Match getMatch(in unsigned long index);
};

interface Segment : Match {
attribute Match criteria;
attribute DOMString order;
void addItem(in Item add);
MatchString createMatchString(in unsigned short test, in DOMString name, in DOMString value);
MatchInteger createMatchInteger(in unsigned short test, in DOMString name, in long value);
MatchBoolean createMatchBoolean(in unsigned short test, in DOMString name, in boolean value);
MatchContent createMatchContent(in unsigned short test, in DOMString name, in unsigned long offset, in Node nodeArg);
MatchSet createMatchSet(in unsigned short test);
StringItem createStringItem(in DOMString name);
IntegerItem createIntegerItem(in DOMString name);
BooleanItem createBooleanItem(in DOMString name);
ContentItem createContentItem(in DOMString name);
void getItem(in unsigned long index);
boolean getNext();
};

interface View {
void select(in Node boundary, in unsigned long offset, in boolean extend, in boolean add);
Segment createSegment();
boolean matchFirstSegment(inout Segment todo) raises(DOMException);
long getIntegerProperty(in DOMString name) raises(DOMException);
DOMString getStringProperty(in DOMString name) raises(DOMException);
boolean getBooleanProperty(in boolean name) raises(DOMException);
Node getContentPropertyNode(in DOMString name) raises(DOMException);
unsigned long getContentPropertyOffset(in DOMString name) raises(DOMException);
};

interface VisualView {
readonly attribute DOMString fontScheme;
readonly attribute unsigned long width;
readonly attribute unsigned long height;
readonly attribute unsigned long horizontalDPI;
readonly attribute unsigned long verticalDPI;
VisualCharacter createVisualCharacter();
VisualCharacterRun createVisualCharacterRun();
VisualFrame createVisualFrame();
VisualImage createVisualImage();
VisualFormButton createVisualFormButton();
VisualFormField createVisualFormField();
void select(in Node boundary, n unsigned long offset, in boolean extend, in boolean add);
void matchSegment(in VisualResource segment);
};

interface VisualResource {
};

interface VisualFont : VisualResource {
attribute DOMString matchFontName;
readonly attribute boolean exists;
readonly attribute DOMString fontName;
boolean getNext();
};

interface VisualSegment : VisualResource {
attribute boolean matchPosition;
attribute boolean matchInside;
attribute boolean matchContaining;
attribute long matchX;
attribute long matchY;
attribute long matchXR;
attribute long matchYR;
attribute boolean matchContent;
attribute boolean matchRange;
attribute Node matchNode;
attribute unsigned long matchOffset;
attribute Node matchNodeR;
attribute unsigned long matchOffsetR;
attribute boolean matchContainsSelected;
attribute boolean matchContainsVisible;
readonly attribute boolean exists;
readonly attribute Node startNode;
readonly attribute unsigned long startOffset;
readonly attribute Node endNode;
readonly attribute unsigned long endOffset;
readonly attribute long topOffset;
readonly attribute long bottomOffset;
readonly attribute long leftOffset;
readonly attribute long rightOffset;
readonly attribute unsigned long width;
readonly attribute unsigned long height;
readonly attribute boolean selected;
readonly attribute boolean visible;
readonly attribute unsigned long foregroundColor;
readonly attribute unsigned long backgroundColor;
readonly attribute DOMString fontName;
readonly attribute DOMString fontHeight;
boolean getNext();
};

interface VisualCharacter : VisualSegment {
};

interface VisualCharacterRun : VisualSegment {
};

interface VisualFrame : VisualSegment {
readonly attribute VisualSegment embedded;
};

interface VisualImage : VisualSegment {
readonly attribute DOMString imageURL;
readonly attribute boolean isLoaded;
};

interface VisualFormButton : VisualSegment {
readonly attribute boolean isPressed;
};

interface VisualFormField : VisualSegment {
readonly attribute DOMString formValue;
};

interface EmbeddingElement {
readonly attribute dom::Document contentDocument;
readonly attribute Window contentWindow;
};

// behavior is always special in ECMAScript, this is defined only for the benefit
// of other languages
interface TimerListener {
// what to put here?
};

interface AbstractView {
readonly attribute DocumentView document;
};

interface DocumentView {
readonly attribute AbstractView defaultView;
};

interface Window : views::AbstractView {
// self-references
readonly attribute Window window;
readonly attribute Window self;

// assigning this has special behavior in ECMAScript, but it is otherwise
// read only. specifically, in ES a string URI can be assigned to location,
// having the same effect as location.assign(URI)
readonly attribute Location location;

// name attribute of referencing frame/iframe/object, or name passed to
// window.open
attribute dom::DOMString name;

// global object of containing document
readonly attribute Window parent;

// global object of outermost containing document
readonly attribute Window top;

// referencing , , , ,
// or other embedding point, or null if none
readonly attribute dom::Element frameElement;

// one-shot timer
long setTimeout(in TimerListener listener, in long milliseconds);
void clearTimeout(in long timerID);

// repeating timer
long setInterval(in TimerListener listener, in long milliseconds);
void clearInterval(in long timerID);
};

interface DocumentWindow : views::DocumentView {
readonly attribute Location location;
};

interface Location {
attribute dom::DOMString href;

// pieces of the URI, per the generic URI syntax
attribute dom::DOMString hash;
attribute dom::DOMString host;
attribute dom::DOMString hostname;
attribute dom::DOMString pathname;
attribute dom::DOMString port;
attribute dom::DOMString protocol;
attribute dom::DOMString search;

void assign(in dom::DOMString url);
void replace(in dom::DOMString url);
void reload();

dom::DOMString toString();
};
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

XML基础

fixopen — Sun, 15 Oct 2006 18:16:37 +0800

作者: fixopen 链接：http://fixopen.javaeye.com/blog/27878 发表时间: 2006年10月15日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

虽说我认为上面的东西基本上不言自明，但我也意识到，很多人并不是很清楚XML的基本概念。所以，我准备把上面的东西解释一遍，只解释那些我认为确实有必要解释的东西。
一个XML文档就是一个文本文档。跟普通文本文档完全相同。只不过，它可能会比别的文本文档多了一些限制而已。一般来说，我们对于XML文档的直观认识就是：里面有大量的尖括号：）。是的，确实如此。XML文档被要求是Unicode字符集的文本文档。当然，它可能有多种编码方式（比如：utf7、utf8、utf16le、utf16ge等等），但这不是我们关注的焦点。顺便说一句，xml文档一般不需要bom字符，当然如果你加上了bom，你的xml必须没有prolog。后面我会讲到prolog是啥。
xml的基本思想就是对文本数据打上标记，用以更精确的表达这些文本数据的含义。举个例子1977/2/19 5:55:00这个文本数据，我们直觉它应该是一个timestamp，但是实际上它可能是任意东西，比如一种食品的名称：），虽然显得有些怪异。而如果我们用1977/2/19 5:55:00来表达这个数据，我们就有把握的说，这个数据是一个生日。注意：尖括号中的数据是用来说明原始数据的，它们被称作标签。前面的那个叫做前标签，后面的那个叫做后标签。tag。注意它们的特征。前后相同，后面多了一个/，都是用<>括起来的。这就是XML，也就是一种给数据打标签的方式。数据加上标签作为一个整体被称为一个元素。Element。

XML中的X表达的是可扩展性，其基本意思就是说：XML本身没有定义任何tag，你可以用你觉得舒服的任何tag对数据作标记，设想一下我们比较熟悉的HTML，会发觉其实它就是规定了tag集合的一种标记语言。

<深入>
有时候我们也会迷惑，如果没有任何预定义的tag，我们对数据进行标记岂不是成了自己逗自己玩？是啊，我自己用了一个标记，想用来表达某些含义，可是谁知道是什么含义呢？除了我自己？如果大家都不知道，我这个标记还有更大的意义么？
可以说，上面这个问题是一个本质问题。如果我们找不到XML存在的意义，我们就不值得去学习它，不是么？
我要提到的一个概念叫做XML Application。什么是XML Application？它就是：规定了一系列tag的含义的一个XML规范。我们可以而且也只能用这些被规定好的tag来标记数据了。又有人不明白了，这……这跟HTML还有区别么？我们说，现在看来暂时没有：）。不过马上我就告诉你其中的区别了。
一、HTML是一个全世界统一的标准，而我们的XML Application可以是在一个范围内有效的标准。
这提供了什么好处呢？最大的好处就是，我可以只需要试图说服一部分人而不是所有人都遵守，这样，我的这个约定就比较容易实施。
二、可以有多个约定，也就是说，可以有多个XML Application。
这个的用处大家就比较清楚了，我可以约定一套用于数学公式的标签集合，也可以约定一套用于音乐的标签集合，两者互不干扰。而HTML只有一套tag集合。却试图表达整个世界。
三、这多个XML Application可以互相混合。
哇，太好了，我真的可以描述整个世界了。可是这又会引发一个问题——这些标签冲突怎么办？
这儿，XML引入了一个namespace的概念。简单的说，不是同一个namespace中的标签，就算其名字相同，我们也知道它们是两码事，不会冲突。可是怎么保证namespace的名字不冲突呢？毕竟，我说我的标签都是dup这个namespace里面的，而这并不能阻止你让你的标签也是dup这个namespace。我们的W3C委员会非常聪明的解决了这个问题：它们规定namespace必须是一个URI，通俗的说，就是一个网址。我们知道，网址是保证全球唯一的。但是，由于网址的书写不过方便——毕竟太长了（更深层次的原因是：它们有些字符是不允许出现的），我们被允许可以起一个别名。当然，这个方案对于故意捣乱者也是无能为力……，不过，这就是另一回事情了。
备注：其实，现在已经定义了好多XML Appliction了。有很多已经被公认了，大家都在用：）。当然，这并不阻止你自己定义自己的Application。顺便说一句，定义Application需要使用Schema，有各种Schema可以用，包括DTD，XML Schema（schemaLocation），Schematron，RELAX NG等等。其中，很多都是一个具体的XML Application。哦，我要晕了。
关于名字空间，我给大家一个直观的感受，看例子：

上面的例子中，涉及到两个名字空间，http://www.music.com/schemas/music和http://www.math.com.cn/，对于这俩名字空间，我们起的别名分别是music和math，这样，我们的元素的tag就可以用namespaceName:前缀来区分了。如果我们不理会名字空间，我们完全可以把namespaceName:tagName看成一个整体。另外，强调一下，名字空间的别名是可以随便起的，只要在同一个文档中不重复就行了。

一个XML文档要求最多一个元素。不过，需要提醒大家的是，元素可以嵌套，嵌套的层次（深度）没有任何限制。我举个例子大家就会很明白了：

dup
1977/2/19 5:55:00

smalltalk
eat
play pingpang

上面就是一个元素嵌套的例子。我想大家应该觉得非常简单。形式是不重要的（比如缩进换行什么的）。只要保证正常的嵌套关系没有搞混乱就行。

元素可以直接或者间接递归。比如：x元素可以有叫做x的子元素，或者其子孙中有叫做x的元素。

顺便我把子，子孙，父，祖先这个几个概念说一下。还是上面的例子，name，birthday，description是person的子。所有的子以及子的所有的子，依次递推下去，这些元素的总和叫做子孙。也就是说，直接的子和间接的子。父相对于子。一个元素只能有一个父。比如：strongPoint的父是description。祖先是父以及其父，依次递推直至最上层元素的那个集合，比如：strongPoint的祖先是description，person。

XML文档中，除了Element以外，还有一些别的东西，我一一道来：）。

其实，上面那个嵌套的元素就已经有一些新鲜的玩艺儿了，比如：如果你仔细注意了的话，有几个（确切的说是两个）元素的前标签里面有一些我们以前没有提及的东西，我们把那东西叫属性。Attribute。Attribute的形式是：n = “v”，其中n是任意的字符串。v也是。一个元素可以有任意多个Attribute，它们的n不能重复。n被称作属性名，v被称作属性值。元素的属性一定是放在前标签里面的。

我们把前标签和后标签之间的文本称作Text。这些Text被称作元素的内容。一个元素的内容可以是Text，也可以是其它元素或者其他元素们，甚至可以是空白。当然，还可以是这些东西的组合。

如果一个Text是以结尾，那么这个Text就被称做是CDATASection，CDATA段。CDATA段一个显著的用意就是禁止被解释。也就是说，CDATA段中的内容，一律按照其原始的形式存在。甚至里面的标签什么的也不会被认为是标签了。只是普通字符而已。

注释是另一种东西，跟元素没有什么关系，它可以出现在在除了标签以外的任何地方，用来进行一个人可以理解的说明。注释的形式如下：其中...可以是任何东西，除了--。

DocumentType。文档类型，其实就是用来指定该XML文档所遵循的XML Application的Schema标准的那种东西。到现在为止，我只知道怎么使用它搞定用DTD定义的Schema，对于别的Schema，我不会使用这种方式，而是采用schemaLocation这个属性的方式来引用相关的文档类型定义。说实话，我不知道用schemaLocation这种方式引用Schema算不算文档类型。需要注意的是，如果一个XML没有引用相关的文档类型定义，也就是用于规定标签集合的Schema，那么这个文档就是普通的格式良好的。如果引用了，那么，XML文档的解释器会使用Schema规定的标签集及其结构验证该XML文档是否满足Schema的规定，故此，这时候的XML文档称作可验证的。DocumentType基本上是这样的语法：，或许还有一些别的东西，比如规定实体（Entity）和记号（Notation）的，以及规定内部子集的。但是遗憾的是：这些语法我不明白，所以就不描述它们了。深入的东西可以看看inline DTD。
我举个例子说明一个DocumentType是什么样子的：

这就是一个特别常见和特别有用的DocumentType，其实说到这儿，我似乎应该深入的描述一下publicId的语法结构，但是，巾短话多，我就不烦你了，如果你有兴趣，参见W3C的规范。

Notation就是记号。这个东西说起来也很绕，原因是：我没有搞明白。所以略而不说。不过，可以告诉大家，在XML文档中碰到这个东西的时候非常好，而且就算碰到你也不会有感觉。所以不说也没有什么问题。
<高级>
记号是一个比较高级的主题，涉及到关于不可解析实体的处理问题。由于XML文档是一个纯文本文档，其中需要用tag作一些标记，用来规定数据的一些意义。这样，XML文档只能用来描述那些文本性质的数据。这些数据被称作可解析数据。也就是说，它们能够被XML解释器解析。但是，我们能用XML描述非文本性质的数据么？比如：二进制的数据，更具体的说，比如一个图片，一段音频什么的？我们说：我们的愿望是无穷的，不能这样就屈服了。我们就是要用XML描述二进制文件！可是我们XML的铁律就是不想让它去处理二进制数据啊。这时候，我们就需要Notation了，其实，Notation只是一个名字，一个记号，一个媒体类型，一个指示XML解析器用什么解释器来解释这种媒体。比如：我们定义了一种叫做PNG的Notation，我们就可以这样使用它了，首先，我们要在Schema中定义元素的某个属性，比如：image元素的src属性，然后，我们在XML文档中这样使用了，这样

，看看，我们能够描述二进制数据了吧。
在这个过程中，我们的XML解释器就很清楚的知道，image的src属性是一个PNG，它需要用PNG的解释器来帮助它解释这个数据。
也就是说，Notation这样的设施就给了XML部分的表达二进制数据的方式，这种数据从本质上讲是XML解析器不可解析的数据。前面的CDATASection就是一种XML解析器不会去解析的数据，是文本形式的。后面还会讲到的ProcessingInstruction也是一种描述不可解析的数据的手段，也是文本形式的。

Entity，实体。最常见的也是必须的几个实体定义是：lt，gt，amp，quot，apos，分别表示<，>，&，"，'，它们本身是标签和属性需要使用的元字符，所以必须用实体引用来引用它们。

EntityReference就是那种&name;的那种东西，name是实体的名字，实体引用会被在引用处替换为实体本身。

ProcessingInstruction，处理指令。其基本语法如下：target是一个外部程序，content是一个字符串，这个字符串是将会被交给target这个外部程序去解释和处理的。我举个例子来说明：，这就是一个处理指令，content可以任意复杂，都会交给target取处理。另一个用法是：它是一种类似于HTML Link的东西，表示引用trans.xsl这个样式单。这种PI的content的组成方式跟Element前标签的Attributes很像，我们一般称它们为伪属性。

一个比较奇特的符合处理指令语法的但是不是处理指令的东西是：它跟上面的那个xml-stylesheet PI很像，但用途市绝对不一样的。这个语法要素要么不出现，要么只出现一次，而且必须出现在开头，绝对的开头，它前面不能有任何空白字符。它在某种程度上完成了BOM的作用。

上面所有的东西都被称为节点。所有的这些节点组合以来就是XML文档。Document。

PS：XML规范中对于字符的处理是非常复杂的，但是，我没有描述这些东西，因为，这些东西不太重要（对于普通用户来说），而且，XML规范中对于字符的处理也有点太复杂了。达到了夸张的地步。

好了，这就是XML文档，其实是非常简单的。但是，这个我们上一篇文章中给出的XML Core DOM有什么关系呢？

XML文档是一个普通的文本字节流，而XML Core DOM是一个XML文档解析器根据这个XML文档构造的一颗树，一棵结点组成的树，其根就是称作Document的东西。ok，这就是XML基础的全部。我们可以通过XML Core DOM提供的接口，遍历这一棵树，访问和修改各个节点，凭空生成和插入新的节点，删除某些节点。处理各种用户自定义的数据等等。现在，你能够看明白上一篇文章的那些接口及其含义了么？
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

JavaScript in Browser

fixopen — Sun, 15 Oct 2006 18:10:00 +0800

作者: fixopen 链接：http://fixopen.javaeye.com/blog/27877 发表时间: 2006年10月15日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

介绍host概念
与普通的语言不同的是，JavaScript一开始就被设计为一个嵌入式的语言。这意味着，它是寄生在某个环境中而不是自足的。当然，这也意味着其运行环境的边境就是JavaScript的能力边境。JavaScript所寄居的那个运行环境叫做JavaScript的Host。JavaScript跟Host环境之间可以进行非常方便的交流和沟通，并且，以其寄宿的Host作为自己的世界。JavaScript的Host多种多样，包括Browser，Web Server，Flash player，Photoshop，……以及所有支持以JavaScript为其接口脚本语言的各种环境。这儿，我们的重点就是Brower。

window就是Global
我们知道，JavaScript语言规范本身定义了一系列的对象。这些对象被称作built-in对象，它要求JavaScript无论在任何Host中都拥有，或者说Built-in对象就是一个约定。也就是说，JavaScript期望这些built-in对象在任何Host中都是一致的。当然， Host可以增添一些对象，或者修改一些对象的property，毕竟，我们知道修改JavaScript对象是很方便的。在Browser这个 JavaScript最流行的Host里面，增加了很多Host定义的对象，这些对象全是被一个标准体系规定的，这个体系叫做DOM。下面我会详细的介绍 DOM标准的。不过需要明确指出的是：Browser对于DOM标准总是半遮半掩，也就是说：它们实现了部分的DOM标准，同时又扩展了部分DOM没有规定的东西。
无论如何，我们首先需要明确的是：window就是Global。Global是JavaScript的内建对象，window是 Brower提供的Global对象，不过，名字叫window。实现基本上类似于var window = Global; window.newProperty = content; window.oldProperty = updateContent;……。window也像Global一样，可以省略"window."来直接引用其属性。

附加的对象有哪些？
Brower 向JavaScript中附加的对象是非常多的。而且对于不同的Browser，其附加的对象也各不相同。不过大致都会有window（作为Global 存在，提供一些基本的实用功能），document（作为Brower中展现的文档的入口存在），styleSheet（作为样式单操作入口）， event（作为事件），xmlHttpRequest（作为异步http通信通道）等等。后面我们自然要一一深究这些对象，不过现在我们可以暂且放过它们。

DOM是什么
DOM是Document Object Model的缩写，它是一个标准族。它规定了Browser相关的对象扩展应该有哪些properties，它们各是什么意义和作用等等。由于DOM是一个独立标准，并不依赖于JavaScript（也就是说，它规定了Browser应该提供的对象以及接口，可是这些对象是用JavaScript引用还是用C++引用它并没有规定），所以它是用了语言独立的IDL来描述这些对象的外貌和功用。关于DOM跟JavaScript的关联，他们把它叫做 binding。
再一次明确一下，DOM是一个标准族，它描述了Browser应该提供的对象的接口。

DOM标准族包括哪些？
DOM 标准族包括XML DOM，HTML DOM，CSS DOM……，其中每一个都有可能是好几个相关的部分组成的。其中最为主要的标准系列就是XMLDOM了。我准备把它们的规范用IDL描述出来，在我认为必要的地方加上简短的说明。关于IDL，其实完全是不言自明的，所以我就不介绍IDL的语法了。

注意：我描述的DOM规范，比较新，有很多特性还没有被Browser支持，而且有些可能还会改动，但改动的幅度不会很大。但是我宁愿描述一个新的合理的规范，也不愿意描述一个老的不完全的规范。

现在开始XML DOM的描述，这是整个DOM标准的核心和基础。DOM标准的基本思想是把一个用标签（tag）标记（mark）的文本文档看作一棵树，文本文档中的任何一段文本都属于这个树的某个节点，每个节点都有一个唯一的父结点，都有若干子节点和属性。
下面是XML DOM的core部分，基础中的基础。

valuetype DOMString sequence
typedef unsigned long long DOMTimeStamp;
typedef any DOMUserData;
typedef Object DOMObject;

interface DOMImplementation;
interface DocumentType;
interface Document;
interface NodeList;
interface NamedNodeMap;
interface UserDataHandler;
interface Element;
interface TypeInfo;

interface DOMLocator;

exception DOMException
{
unsigned short code;
};
// ExceptionCode
const unsigned short INDEX_SIZE_ERR = 1;
const unsigned short DOMSTRING_SIZE_ERR = 2;
const unsigned short HIERARCHY_REQUEST_ERR = 3;
const unsigned short WRONG_DOCUMENT_ERR = 4;
const unsigned short INVALID_CHARACTER_ERR = 5;
const unsigned short NO_DATA_ALLOWED_ERR = 6;
const unsigned short NO_MODIFICATION_ALLOWED_ERR = 7;
const unsigned short NOT_FOUND_ERR = 8;
const unsigned short NOT_SUPPORTED_ERR = 9;
const unsigned short INUSE_ATTRIBUTE_ERR = 10;
const unsigned short INVALID_STATE_ERR = 11;
const unsigned short SYNTAX_ERR = 12;
const unsigned short INVALID_MODIFICATION_ERR = 13;
const unsigned short NAMESPACE_ERR = 14;
const unsigned short INVALID_ACCESS_ERR = 15;
const unsigned short VALIDATION_ERR = 16;
const unsigned short TYPE_MISMATCH_ERR = 17;

interface DOMStringList
{
DOMString item(in unsigned long index);
readonly attribute unsigned long length;
boolean contains(in DOMString str);
};

interface NameList
{
DOMString getName(in unsigned long index);
DOMString getNamespaceURI(in unsigned long index);
readonly attribute unsigned long length;
boolean contains(in DOMString str);
boolean containsNS(in DOMString namespaceURI, in DOMString name);
};

interface DOMImplementationList
{
DOMImplementation item(in unsigned long index);
readonly attribute unsigned long length;
};

interface DOMImplementationSource
{
DOMImplementation getDOMImplementation(in DOMString features);
DOMImplementationList getDOMImplementationList(in DOMString features);
};

interface DOMImplementation
{
boolean hasFeature(in DOMString feature, in DOMString version);
DocumentType createDocumentType(in DOMString qualifiedName, in DOMString publicId, in DOMString systemId) raises(DOMException);
Document createDocument(in DOMString namespaceURI, in DOMString qualifiedName, in DocumentType doctype) raises(DOMException);
DOMObject getFeature(in DOMString feature, in DOMString version);
};

interface Node
{
// NodeType
const unsigned short ELEMENT_NODE = 1;
const unsigned short ATTRIBUTE_NODE = 2;
const unsigned short TEXT_NODE = 3;
const unsigned short CDATA_SECTION_NODE = 4;
const unsigned short ENTITY_REFERENCE_NODE = 5;
const unsigned short ENTITY_NODE = 6;
const unsigned short PROCESSING_INSTRUCTION_NODE = 7;
const unsigned short COMMENT_NODE = 8;
const unsigned short DOCUMENT_NODE = 9;
const unsigned short DOCUMENT_TYPE_NODE = 10;
const unsigned short DOCUMENT_FRAGMENT_NODE = 11;
const unsigned short NOTATION_NODE = 12;

readonly attribute DOMString nodeName;
attribute DOMString nodeValue;
// raises(DOMException) on setting
// raises(DOMException) on retrieval

readonly attribute unsigned short nodeType;
readonly attribute Node parentNode;
readonly attribute NodeList childNodes;
readonly attribute Node firstChild;
readonly attribute Node lastChild;
readonly attribute Node previousSibling;
readonly attribute Node nextSibling;
readonly attribute NamedNodeMap attributes;
readonly attribute Document ownerDocument;
Node insertBefore(in Node newChild, in Node refChild) raises(DOMException);
Node replaceChild(in Node newChild, in Node oldChild) raises(DOMException);
Node removeChild(in Node oldChild) raises(DOMException);
Node appendChild(in Node newChild) raises(DOMException);
boolean hasChildNodes();
Node cloneNode(in boolean deep);
void normalize();
boolean isSupported(in DOMString feature, in DOMString version);
readonly attribute DOMString namespaceURI;
attribute DOMString prefix;
// raises(DOMException) on setting
readonly attribute DOMString localName;
boolean hasAttributes();
readonly attribute DOMString baseURI;

// DocumentPosition
const unsigned short DOCUMENT_POSITION_DISCONNECTED = 0x01;
const unsigned short DOCUMENT_POSITION_PRECEDING = 0x02;
const unsigned short DOCUMENT_POSITION_FOLLOWING = 0x04;
const unsigned short DOCUMENT_POSITION_CONTAINS = 0x08;
const unsigned short DOCUMENT_POSITION_CONTAINED_BY = 0x10;
const unsigned short DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 0x20;

unsigned short compareDocumentPosition(in Node other) raises(DOMException);
attribute DOMString textContent;
// raises(DOMException) on setting
// raises(DOMException) on retrieval
boolean isSameNode(in Node other);
DOMString lookupPrefix(in DOMString namespaceURI);
boolean isDefaultNamespace(in DOMString namespaceURI);
DOMString lookupNamespaceURI(in DOMString prefix);
boolean isEqualNode(in Node arg);
DOMObject getFeature(in DOMString feature, in DOMString version);
DOMUserData setUserData(in DOMString key, in DOMUserData data, in UserDataHandler handler);
DOMUserData getUserData(in DOMString key);
};

interface NodeList
{
Node item(in unsigned long index);
readonly attribute unsigned long length;
};

interface NamedNodeMap
{
Node getNamedItem(in DOMString name);
Node setNamedItem(in Node arg) raises(DOMException);
Node removeNamedItem(in DOMString name) raises(DOMException);
Node item(in unsigned long index);
readonly attribute unsigned long length;
Node getNamedItemNS(in DOMString namespaceURI, in DOMString localName) raises(DOMException);
Node setNamedItemNS(in Node arg) raises(DOMException);
Node removeNamedItemNS(in DOMString namespaceURI, in DOMString localName) raises(DOMException);
};

interface CharacterData : Node
{
attribute DOMString data;
// raises(DOMException) on setting
// raises(DOMException) on retrieval

readonly attribute unsigned long length;
DOMString substringData(in unsigned long offset, in unsigned long count) raises(DOMException);
void appendData(in DOMString arg) raises(DOMException);
void insertData(in unsigned long offset, in DOMString arg) raises(DOMException);
void deleteData(in unsigned long offset, in unsigned long count) raises(DOMException);
void replaceData(in unsigned long offset, in unsigned long count, in DOMString arg) raises(DOMException);
};

interface Attr : Node
{
readonly attribute DOMString name;
readonly attribute boolean specified;
attribute DOMString value;
// raises(DOMException) on setting
readonly attribute Element ownerElement;
readonly attribute TypeInfo schemaTypeInfo;
readonly attribute boolean isId;
};

interface Element : Node
{
readonly attribute DOMString tagName;
DOMString getAttribute(in DOMString name);
void setAttribute(in DOMString name, in DOMString value) raises(DOMException);
void removeAttribute(in DOMString name) raises(DOMException);
Attr getAttributeNode(in DOMString name);
Attr setAttributeNode(in Attr newAttr) raises(DOMException);
Attr removeAttributeNode(in Attr oldAttr) raises(DOMException);
NodeList getElementsByTagName(in DOMString name);
DOMString getAttributeNS(in DOMString namespaceURI, in DOMString localName) raises(DOMException);
void setAttributeNS(in DOMString namespaceURI, in DOMString qualifiedName, in DOMString value) raises(DOMException);
void removeAttributeNS(in DOMString namespaceURI, in DOMString localName) raises(DOMException);
Attr getAttributeNodeNS(in DOMString namespaceURI, in DOMString localName) raises(DOMException);
Attr setAttributeNodeNS(in Attr newAttr) raises(DOMException);
NodeList getElementsByTagNameNS(in DOMString namespaceURI, in DOMString localName) raises(DOMException);
boolean hasAttribute(in DOMString name);
boolean hasAttributeNS(in DOMString namespaceURI, in DOMString localName) raises(DOMException);
readonly attribute TypeInfo schemaTypeInfo;
void setIdAttribute(in DOMString name, in boolean isId) raises(DOMException);
void setIdAttributeNS(in DOMString namespaceURI, in DOMString localName, in boolean isId) raises(DOMException);
void setIdAttributeNode(in Attr idAttr, in boolean isId) raises(DOMException);
};

interface Text : CharacterData
{
Text splitText(in unsigned long offset) raises(DOMException);
readonly attribute boolean isElementContentWhitespace;
readonly attribute DOMString wholeText;
Text replaceWholeText(in DOMString content) raises(DOMException);
};

interface Comment : CharacterData
{
};

interface TypeInfo
{
readonly attribute DOMString typeName;
readonly attribute DOMString typeNamespace;

// DerivationMethods
const unsigned long DERIVATION_RESTRICTION = 0x00000001;
const unsigned long DERIVATION_EXTENSION = 0x00000002;
const unsigned long DERIVATION_UNION = 0x00000004;
const unsigned long DERIVATION_LIST = 0x00000008;

boolean isDerivedFrom(in DOMString typeNamespaceArg, in DOMString typeNameArg, in unsigned long derivationMethod);
};

interface UserDataHandler
{
// OperationType
const unsigned short NODE_CLONED = 1;
const unsigned short NODE_IMPORTED = 2;
const unsigned short NODE_DELETED = 3;
const unsigned short NODE_RENAMED = 4;
const unsigned short NODE_ADOPTED = 5;

void handle(in unsigned short operation, in DOMString key, in DOMUserData data, in Node src, in Node dst);
};

interface DOMError
{
// ErrorSeverity
const unsigned short SEVERITY_WARNING = 1;
const unsigned short SEVERITY_ERROR = 2;
const unsigned short SEVERITY_FATAL_ERROR = 3;

readonly attribute unsigned short severity;
readonly attribute DOMString message;
readonly attribute DOMString type;
readonly attribute DOMObject relatedException;
readonly attribute DOMObject relatedData;
readonly attribute DOMLocator location;
};

interface DOMErrorHandler
{
boolean handleError(in DOMError error);
};

interface DOMLocator
{
readonly attribute long lineNumber;
readonly attribute long columnNumber;
readonly attribute long byteOffset;
readonly attribute long utf16Offset;
readonly attribute Node relatedNode;
readonly attribute DOMString uri;
};

interface DOMConfiguration
{
void setParameter(in DOMString name, in DOMUserData value) raises(DOMException);
DOMUserData getParameter(in DOMString name) raises(DOMException);
boolean canSetParameter(in DOMString name, in DOMUserData value);
readonly attribute DOMStringList parameterNames;
};

interface CDATASection : Text
{
};

interface DocumentType : Node
{
readonly attribute DOMString name;
readonly attribute NamedNodeMap entities;
readonly attribute NamedNodeMap notations;
readonly attribute DOMString publicId;
readonly attribute DOMString systemId;
readonly attribute DOMString internalSubset;
};

interface Notation : Node
{
readonly attribute DOMString publicId;
readonly attribute DOMString systemId;
};

interface Entity : Node
{
readonly attribute DOMString publicId;
readonly attribute DOMString systemId;
readonly attribute DOMString notationName;
readonly attribute DOMString inputEncoding;
readonly attribute DOMString xmlEncoding;
readonly attribute DOMString xmlVersion;
};

interface EntityReference : Node
{
};

interface ProcessingInstruction : Node
{
readonly attribute DOMString target;
attribute DOMString data;
// raises(DOMException) on setting
};

interface DocumentFragment : Node
{
};

interface Document : Node
{
readonly attribute DocumentType doctype;
readonly attribute DOMImplementation implementation;
readonly attribute Element documentElement;
Element createElement(in DOMString tagName) raises(DOMException);
DocumentFragment createDocumentFragment();
Text createTextNode(in DOMString data);
Comment createComment(in DOMString data);
CDATASection createCDATASection(in DOMString data) raises(DOMException);
ProcessingInstruction createProcessingInstruction(in DOMString target, in DOMString data) raises(DOMException);
Attr createAttribute(in DOMString name) raises(DOMException);
EntityReference createEntityReference(in DOMString name) raises(DOMException);
NodeList getElementsByTagName(in DOMString tagname);
Node importNode(in Node importedNode, in boolean deep) raises(DOMException);
Element createElementNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
Attr createAttributeNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
NodeList getElementsByTagNameNS(in DOMString namespaceURI, in DOMString localName);
Element getElementById(in DOMString elementId);
readonly attribute DOMString inputEncoding;
readonly attribute DOMString xmlEncoding;
attribute boolean xmlStandalone;
// raises(DOMException) on setting
attribute DOMString xmlVersion;
// raises(DOMException) on setting
attribute boolean strictErrorChecking;
attribute DOMString documentURI;
Node adoptNode(in Node source) raises(DOMException);
readonly attribute DOMConfiguration domConfig;
void normalizeDocument();
Node renameNode(in Node n, in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
};

上面说了，这是标准中的基础部分，而且，也是标准中最重要的部分，实际上，如果你知道了这些接口（再加上这些标准接口跟JavaScript在Browser这个Host中的对象的binging），你就可以进行几乎所有的Browser端编程了。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐