BeginningXML

Tips:
1.二进制文件：一个比特流（0，1序列）,只有创建这个二进制文档的应用程序可以理解这些二进制的具体含义，如果不是这个特定应用打开，则可能看到乱码。在这个二进制文档中还含有元数据及信息的信息。二进制格式优点：内容简洁，并可被压缩保存到一个相对较小的空间，这样也有利于在网络上传输它们，因为它们所占的带宽内容更小。
2。文本文件：文本文件人机均可读，不需要一个专门的应用程序去读取它，文本文件中每一组比特流均表示一个已知字符集中的一个字符，所以许多不同应用程序都能读取文本文件。优点：人机均可读，且比二进制文件更容易被解析。缺点：文件较大，不可保存元数据的文件格式。
3.标记语言：既方便人类阅读，又能被各种应用程序解析，还可以保存元数据的文件格式。
4.SGML:标准通用标记语言。standard generalized markup language.
5.因为SGML太复杂，所以人们开发了他的子集XML ：eXtensible Markup Language可扩展标记语言
6.几乎所有xml文件都由两种内容组成，元素与属性。
7.浏览器通过xml样式表文件或xml样式转换插件来处理xml文件
8.xml目标之一将数据与显示完全分离开来，不像html一样有内嵌的数据显示方式。
9.使用CDATA来是我们可以直接使用“>”“<”等符号而不需要使用“&gt”“&lt”等符号表示，如：
<![CDATA[ 1 kilometer <1 mile 1 pint<1 liter ]]>
10.声明名称空间的方法
@1.让文档中所有元素的隶属于这个名称空间
@2。让文档中部分元素属于这个名称空间。
forxeample：
无名称空间的xml：




默认命名空间：“”与他的所有子元素都属于这一命名空间,但其中的属性并不属于这一命名空间。默认命名空间只能作用于元素，属性的命名空间需要显示的声明。xml文档中其他组件（如：注释）也不属于任何名称空间。




为命名空间取名后：




现在我们使用我们所去的名
<hr:animal xmlns:hr=“http://www.baidu.com/confg”>


</hr:animal>
当然属性也可以：
<hr:animal xmlns:hr=“http://www.baidu.com/confg”>
<hr:cat hr:name=”kimi”/>
<hr:dog hr:name=“yuri”/>
</hr:animal>
命名空间声明的位置不能晚于第一个使用它的元素。当一个元素声明了一个命名空间后，他自己和他的子元素与他的属性都属于这一命名空间了，但我们也可以通过显示声明他的子元素的命名空间的方法来改变他的子元素的命名空间。
声明多个名称空间：

<hr:cat hr:name=”kimi”/>
<hr:dog hr:name=“yuri”/>


我们可以看出这一“animal”与pig用默认的命名空间，而cat，dog使用命名空间“hr”。实际开发中把使用最频繁的命名空间作为默认命名空间。
你也可以：
<en:animal
xmlns:en=“http://www.goole.com/en”
xmlns:hr=“http://www.baidu.com/confg”>
<hr:cat hr:name=”kimi”/>
<hr:dog hr:name=“yuri”/>
<en:pig name=“jiki”/>

当然如果你愿意你也可以为同一命名空间取不同名字来声明，但不可为同一取名指定不同命名空间
<en:animal
xmlns:en=“http://www.baidu.com/confg”
xmlns:hr=“http://www.baidu.com/confg”>
<hr:cat hr:name=”kimi”/>
<hr:dog hr:name=“yuri”/>
<en:pig name=“jiki”/>

请百度URL,URI,URN区别，
请百度如何前缀名和URI映射的关系，修改默认命名空间，取消声明以移除命名空间的作用域。

验证
1.文档类型定义（DTD）
1.什么是文档类型：将词汇（元素与属性）与结构放在一起。
2。解析器是一个软件的子系统，他将xml文档包含的信息读入到我们的程序中。解析器分为：验证类，与非验证类。
3.DTD与文档进行关联：内部关联与外部关联。
4.一个DTD example:

<?xml version="1.0"?>

<!ELEMENT first (#PCDATA)>
<!ELEMENT middle (#PCDATA)>
<!ELEMENT last (#PCDATA)>
]>

kimi hihi bibo 以上是通过jedit的DTD解析器插件来检查的，该解析器内置了验证功能，可以按不同方式验证xml文档，最基本的方法是：解析器读取DTD声明语句，并将它们保存在内存中，然后读取文档内容，把每个元素与DTD文件里的声明进行比较，如果发现每个元素或属性在声明中没有出现或位置不对，或者一个声明没有xml内容与之对应，就会产生一个验证错误。

//because use”check” will cost more time enough if it is a lilies XMLdocument ,so if we are sure of our document correct ,we ‘d better do not use “check”.

//XML is case sensitive .you should differe upcase and lowercase
//internal subset declaration:

<?xml version="1.0"?>

<!ELEMENT first (#PCDATA)>
<!ELEMENT middle (#PCDATA)>
<!ELEMENT last (#PCDATA)>
]>

kimi hihi bibo //enternal subset declaration: 1.”SYSTEM identifier” The uri can be “a file on the disk””a file in the local net””a file in the internal net””a file in the internet”, The internal subset declaration can use use with the internal subset declaration ,use “[]”refer to internal subset declaration You can write something in the “[]”refer to the internal subset declaration 2.”PUBLIC identifier ”: You can use it with “SYSTEM identifier”:when “SYSTEM ”write with”PUBLIC”,the word”SYSTEM” can not need to be write So we can see if you want to use “DTD”you can use the “internal subset declaration ””external subset declaration (SYSTEM|PUBLIC )”together ,or one of them ,or two of them by what you like: Fro example: At first create a”name.dtd”: <!ELEMENT name (first,middle,last)> <!ELEMENT first (#PCDATA)> <!ELEMENT middle (#PCDATA)> <!ELEMENT last (#PCDATA)> Then we create a “name.xml” <?xml version="1.0"?> kimi hihi bibo

//DTD 由三个基本部分组成：元素声明，属性声明，实体声明

元素声明：由ELEMENT声明，元素名，元素内容模型组成
//ELEMENT声明告诉解析器当前声明一个元素，元素内容模型可以为：元素内容：元素由子元素组成；混合内容：只要含有文本就是混合内容，空内容，任意内容。
元素内容：<!ELEMENT name (first,last)>
元素内容顺序组合：如果在xml文档里少了顺序组合中的某个元素或多了某元素，或顺序与声明的顺序不同，解析器都会报错。
元素内容选择组合：<!ELEMENT location (address|gps)>从address或GPS中选择且只能选择一个。
顺序组合和选择组合的组合：

<!ELEMENT location (address|(latitude, longitude）)>

//混合组合：
PCDATA：parsed character data:被解析的字符串，这个关键字表示文档模型中的字符数据需要解析。
混合内容模型中声明元素时，规则：#PCDATA关键字必须在元素列表开头，不能内嵌内容，如果有子元素，则基数指示符必须出现在模型结尾。
many animalcat
doglovehaha

<!ELEMENT animal (#PCDATA|em|strong|br)*>

“*”指这个选择我们将进行无数次匹配，在这里我们不需要在意元素顺序与元素个数，可以有无限个等

//空内容：只有在我们完全确定这个元素不会有内容是才可用如
，而例如或我们不知其中是否会有内容所以我们不能对其使用空内容

<!ELEMENT br EMPTY>

//任意内容：元素中可以是任意以声明的元素或内容

<!ELEMENT animal ANY>

//example(contact):
//below are “contact.xml”

<?xml version="1.0"?> Jeft Cragic Raffer 34.031548 -112.234567 000754433 KIMI,LUCY Jeft is the author fat
veryfat

//below are “contacts.dtd”:(the ELEMENT in the dtd do not need by order):

<!ELEMENT contacts (contact)> <!ELEMENT contact (name,location,phone,knows,description)> <!ELEMENT name (first,middle,last)> <!ELEMENT first (#PCDATA)> <!ELEMENT middle (#PCDATA)> <!ELEMENT last (#PCDATA)> <!ELEMENT location (address|(latitude,longitude))> <!ELEMENT address (#PCDATA)> <!ELEMENT latitude (#PCDATA)> <!ELEMENT longitude (#PCDATA)> <!ELEMENT phone (#PCDATA)> <!ELEMENT knows (#PCDATA)> <!ELEMENT description (#PCDATA|em|strong|br)*> <!ELEMENT em (#PCDATA)> <!ELEMENT strong (#PCDATA)> <!ELEMENT br EMPTY> Jeft Cragic Raffer 34.031548 -112.234567 000754433 KIMI,LUCY Jeft is the author fat
very fat

基数：
//一个元素的基数是指这个元素在一个内容模型中出现的次数：
1.无基数指示符：该元素必须出现且仅出现一次
2。“？”：该元素出现一次或零次
3。”+“：该元素出现一次或多次；
4.”*“：该元素出现0次或多次
Eg.<!ELEMENT name (first+,middle?,last)>
这样解析器就会按照以上要求检查，如有多个first ，没有middle 等也不会报错。注意元素还是要按顺序排列的。
如果我们定义如下<!ELEMENT contacts (contact*)>则可以存储更多的人。
//我们改进原code

<!ELEMENT contacts (contact*)> <!ELEMENT contact (name,location,phone,knows,description)> <!ELEMENT name (first+,middle？,last)> <!ELEMENT first (#PCDATA)> <!ELEMENT middle (#PCDATA)> <!ELEMENT last (#PCDATA)> <!ELEMENT location (address|(latitude,longitude)*)> <!ELEMENT address (#PCDATA)> <!ELEMENT latitude (#PCDATA)> <!ELEMENT longitude (#PCDATA)> <!ELEMENT phone (#PCDATA)> <!ELEMENT knows (#PCDATA)> <!ELEMENT description (#PCDATA|em|strong|br)*> <!ELEMENT em (#PCDATA)> <!ELEMENT strong (#PCDATA)> <!ELEMENT br EMPTY>

//属性声明（详细百度）
//在xml中取名时不能有空格
//记住ID类型的属性值必须唯一，不同元素的ID属性值必须不同。
Forexample：
//below code “contact.xml
?xml version=“1.0”?>

Jeft Cragic Raffer 34.031548 -112.234567 000754433 > Jeft is the author fat
veryfat Jeft Cragic Raffer 34.031548 -112.234567 000754433 > Jeft is the author fat
veryfat Jeft Cragic Raffer 34.031548 -112.234567 000754433 > Jeft is the author fat
veryfat

//contacts.dtd

<!ELEMENT contacts (contact)> <!ATTLIST contacts version CDATA #FIXED "1.0"> <!ATTLIST contacts source CDATA #IMPLIED> <!ELEMENT contact (name,location,phone,knows,description)> <!ELEMENT name (first,middle,last)> <!ATTLIST contact person ID #REQUIRED> <!ATTLIST contact tags NATOKENS #IMPLIED> <!ELEMENT first (#PCDATA)> <!ELEMENT middle (#PCDATA)> <!ELEMENT last (#PCDATA)> <!ELEMENT location (address|(latitude,longitude))> <!ELEMENT address (#PCDATA)> <!ELEMENT latitude (#PCDATA)> <!ELEMENT longitude (#PCDATA)> <!ELEMENT phone (#PCDATA)> <!ATTLIST phone kind (home|work|cell|fax) "home"> <!ELEMENT knows EMPTY> <!ATTLIST knows contacts IDREFS #IMPLIED> <!ELEMENT description (#PCDATA|em|strong|br)*> <!ELEMENT em (#PCDATA)> <!ELEMENT strong (#PCDATA)> <!ELEMENT br EMPTY>

//the details about “ENEITY” please use Baidu.com

XML Schema
//模式是指任何类型的模型文档，他定义一个对象（这里指xml文档）的结构，本书一直以“词汇”指代模式。
//DTD一个明显优点是：DTD是xml推荐标准里唯一的定义与验证方法，这是DTD可以直接嵌入xml文档，而其他所有语法都需要单独的文件。
//一个xml文档引用一个xml schema文档，后者定义一个词汇，遵循某个特定的xml schema 词汇的xml文档称为该XML schema文档的实例文档。

<?xml version="1.0"?>

>

targetNamespce:表示我们正为名称空间http://www.example.com/name 定义一个词汇。
:表示一个顺序组合，xml实例文档中该组合中元素顺序不可改变

<?xml version="1.0"?>

john
kiji
Doe

这里的默认名称空间与XMLschema的targetNamespace相匹配，名称空间“xsi”的许多属性我们都可以应用到实例文档中，Schemalocation属性告诉模式检验器哪里去找用于验证的XMLschema文档，该属性属于“xsi”。
创建局部类型：







>


或者








//创建全局类型：（任何作为的直接子元素的元素都可作为全局类型，全局类型一定是有限类elementformdefault=“qualified”）

<?xml version="1.0"?>

>

或者： <?xml version="1.0"?>

</xs:element>
</xs:Schema>

全局元素：

<?xml version="1.0"?>

>

模式验证器处理实例文件过程：首先解析根元素，遇到元素在xmlschema中查找的声明，此时他只搜索全局元素，在模式验证器找到匹配的声明后，就去寻找关联的类型声明（此处为nametype的全局定义），根据关联类型定义的内容模式验证元素的内容，当模式验证器遇到引用声明后，他把全局的声明导入定义，把他们肯成他的直接孩子。
//基数：在xmlsvhema中通过声明minOccurs和maxOccurs,改变元素的基数，即出现次数，且若不显示声明基数，默认minoccurs与maxoccurs均为“1”，而当父类元素声明基数后其子类默认也是该基数，当然子类也可以通过声明拥有自己的基数。注意：全局元素不允许定义基数，但可以在内容模型引用元素时使用这个属性。maxOccurs=“unbounded”表示无穷多次。
//当一个元素由fixed时其文本内容只能插入fixed的定义的值，如果一个元素出普通文本外还有其他元素，则不能使用fixed。此时若不显示定义文本值，解析器会自动插入固定值。

则1.0或或均正确，
2.0错误。
//元素通配符请百度。
//局部不需要名字，全局需要名字。
// :要求一定要符合顺序：






>

//几个选择里选择一个或几个：



<element name="string"type=“string”/>>

//也可以声明一个空内容模型：

 <element name="knows">
<complexType/>
</element>

//此时他的实例内容可为：
或

//声明：

<?xml version="1.0"?>

<element name=“name” type="target:NameType”/>

//声明：
表示模型中的元素可以按任何顺序出现：
注意：声明必须时中唯一内容模型声明，只包含声明作为他的子声明，的子声明每个只能在文档中出现一次或不出现即minoccurs与maxoccurs只能是“0或1”，具体依具体的minoccurs与maxoccurs设定决定。常用于内容已知但顺序不确定的情况。

//below is example:
//the element “contacts” must be defined as global element, because it is a root element.
When the “schemacheckingprocessor”meet the “contacts”it will arrcording to the “psi:schemaLocation”’s attribute to find the xml schema document, and finding and checking .
//“complexType”:is used to defined a type including “attribute” and “element”
“simpleType”:is used to defined the content only has “text”.
//“attribute ”when is use it do not need follow the define order
//below code are “contacts.xsd”

<?xml version="1.0"?>

>

//below code are ”contacts.xml” <?xml version="1.0"?> Jeft Cragic Raffer 34.031548 -112.234567 000754433 > Jeft is the author fat
veryfat

//more details:eg.”comment””annotation””import””include””use other namespace as comment” you can use “Baidu.com” to know more.

RELAX NG
//for example:
//below code in “name.xml”

<?xml version="1.0"?>

<name title="Mr.">
	<first>ji</first>
	<middle>hi</middle>
	<last>ft</last>
</name>

//below code in “name.rnc”
element name{
attirbute title {text},
element first {text},
element middle {text},
element last {text}
}

//another example:
//below code in “contacts.xml”:

<?xml version="1.0"?>

Jeft
Cragic
Raffer


34.031548
-112.234567

000754433
>
Jeft is the author fat
veryfat

//below code in”contacts.rnc”:
//the first edition
element contacts{
attribute version {“1.0”},
attribute source {text}?,
element contact {
attribute person {text},
attribute tags {text}?,
element name {
attribute title {"Mr.|“Mrs.”|“Ms.”|“Sir”}?,
element first {text}+,
element middle {text}?,
element last {text}
},
element location {
(element address {text}|(element latitude {text},element longitude {text}))*
},
element phone {
attribute kind {“Home”|“Work”|“Cell”|“Fax”}?,text
},
element knows {
attribute contacts {text},
empty
}
element description {
mixed {
element em {text}|element strong {text}|element br {empty}
}*
}
}*
}
//now we improved the code in”contacts.rnc”
namespace xhtml=“http://www.w3.org/1999/xhtml”
start = contacts

version =attribute version {xsd:decimal}
source = attribute source {text}
title = attribute title {text}
contacts =element contacts {
version,
source?,
title?,
contact*
}

contact = element contact {contactContents}
contactContents={
person?,
tags?,
name,
location,
phone,
knows,
description
}

person = attribute person {xsd:ID}
tags = attribute tags {xsd:token}
name = grammar {
start =name
name = element name {nameContents}
nameContents={
title?,
first+,
middle?,
last
}
titles = (“Mr.”|“Mrs.”|“Sir”|“Ms”)
title = attribute title {titles}
first =element {text}
middle =element {text}
last =element {text}
}

location = element location {locationContents*}
locationContents =(
address|(latitude,longitude)
)

address = element address {text}
unknownString =xsd:string {pattern=“Unknown”}
unknownStringOrFloat =(xsd:float |unknownString)
latitude = element latitude {unknownStringOrFloat}
longitude =element longitude {unknownStringOrFloat}

phone =element phone {phoneContents}
phoneContents ={
kind?,
PhonePattern
}
PhonePattern=(UsPhonePattern|IntlPhonePattern)
UsPhonePattern = xsd:string{
pattern="(\d{3}-\d{3}-\d{3}-\d{4})|(\d{3}\s\d{3}\s\d{3}\s\d{4})"
}
IntlPhonePattern=xsd:string{
pattern="+\d{2}-\d{4}-\d{2}-\d{2}-\d{2}-"
}
kinds =(“Home”|“Work”|“Cell”|“Fax”)
kind =attribute kind {kinds}

knows = element knows {knowsContents}
knowsContents=(
attribute contacts {xds:IDREFS},
empty
)

description =element description {
mixed {anyHTML}*
}
anyHTML = element * {text}

//below code is very important
以下样式可以用来验证任何的xml文档，但该xml文档中不能含有属性（我们使用递归）
anyElement= element * {anyElement|text}*
以下可以作用于所有xml文档的验证，其可以含有元素，也可以含有属性
anyElement= element {anyAttribute | anyElement|text}
anyAttribute=attribute * {text}
也可以这样写：
any= element {attribute * {text} | any | text}

处理过程
XPath
//XPath作用：用于允许用户从一个XML文档中选取部分数据处理，更多请百度
//根结点代表文档本身，他与文档内容无关，根结点是代表xml文档的结点层级结构中的顶点，他没有名称，在文档串行化时，他是不可见的。元素结点是根结点的一个孩子，它代表文档元素。一个根结点可能只有一个孩子元素（即文档元素），也可能有多个子结点（如处理指令，注释）。
//根结点与根元素区别：根结点在文档串行化格式中不可见，他只是访问文档的一个起始点。根元素是文档里的第一个元素，它是根结点的一个孩子。
//根结点（或一个元素）的文本内容是根结点（或这个元素）所有子孙结点值的合并值，合并后顺序就是他们在文档中的顺序，如jjdddsss,这个文档的文本值是jjdddsss。
注意：根结点没有名称。
//xml文档里的每个元素在xpath数据模型里都表示一个元素结点。
//注意：在xml中任何元素起名都不能以数字开头，如果一个属性是一个id类型，id名的第一个字母不可以是数字，如中number是一个id属性，所以不可以写成为一定要加c使其以字母开头。
//属性结点的父节点就是属性修饰的元素结点。注意：访问属性结点一定要通过属性轴，而不是通过孩子轴。
//一个元素的文本内容在xpath中就是一个文本结点，一个文本结点的值就是他的字符串，文本结点没有名字。
//还有注释结点，处理指令结点，名称空间结点。
//子轴：默认轴：“child：：item”或简写“item”，如果要选取当前上下文的全部子结点“child：：”或“”。（但该方法只能选取有名字的结点即元素结点）。若要选取所有结点（含注释结点等）需要这样写：“child：：node（）”或“node（）”。选取上下文结点的文本子结点“child：：text（）”或“text（）”。
//属性轴：如果上下文结点是一个元素结点，则属性结点的定位路径为
“attribute：：”或“@”此时返回该元素结点的全部属性结点。
一般格式：“attribute：：secruity”或“@security”
//祖先轴：可以选取上下文结点的双亲结点，双亲的双亲结点直到根结点。如果上下文结点是根结点则返回空结点集。“ancestor：：”注意：无简写方法
//祖先自身轴：返回祖先轴中会返回的内容和上下文结点自身。“ancestor-or-self::section”
//子孙轴：选取上下文结点的子结点和子结点的子结点依此类推“descendant::”
//由于只有元素才有子元素因此把子孙轴用于其他类型结点如“属性结点”会返回空结点集
//子孙轴无简写。
//子孙自身轴：返回与子孙轴相同内容和他自身：”descendant-or-self：：”简写“//”
//后继轴：文档顺序中紧跟在上下文结点后的所有结点，不包括这个上下文结点的子孙结点，属性结点和名称空间结点等。“following：：”。
//后继兄弟轴：后继轴中与上下文结点共享同一个双亲的所有结点。“following-sibling：：”
//名称空间轴：选取名称空间结点。
//双亲轴：选取上下文结点的双亲结点“parent：：node（）”或“…”(注意：有两个点)。
如果上下文元素是根元素，则上述的定位路径返回文档的根结点。所以判断一个结点是否是根结点的方法：测试他的双亲结点是否为空，因为根结点是唯一没有双亲结点的结点。
//前驱轴：上下文结点前的结点不包括当前结点的祖先轴，属性轴等“preceding::”
//前驱兄弟结点：包括所有在前驱轴里的结点并且是与上下文结点共享一个双亲的结点。”preceding-sibling:😗”
//自身轴：选取上下文结点即自身：“self::node()”简写“.”（注意：是一个点）。
//了解更多：请百度。
//for example：（change lower case to uppercase）

<?xml version="1.0" encoding="UTF-8"?>

<xsl:stylesheet version=“1.0” xmlns:xsl=“http://www.w3.org/1999/XSL/Transform”>
<xsl:template match="/">


<xsl:apply-template select="//text()[normalize-space(.)]"/>


</xsl:template>
<xsl:template match=“text()”>
<xsl:variable name=“upper”
select="‘ABCDEFGHIJKLMNOPQRSTUVWXYZ’"/>
<xsl:variable name=“lower”
select="‘abcdefghijklmnopqrstuvwxyz’"/>
the input

<xsl:value-of select="."/>


<xsl:value-of select=“translate(.,$lower,$$upper)”/>



</xsl:template>
</xsl:stylesheet>

XSLT
//可扩展样式表语言转换（eXtensible Stylesheet Language Transformations）XSLT.
//important:一个xslt处理器就像一个软件，他接受一个XML文档（我们称它为源文档），把一个xslt样式表应用在此文档上，生成另一个文档（我们称为目标文档），目标文档可以是xml格式，也可以是html格式，甚至可以是纯文本格式和其他格式。
//important：对于XML处理器一个比较详细的描述是：他接受一个源文档，并根据xpath的数据模型，在内存中用一个树形结构表示这个文档，我们称它为源树（source tree），xslt处理器根据xslt样式表里的模板处理这棵源树，最后生成一棵目标树，从源树生成目标树的过程称为转换。生成目标树之后，开始串行化过程，他根据目标树，生成我们熟悉的串行化的xml文档或其他格式的文档。xslt处理器只负责把源树转化为目标树的任务。在xslt2.0中目标树可以不值一棵，而且，大多数xslt处理器也内带xml解析器和序列器，前者建立一棵源树，后者可以串行化目标。
//过程性语言：需要具体告诉计算机不论是什么操作都要把具体应该怎么做完全写出来，如用函数表示一个具体的动作的代码运行过程。描述性语言：只要告诉计算机你要他做什么，不用告诉他完成目的要进行什么样的动作与具体操作，由计算机自行完成（如：数据库中查找数据，你不用告诉数据库怎么去找，只要告诉数据库你想要什么数据，他就会帮你找）。

//forexample：
//below code in”test.xml”

<?xml version="1.0"?> kimi good boy lucy good girl

//below code in “test.xslt”
<xsl:stylesheet
xmlns:xsl=“http://www.w3.org/1999/XSL/Transform”
version=“1.0”>
<xsl:template match="/">

information about
<xsl:value-of select=“count(people/person)”/>people.

<xsl:apply-templates select="/people/person"/>


</xsl:template>
<xsl:template match=“person”>

<xsl:value-of select=“name”/>

<xsl:value-of select=“description”/>

</xsl:template>
</xsl:stylesheet>

//以上“test.xslt”会生成以下“test.html”

information about 2 people.

kimi

good boy

lucy

good girl

//可以由xsl:apply-template元素的select属性值决定上下文结点。
//以上例子中不用“select=“/people/person/name””是因为如果这样写将会匹配整个文档中所有name中的任意一个，而“select=“name””只会匹配当前person元素结点的子结点，即name元素结点的值才可以添加到目标树。
//XSLT指令：
1.xsl:value-of
他从源树中读取信息，他只选取一个结点集的值，如果这个结点集有多个结点，则“xsl:value-of”元素选取文档顺序的第一个结点值，而不是全部结点的值。
2.xsl:copy:(多用于xml文档的重构)：把一个结点复制到目标树，但并没有复制他的子孙结点，也不会复制他的属性等。当我们希望使用一个元素，但又想改变他的结构，如增加删除他的属性时，这个元素特别有用。for example：(here we change the child node of the “person” to be it attribute)
//below code in “test.xml”

<?xml version="1.0"?> kimi good boy lucy good girl //below code in “test.xslt” //above code will create below “test2.xml” <?xml version="1.0" encoding="UTF-8"?>

//接下来我们举一个增加子结点的例子：把上面“test2.xml”中的person的属性变回为他的子结点：
<xsl:stylesheet
xmlns:xsl=“http://www.w3.org/19997/XSL/Transform”
version=“1.0”>
<xsl:template match="/">

<xsl:apply-template select=“people/person”/>

</xsl:template>
<xsl:template match=“person”>
xsl:copy
<xsl:element name=“name”><xsl:value-of select="@name"/></xsl:element>
<xsl:element name=“description”><xsl:value-of select="@description"/></xsl:element>
</xsl:copy>
</xsl:template>
</xsl:stylesheet>
//自后目标文档为“test3.xml”

<?xml version="1.0"?> kimi good boy lucy good girl

//xsl:copy-of深复制：可以复制结点以及他所有的属性结点和子孙结点都复制到目标树中。
//我们接下来建一个订单在接受与发送不同人之间的呈现不同形式
//below in “user2.xml”

<?xml version="1.0"?> a.org b.com

123street anycity mo 456

//below code in “exchange.xslt”

//the code in”user1.xml” :

<?xml version="1.0"?> b.com a.org

123street anycity mo 456

//xsl:output:控制生成什么格式的输出文档。eg。<xsl:output method=“html”/>或<xsl:output method=“xml”/>或采用文本格式：<xsl:output method=“text”/>（注意：method中必须采用小写）
有时处理器也会推测我们想要生成什么文档，如当我们的第一个字面结果元素是“html”形式时，他会推测我们想要输出“html”格式。

//xsl:if
//in “product.xml”

<?xml version="1.0"?> a.org b.com

123street anycity mo 456

dog a.org b.com

123street anycity mo 456

cat

//in “product.xslt”
<xsl:stylesheet
xmlns:xsl=“http://www.w3.org/19997/XSL/Transform”
version=“1.0”>
<xsl:template match="/">

let find which price is expensive

<xsl:apply-template select="/purchaseorder/product"/>


</xsl:template>
<xsl:template match=“product”>
<xsl:if test="@price > 50">

<xsl:value-of select="."/>is expensive than 50 ,the price is <xsl:value-of select="@price">

</xsl:if>
</xsl:template>
</xsl:stylesheet>
//注意：因为“xsl:if”是“xsl:product”的子元素，因此当xml:if 元素的test值返回false时，product元素的模板不输出任何内容，即他不会被添加到目标树上。

//xsl:choose:必须从多个选项中选出一个，注意是只选出一个，或者一个都选不出，类似于java中的switch，当在所有选项中已有一个元素被选中，那么他之后的所有选项都不会被处理(包括xsl:otherwise也会被跳过)，如果没有一个”xsl:when”的test属性的值是”true”则处理”xsl:otherwise”
//in “product.xml”

<?xml version="1.0"?> a.org b.com

123street anycity mo 456

dog a.org b.com

123street anycity mo 456

cat

//in “product.xslt”
<xsl:stylesheet
xmlns:xsl=“http://www.w3.org/19997/XSL/Transform”
version=“1.0”>
<xsl:template match="/">

let find which price is expensive

<xsl:apply-template select="/purchaseorder/product"/>


</xsl:template>
<xsl:template match=“product”>
xsl:choose
<xsl:when test="@price > 50">

<xsl:value-of select="."/>is expensive than 50,it is<xsl:value-of select="@price"/>

</xsl:when>
xsl:otherwise

<xsl:value-of select="."/>is not expensive than 50,it is<xsl:value-of select="@price"/>

</xsl:otherwise>
</xsl:choose>
</xsl:template>
</xsl:stylesheet>
//code in”product.html”

let find which price is expensive

dog is expensive than 50,it is 100

cat is expensive than 50,it is 20

//xsl:for-each:将xslt指令作用于结点集的每一个元素上,注意：在用”xsl:for-each”时已经切换了上下文结点，将上下文结点切换到了当前for-each在搜索的结点上了。
//注意：元素在输出中的顺序可以完全不同于结点在源文档中的顺序。
<xsl:stylesheet
xmlns:xsl=“http://www.w3.org/19997/XSL/Transform”
version=“1.0”>
<xsl:template match="/">

every product 's price

<xsl:apply-template select="/purchaseorder"/>


</xsl:template>
<xsl:template match=“purchaseorder”>

• 
  <xsl:for-each select=“product”>
  
• <xsl:value-of select="@price"/>
• 
  </xsl:for-each>
  

</xsl:template>
</xsl:stylesheet>

//xsl:sort可以对结点集中的元素进行排序。

<?xml version="1.0"?> a.org b.com

123street anycity mo 456

dog1 dog2 a.org b.com

123street anycity mo 456

cat1 cat2

//in”test.xslt”
<xsl:stylesheet
xmlns:xsl=“http://www.w3.org/19997/XSL/Transform”
version=“1.0”>
<xsl:template match="/">

order product 's price

<xsl:apply-template select="/purchaseorder"/>
<xsl:sort select="@name" data-type=“text”/>


</xsl:template>
<xsl:template match=“purchaseorder”>

• 
  <xsl:for-each select=“product”>
  <xsl:sort select="@price" order=“descending” data-type=“number”/>
  
• <xsl:value-of select="."/>
• 
  </xsl:for-each>
  

</xsl:template>
</xsl:stylesheet>
//如果想要将排序的执行顺序优先后之分可以写如下代码：
<xsl:apply-template select=“person”>
<xsl:sort select=“lastname”/>
<xsl:sort select=“firstname”/>
</xsl:apply-template>
如果lastname一样再按firstname排序。

//XSLT Mode （为了同一对象可以有更多不同具体处理方法时便于区分不同的处理方法，有mode以后再匹配模式时不止要match一样，mode值也要一样）,是实现对源树的某个结点进行多次处理的需要。
For example：（将书的标题添加在目录于每节具体内容前）
//below code in”book.xml”

<?xml version="1.0"?> kimi lucy bob yuri 2018 xml is hahah hello xml good xml //below code in”book.xslt”

by

table of the content

, and .

:

.

//用法于Java中一样，当有多个时每个都会被按照顺序执行一遍，不断之前是否已有已经被执行过了。 //可以在生成的字符串中保留空白符（包括空格符，换行符）：如： :生成空格符

//XSLT变量于参数
//xsl:variable为变量，通过￥variablename引用
//xsl:parameter为参数，通过￥parametername引用。
//注意：在xslt中一个变量一旦被赋值就不能再被改变，例如不存在￥a=￥a+1的用法。
//注意：参数可以通过外部传递给转换程序，如在终端用户可以交互的输入，而变量只能在xslt样式表里内部定义，在xslt样式表内部有两种方法给变量赋值：用select或将值放在开始与结束标签之间。
注意：如果赋值的内容是字符串一定要注意双引号与单引号的交替引用。
<xsl:variable name=“a” select=“‘hi’”/>如果没有引号，他默认为由上下文结点的所有hi元素组成的结点集。
或
<xsl:variable name=“b”> 2</xsl:variable>
当然一个参数也可以用以上两种形式被赋值。
for example：
//below code in”book.xslt”
<xsl:stylesheet
xmlns:xsl=“http://www.w3.org/19997/XSL/Transform”
version=“1.0”>
<xsl:param name=“chaptertitle”>
<xsl:template match="/">





<xsl:apply-template select="/book/chapters/chapter[@title=$chaptertitle]"/>


</xsl:apply-template>

<xsl:template match="chapter">
   <p>chapter<b><xsl:value-of select="$chaptertitle"/></b>'s number is<xsl:value-of select="@number"></p>
</xsl:template>

</xsl:stylesheet>
below code in “book.xml”

<?xml version="1.0"?> kimi lucy bob yuri 2018 xml is hahah hello xml good xml //然后你可以在终端中输入：java -jar saxon9he.jar -o findbook.html book.xml book.xslt person=“hello xml” //then you will get “fingbook.html”

chapter htllo xml's number is 2

//命名模板xsl:call-template
//可以像在js里调用函数一样，根据模板的name使用模板。可以在调用模版时传入一个或很多个参数。
<xsl:template name=“a”>
XXXXXXX
</xsl:template>
<xsl:call-template name=“a”>
<xsl:with-param name=“parametername” select=“xxx”/>
</xsl:call-template>

//当然在任何时候我们都可以用<xml:with-param name=“parametername”select=“xxxx”/>来传入参数如
<xsl;template name=“a”>
<xsl:with-param name=“xxx” select=“xxx”/>
</xsl:template>

//xslt函数（请百度）
//xslt2.0 的分组元素

<?xml version="1.0" encoding="UTF-8"?>

<xsl:stylesheet
xmlns:xsl=“http://www.w3.org/19997/XSL/Transform”
version=“2.0”>
<xsl:templte match="/">

devide by country

<xsl:for-each-group select=“contacts/contact” group-by=“country”>
<xsl:sort select=“current-grouping-key()”/>

contacts live in <xsl:value-of select=“current-grouping-key()”/>

• 
  <xsl:apply-template select=“current-group()”>
  <xsl:sort select=“lastname”/>
  </xsl:apply-template>
  

</xsl:for-each-group>


</xsl:template>
<xsl:template match=“contact”>

• 
  <xsl:value-of select=“lastname”/>,<xsl:value-of select=“firstname”/>
  
• 
  </xsl:template>
  </xsl:stylesheet>

  //非XML输入源与字符串处理
  //假设一个变量“historicaldates”含有文字与数字形式的日期，现在我们想把日期分离出来：

  //读取并使用非xml输入源 //在“config.ini”中有 name = joe server = socrates role = admin initail screen = acounts //用“createconfig。xslt”转换他 <?xml version="1.0" encoding="UTF-8"？>

  <xsl:param name=“sourceuri” as=“xs:string”/>
  <xsl:template name=“main”>
  <xsl:variable name=“inifile” select=“upparsed-text($sourceuri)"/><config><xls:analyze-stringselect="$inifile” regex="\n">
  xsl:non-matching-string
  
  <xsl:for-each select=“tokenize(.’\s+=\s+’)”>
  xsl:choose
  <xsl:when test=“position()=1”>
  <xsl:attribute name=“name”>
  <xsl:value-of select="."/>
  </xsl:attribute>
  </xsl:when>
  xsl:otherwise
  <xsl:value-of select="."/>
  </xsl:otherwise>
  </xsl:choose>
  </xsl:for-each>
  
  </xsl:non-matching-string>
  </xsl:analyze-string>
  
  </xsl:template>

  </xsl:stylesheet>

  //最后生成
  
  joe
  socrates
  admin
  accounts
  

  //多文档输出

  <?xml version="1.0" encoding="UTF-8"?>

  <xsl:stylesheet
  xmlns:xsl=“http://www.w3.org/19997/XSL/Transform”
  version=“2.0”>
  <xsl:templte match="/">
  
  
  
  
  
  

  devide by country

  
  <xsl:for-each-group select=“contacts/contact” group-by=“country”>
  <xsl:sort select=“current-grouping-key()”/>
  

  contacts live in <xsl:value-of select=“current-grouping-key()”/>
  

  • 
    <xsl:apply-template select=“current-group()”>
    <xsl:sort select=“lastname”/>
    </xsl:apply-template>
    
  
  
  
  <xsl:result-document href="{current-grouping-key()}.xml">
  
  <xsl:copy-of select=“current-group()”/>
  
  </xsl:result-document>

              </xsl:for-each-group>
          </body>
      </html>
  </xsl:template>
  <xsl:template match="contact">
      <li>
          <xsl:value-of select="lastname"/>,<xsl:value-of select="firstname"/>
      </li>
  </xsl:template>
  

  </xsl:stylesheet>

  //用户自定义函数
  //以下例子中有订单我们希望返回订单的日期与总额，我们自己创建一个函数可以返回一个的总额
  //“orders.xml”as below

  <?xml version="1.0"?> //自定义函数代码如下

  //code in”orders.xslt”

  <?xml version="1.0" encoding="UTF-8"?>

  <xsl:stylesheet
  xmlns:xsl=“http://www.w3.org/1997/XSL/Transform”
  xmlns:xs=“http://www.w3.org/2001/XMLSchema”
  xmlns:udf=“http://wrox.com/XSLT/functions”
  version=“2.0”>

  <xsl:templte match="/">
      <html>
          <head>
              <title>orders</title>
          <head>
          <body>
              <h3>order summary for customers
              <xsl:value-of select="orders/@customerid"/>
              </h3>
              <table>
              <thead>
                  <tr>
                      <td>order id</td>
                      <td>order date</td>
                      <td>order total</td>
                  </tr>
              </thead>
              <tbody>
                  <xsl:apply-template select="orders/order">
                      <xsl:sort data-type="number" select="translate(@orderdate,'-','')"/>
                  </xsl:apply-template>
              </tbody>
              </table>
          </body>
      </html>
  </xsl:template>
  

  <xsl:template match=“order”>
  
  
  <xsl:value-of select="@orderid"/>
  
  
  <xsl:value-of select=“orderdate”/>
  
  
  <xsl:value-of select=“udf:get-order-total(items)”/>
  
  
  </xsl:template>

  <xsl:function name=“udf:get-order-total” as=“xs:double”>
  <xsl:param name=“items”/>
  <xsl:value-of select=“sum(for $item in $items/item return $item/@quantity\ast$item/@itemprice)”/>
  </xsl:function>
  </xsl:stylesheet>

  XLT-FO
  //XSL的组成：XSLT,XSL-FO,XPath（xslt：可以用来创建其他数据格式，排序现有数据，或通过筛选查询xml数据，主要用来转换。xslt-fo：用规定的结构格式化数据，主要用来格式化。xpath：提供标识xml文档树各部分的功能，主要用来选择要操作的元素。）
  //再用xsl-fo产生格式化输出时，首先利用xslt来产生一个xsl-fo可用的xml结构通常是要采取的第一步。
  //应用程序从一个数据源（如数据库，文本文件，另一个xml等）中提取数据，xslt将其转换成一个规定的属性结构，从而为数据的进一步转换做准备，根据输出要到达的终端，可以像数据应用一个样式表来产生适当的输出。
  // html—》html xsl—〉html page
  PDF—》pdf xsl—〉pdf document
  Datastore–（rawdata）—》xslt-（xml structure）—〉web service—》web servicexsl—webserviceconsumer
  //forexample：
  //below code in “hello.xml”

  <?xml version="1.0" encoding="UTF-8"?>

  <fo:root xmlns:fo=“http://www.w3.org/1999/XSL/Format”>
  fo:layout-master-set
  <fo:simple-page-master
  master-name=“A4”
  page-height=“29.7cm”
  page-width=“21cm”
  margin-top=“1.0cm”
  margin-bottom=“1.0cm”
  margin-left=“1.0cm”
  margin-right=“1.0cm”>
  <fo:region-body margin=“1.0cm”/>
  <fo:region-before extent=“1.0cm”/>
  <fo:region-after extent=“1.0cm”/>
  </fo:simple-page-master>
  </fo:layout-master-set>

  <fo:page-sequence master-reference="A4">
      <fo:flow flow-name="xsl-region-body">
          <fo:block>hello word</fo:block>
      </fo:flow>
  </fo:page-sequence>
  

  </fo:root>
  //以上文本通过apache fop 格式化对象处理器隐形xsl-fo代码。
  如果想得到纯文本格式：终端输入：“fop hello.xml -txt hello.txt”
  如果想得到PDF，输入“fop hello.xml -pdf hello.pdf”
  //“fo:flow ”为现实的内容的所有子元素提供一个子元素创造区域，“fo:flow”其不是真实会显示在页面上的区域，它只是为了能顺序显示他的子元素们而声明。flow-name中的值指定数据流显示在页面哪个位置。
  //for example：
  //belowcodein“post.xml”

  <?xml version="1.0" encoding="UTF-8"?> 123 a 456 b //below code in “post.xls” <?xml version="1.0" encoding="UTF-8"?>

  <fo:page-sequence master-reference="A4">
      <fo:flow flow-name="xsl-region-body">
       <xsl:apply-template select="//root/postcodes"/>
      </fo:flow>
  </fo:page-sequence>
  

  </fo:root>
  </xsl:template>
  <xsl:template match="//root/postcodes">
  fo:block<xsl:value-of select=“postcode”/>-<xsl:value-of select=“city”/></fo:block>
  </xsl:template>

  </xsl:stylesheet>
  //xsl-fo含有元素与属性可以创建列表和表格详细请百度，xls-fo使用时结合xslt，css，xpath

  数：据库
  XQuery
  //XSLT,XQuery都是以xml为输入源，他们生成的结果都来自于源xml树的结点，经过组合和过滤树并且给目标树增加一些文字内容，且都通常允许使用自定义函数。且xslt与xquery在变量创建并赋值后，变量就将不可修改。
  //绝大多数情况下xslt用来把xml文档转化为一显示为目的的html文档，或也可创建其他基于xml的显示格式如svg，或可用于B2B事务中把xml文档结构转换为另一种xml文档结构。而xquery更多用于数据库的查询。xslt采用xml语法，xquery采用非XML语法。xslt与xquery都可以把结点添加进目标树，都利用xpath选取需要处理的结点。
  //xquery用序列概念代替xpath的结点集概念。
  //FLWOR分别代表xslt的“xsl:for-each””xsl:variable””xsl:if””xsl:sort”
  //一个“for”可以绑定多个变量，而“let”只绑定一个变量。
  //fro example:
  //below code in”test.xml”

  <?xsl version="1.0"?> widget car fyt //below in “test.xquery” {for $i in (1,2,doc("test.xml")/products/product/text(),3,4) return {$i} } //the result: <?xml version="1.0"?> 1 2 widget car fyt 3 4

  //forexample:
  for $I in (1,2,3,4,5)
  与
  for $I in 1 to 5
  是一样的
  //for的嵌套
  
  {for $I in (1 to 5 ,7,8) return
  {for $ain(1to($I-2)) return {$a}}}
  

  //where
  
  {for $book in doc(“books.xml”)/books/book
  where KaTeX parse error: Expected '}', got 'EOF' at end of input: …attribute year{book/@yaer},
  element title {$book/title/text()}}}
  
  //order by
  
  {for $book in doc(“books.xml”)/books/book
  let $t:=$book/title/text() order by KaTeX parse error: Expected '}', got 'EOF' at end of input: … <book><title>{t}}
  

  //条件表达式
  
  {for $bookindoc("books.xml")/books/bookreturnif(count($book/author) gt 2)
  then
  
  else()
  }

  //更多xquery内容请百度

  XML与数据库
  //关系型数据库中数据以表格形式存贮，行在关系表里的顺序不代表数据的顺序，这与xml文档完全相反，在xml文档里，文档顺序是内在固有的，它会影响xpath里position（）等函数的返回结果。典型的关系型数据库用多个表表示，表与表之间有复杂的关系，不同表里的数据通过键关联起来。关系型数据库不像xml那样具有层级结构，而xml本质上就是层级结构。
  //更多内容请百度

  程序设计
  XML DOM

  //xml文档本身可以表示为一个Document结点。
  //xml dom多用于xml文档的大小较小时，当xml较大时我们使用sax等。
  //xml dom中的attr结点不是其元素结点的子结点，因为attr结点不被认为是dom树的一部分，尽管attr采用了node接口，attr结点的双亲结点，前后兄弟结点等都是null。
  //for example:
  //in IE

  //结点对象
  //显示dom结点的两种方法：一种方法是，把dom树看成由node对象组成的层级结构，即所有的xml dom对象都是node 对象，这样我们可以使用node对象的一些属性与方法；第二种方法：把dom树的根看作document结点（或对象），他的子孙结点是不同的对象。
  //注意：hi中的“hi”不是元素的nodeValue，一个元素的nodevalue一定为null，根据xmldom规定，只有文本结点与属性的nodeValue的值才为非null。
  用node对象的childNodes属性得到当前结点的子结点列表（注意：是列表）。
  //对于之前例子中不同浏览器要区别对待的问题我们通过引入“zXML”库来解决，其利用“浏览器嗅探”技术，判断在不同浏览器中哪些类可以使用，并返回一组共享方法的对象，实现跨浏览器操作。
  //具体的node对象的各种属性和方法请百度。
  forexample；

  //replace node

  //文本结点的效果

  //node对象的attributes会返回一个NamedNodeMap对象，这是一个命名的结点集合，其中保存了element结点所代表的元素的全部属性，这种保存是以无序的状态保存的，NamedNodeMap对象只有一个属性length。具体NamedNodeMap对象的更多方法请百度。
  //增加与删除属性，for example：

  //以所有上例子中的“book.xml”如下代码：
  
  this is chapter1
  this is chapter2
  this is chapter3
  this is chapter4
  
  //我们可以用node的childnodes来得到他的子所有子结点返回“NodeList”再用“NodeList”对象的length属性可以结合循环来处理一些事务，也可以通过的“NodeList”对象的“item（）”方法来得到具体的子元素，注意“item（）”从“0”开始取值。

  SAX
  //dom即所谓的基于结构树的API，原始文档中的所有信息和内容都被读入内存并存储在树状结构中。只有信息被全被读入后，客户端程序才能访问文档内容，在文档被分析并在内存中存储为树状结构后，客户端程序就会完全获得文档信息了。这样遍历修改文档或在结构树上添加或删除结点十分简单但是文档的大小将影响程序的运行以及内存的消耗，若文档过大将所有内容一次性加载到内存是不可能的且客户端必须等到文档被成功分析后才可获得信息，效率比较低。而sax是事件驱动型的API，该API并不在内存中建立一个文档副本再将其传递给客户端程序，而是要求客户端进行注册，以在解析器辨识这些xml文档中的不同部分时通知客户端。在事件驱动环境下，API本身并不为文档内容分配存储空间，所以不论文档大小是多少他们占用的内存与运行的效果，所需的文档内容被传递给事件通知方法，然后被丢弃。不同于结构树的方法，当客户端通知下下达时将认定文档已被分析完毕，这意味着客户端在整个文档被读取完毕钱就可以进行处理工作。这种方法的缺陷是程序开发者必须自己负责建立数据结构，来存储后续必须参考的所有文档信息。因为内存中不存在完整的文档信息。
  //基本sax应用程序流程：先获取一个对象引用，来实现XMLReader接口功能，再创建一个应用程序特定对象的实例，已实现一个或多个不同sax处理程序接口的功能。li将对象实例注册到XMLReader对象，以确保当xml分析事件发生时能够接收到通知。再对每个需要被应用程序处理的xml文档使用XMLReader.parse()方法。
  //更多内容如例子等请百度。
  通信
  Ajax
  //Ajax（asynchronous javascript and xml）：ajax背后的核心思想就是利用浏览器内置的javascript，从服务器端传输和处理xml。所谓异步指的是这种传输过程是在后台线程中进行的，从而允许客户机继续与web 页面进行交互。异步下载，加上如果只有相对少量的xml传输，就会减少这个浏览器页面的循环回复，这使web应用程序看上去更有效率。
  //ajax容易给人误解：ajax不总是异步的，是否异步你可以自己通过设置来改变。ajax不总是使用js如果满足于IE浏览器专用的程序代码，则也可以使用VBScript来代替。xml也不是一定必要的你也可以通过json等来传递数据。ajax的关键是应用程序在后台发送请求，不需要重新载入整个html页面也可以在页面里合并服务器返回的任何数据。有客户端脚本控制http请求，数据通常以xml格式通过请求发送回来，接收到的响应也通常采用xml格式。利用动态html网页的方法把响应的信息嵌入到页面里。
  //XMLHttpRequest：以下是创建一个XMLHTTPRequest对象的错误方法。

  //以上代码的不足之处在于当浏览器版本发生变化，新浏览器版本的出现，浏览器代理的字符串发生变化或者浏览器被设置成模拟其他浏览器时容易发生错误。所以我们建议使用如下的代码来创建。

  //XMLHttpRequest对象的方法：“open（）”：打开一个新的请求，以备调用。属性：“onreadystatechange”：onreadystatechange提供了一个事件侦听器hook函数，以便添加一个例程来处理异步请求，该方法与事件关联，在异步方法完成时被调用。属性“readystate”：反应当前的状态，具体可百度。
  //以下是对XMLHttpRequest调用的伪代码：
  var req=getReqObj();
  req.open(‘GET’,‘http://www.baidu.com’,true);
  //in the privious line the 'true’refrence to that this request is a asynchronous request
  //now we then set the function that will respond whenthe call is completed
  req.onreadystatechange=MyFunction;
  //notice in the previous line 'MyFunction’is function we write by our self ,in this function
  //we must refer to all state 's behivour when the state is happened
  req.send(data);
  //DOM中的对象：document，location（主要用于将用户转移到下一个页面），navigator（再查询浏览器功能是十分有用），window（在缩放窗口或改变其部件的可见性时十分有用）。以上对象具体使用情况请百度。
  //documentElement对象是文档的根结点，此结点被用来探索文档的深层结构。docuemnt对象还有很多方法：createElement（Tagname），getElementById（），getElementsByTagName（）：注意此方法返回指定类型的所有元素（是所有元素），通常情况下被用作循环的输入部分，以供接下来的程序进一步处理。
  //DOM中的事件：
  当我们将程序代码与事件关联起来时我们建议不用以下代码：
  button.οnclick=somejsfunction;
  以上代码存在潜在问题他去除了之前设置与onclick事件处理器相关联的任何处理程序。我们建议使用以下代码：
  在IE中：
  button.attachEvent(‘click’,somejsfunction);
  在dom complaint browser 中：
  button.addEvenetListener(‘click’,somejsfunction);
  上述代码给onclick方法添加了事件处理器功能，并使设置的事件捕获不会中断对已存在事件的侦听。
  //接下来是一些例子(a application be used to search telephone number),here we use HTMLpage(contains js)as client ,use ASP.NET HTTPas server
  //below code in “contactList.xml”
  
  
  alferds futterkiste
  maria anders
  1223
  
  
  alfe
  mia
  143
  
  
  kimi
  ko
  456
  
  
  iste
  ers
  8997
  
  
  //below code in the server
  <%@ WebHnadler Language=‘C#’ Class=‘CustomerLookup’%>

  using System;
  using System.Web;
  using System.Web.Caching;
  using System.Globlization;
  using System.Xml;
  using System.Xml.XPath;
  using System.Text;
  using System.IO;

  public class CustomerLookup:IHttpHandler{
  private const String dataFile=‘app_data/contactList.xml’;
  private const String cacheKey=‘contactList’;
  private const String Int32 maxResults=10;

  private HttpContext myContext=null;
  private String xQuery=@"customer/customer[start-with(translate(company,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz'),'{0}')or start-with(translate(contact,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz'),'{0}')]";
  
  public void ProcessRequest(HttpContext context){
      myContext=context;
      String result=String.Empty;
      String query=context.Request['q'];
      if(!String.IsNullOrEmpty(query)){
          result=GetContactList(query,maxResults);
      }
      context.Response.ContextType='text/xml';
      context.Respomse.Write(result);
  }
  
  public bool IsReusable{
      get{
          return false;
      }
  }
  
  private String GetContactList(String root,Int32 count){
      StringBuilder result=new StringBuilder();
      String fileName=myContext.Server.MapPath(dataFile);
      String data=LoadAndCache(fileName);
      String query=String.Empty;
      XmlDocument doc=new XmlDocument();
      XPathNavigator nav=null;
      int i=0;
  
      doc.LoadXml(data);
      query=String.Format(xQuery,root);
      nav=doc.createNavigator();
  
      XPathNodeIterator iter=nav.Select(query);
      XmlWriterSetting settings=new XmlWriterSetting();
      settings.Encoding=Encoding.UTF8;
      setting.OmitXmlDeclaration=true;
  
  
      using(XmlWriter w=XmlWriter.Create(resut,settings)){
          w.WritStartDocument();
          w.WriteStartElement("result");
          while(iter.MoveNext()){
              w.WriteNode(iter.Current,false);
              i++;
              if(i==count){
                  braek;
              }
          }
          w.WriteEndElement();
          w.WriteEndDocument();
       }
  
       return result.ToString();
  }
  
  
  private String LoadAndCache(sTRING fileName){
      String result=String.Empty;
  
      result=myContext.Cache[CacheKey] as String;
      if(String.IsNullOrEmpty(result)){
          using(StreamReader reader=File.OpenText(fileName)){
              result=reader.ReadToEnd();
          }
  
          myContext.Cahce.Add(cacheKey,result,
          new CacheDependency(fileName);
          Cache.NoAbsolutionExpiration,Cache.NoSlidingExpiration,
          CacheItemPriority.Normal,null
          );
      }
      return result;
  }
  

  }
  //below code in the client

  XML与.NET
  //通过XMLSerializer类串行化，通过XmlWriter，XmlReader，XPathDocument来操作，对于开发IE的人来说都十分有用，当用到的时候务必百度以了解更多（真的很有用）。

  XML与JAVA
  //了解更多请百度

  显示
  Css
  //当我们把css应用到XHTML/HTML的文件里时，css规则可以直接插入到文档头的

  <?xml version="1.0" encoding="UTF-8"> <?xml-stylesheet type="text/css" href="table.css"?> one two three four //below code in the “table.css” page{ display:block; color:#000000; background-color:#FFFFFF; border-style:solid; border-width:2px; border-color:#000000; }

  table{
  display:table;
  padding:20px;
  color:#000000;
  background-color:#FFFFFF;
  border-style:solid;
  border-width:2px;
  border-color:#000000;
  }

  tablerow{
  display:table-row;
  }

  tablecell{
  display:table-cell;
  padding:20px;
  color:#000000;
  background-color:#FFFFFF;
  border-style:solid;
  border-width:2px;
  border-color:#000000;
  }
  //注意在写属性值时，每一个属性与属性值对后一定要加分号，特别是最后一对在花括号前一定要加分号，方便我们以后再添加属性队，否则浏览器以后可能对新添加的内容解析失败。

  //在xml中用css生成链接：
  //below code in “link.xml”

  <?xml version="1.0" encoding="UTF-8"?> <?xml-stylesheet type="text/css" href="link.css"?> the following link use xlink to replicate the functionality of the htmlmhyperlinks between pages:

  
  click here
  
  

  //below code in “link.css”
  page{
  display:block;
  padding:10px;
  color:#000000;
  background-color:#ffffff
  border-style:solid;
  border-width:1px;
  border_color:#000000;
  }

  paragraph{
  display:block;
  padding:20px;
  color:#000000;
  background-color:#ffffff
  font-family:arial,verdana;
  }

  link{
  display:inline;
  color:#0000ff;
  text-decoration:underline;
  }
  //想要插入图像只需更改“link”即可，或者把想要的图像设为想改变元素的背景即可:
  

  XHTML
  //什么是xhtml：xhtml是html4.0的升级版，实际上它本质上还是一个html，只是制定者希望xhtml像xml一样可以更规范所以制定了他，但xhtml仍有很多版本，具体请“www。baidu。com”
  //注意：在编写xhtml时：所有元素名和属性名必须小写，但属性值可以出现大写。xhtml中使用“id”属性，不使用“name”属性。为了兼容在编写“xhtml”时最好“name”与“id”都写，且最好值相同。
  所有属性值必须用引号括起来，“id”属性的属性值必须是“ID”类型，因此他的值在文档里必须是唯一的。
  //格式化“xml”与格式化“xhtml”的区别：在格式化“xml”时，创建样式表的工具程序不会预先知道元素的显示格式，一切都要程序员自己定义，但在“xhtml”显示文档的工具大致已经知道某个元素要干什么，类似“html”，如浏览器知道“

  ”表示一个段落等，因此你只需像在“html”上一样即可。
  在“xml”中插入样式表<?xml-stylesheet?>
  在“xhtml”中插入样式表
  //在网页中不要直接插入js脚本代码，而是养成习惯把js脚本程序保存到单独的一个文件里

  在编写js时把代码放在注释里，这样是为了队老浏览器的兼容，而且对于 xhtml浏览器和服务器会在显示页面之前删除文档中的注释内容，这意味着删除了js程序，所以我们这样做：

  然而如果在文档中使用MIME为“application/xhtml+html”浏览器就知道文档为xml类型，而如果MIME为“text/html”则浏览器把它作为html文档，会产生以下不同：
  在xml DOM中用getelementsbytagname（）时返回元素名 用小写表示而在html中返回元素名用大写表示，xml中不能只用documnet.write()方法往页面中写入内容，必须要在文档中创建一个新元素。
  在xml中不能使用document.form等集合类型来访问文档内容，而要用getelementsbytagname()等其他方法。

  //什么是MIME：MIME类型就是设定某种扩展名的文件用一种应用程序来打开的类型方式，当该扩展名文件被访问时浏览器就会自动使用指定应用程序来打开。
  //对于“href”与“src”在xhtml2.0中凡是有“src”属性的元素都可以被认为是一个对象，凡是有“href”属性的元素都是一个链接。
  //forexample：
  //以下内容全在“test。html”中（注意是“.html”）

  <?xml version="1.0" encoding="UTF-8"?>

  <head>
      <meta http-equiv="Content-Type" content="text/html;charset=UTF-8"/>
      <title>lists in xhtml</title>
  </head>
  <body>
      <h1><a id="lists">lists in xhtml</a></h1>
      <p>three types of list </p>
  
      <ul>
          <li><a href="#orderedlist">ordered list</a></li>
          <li><a href="#unorderedlist">unordered list</a></li>
          <li><a href="#definitionlist">definition list</a></li>
      </ul>
  
      <h2><a id="orderedlist">orderedlist</a></h2>
          <p>lalala</p>
      <h2><a id="unorderedlist">unorderedlist</a></h2>
          <p>hihi</p>
      <h2><a id="definitionlist">definitionlist</a></h2>
          <p>kiki</p>
  
      <div><a href="#lists">back to the top</a></div>
  </body>
  

  SVG（scalable vector graphics）
  //svg 主要用来绘图，跟多内容请百度
  //通过以下例子我们可以发现使用svg比使用html与js结合用canvas来做图要方便的多，而且svg是Scalable作图，所以便于缩放图形，而且svg是vector作图是文件内容比位图要小的多（位图是通过逐个像素定义图像来完成的）
  //for example：

  <?xml version="1.0"?> //这里我们的默认单位是“px”像素，即width=“100”即为默认的width=“100px”。 //注意：一个图形在代码中的顺序决定了他被显示时的效果，即哪一个图形在上，哪个图形在下。 For example：我们改变上述代码 <?xml version="1.0"?> 此时将会呈现出不一样的效果，此时圆就不会再覆盖直线了。 //使用组是某些需要处理一些共性的元素刚在一组，使我们处理时更方便，减少多余重复代码的编写 //但是注意，这些共同的处理方法只有在被包含的元素没有独自在定义这个属性时才会生效，否则他的值将会被覆盖。 一上含有一些属性的重写 以上情况才能使组中所有元素都真的按照 中属性的值来呈现 //transform坐标变换，具体请百度，其中注意：变换的顺序不同，结果也会不同。其核心是坐标空间，而坐标空间通过变换矩阵来控制。常可把“transform”属性作用于 元素已实现移动整个组中的元素。 //path命令（注意path命令是严格区分大小写的） for example； 注意：以上代码中画的直线都在同一个位置，而第三种方法与第二种方法只有“l”的大小写不同导致他们需要有不同的坐标定位，因为“L（大写）”指绝对定位，“l（小写）”指相对定位。其中“M”指移动虚拟笔但不绘图，“L/l”指画直线。所有的命令如果用大写则表示绝对坐标，如果用小写则表示相对坐标。 //可以让svg与ECMAScript结合形成可交互的应用，具体例子可百度。 //更多请百度。 //html与xml是相似的，但html是为了呈现文本本身而标签文本，而xml是为了呈现数据而标签文本。

  XForms
  //xforms文档不是独立运行的，而是把xforms标记与另一个xml语言（如xhtml或svg）的标记相结合生成具有xforms功能的xhtml或svg文档。
  //for example::below code in “forms.xhtml”

  <?xml version="1.0" encoding="UTF-8"?> >

  enter your name

  enter your first name

  enter your last name

  click here to submit

  了解更多请百度