XML 学习笔记

时间 2020-05-02

标签 xml 学习笔记栏目 XML 繁體版

原文原文链接

Blog: https://blog.yilon.tophtml

XML 简介

XML 指可扩展标记语言（EXtensible Markup Language）。
XML 是一种很像HTML的标记语言。
XML 的设计宗旨是传输数据，而不是显示数据。
XML 标签没有被预约义。您须要自行定义标签。
XML 被设计为具备自我描述性。
XML 是 W3C 的推荐标准。
HTML 被设计用来显示数据。

XML 是对 HTML 的补充。node

XML 不会替代 HTML，理解这一点很重要。在大多数 Web 应用程序中，XML 用于传输数据，而 HTML 用于格式化并显示数据。git

对 XML 最好的描述是：数据库

XML 是独立于软件和硬件的信息传输工具。浏览器

XML 用途

XML 应用于 Web 开发的许多方面，经常使用于简化数据的存储和共享。服务器

XML 把数据从 HTML 分离

若是您须要在 HTML 文档中显示动态数据，那么每当数据改变时将花费大量的时间来编辑 HTML。网络

经过 XML，数据可以存储在独立的 XML 文件中。这样您就能够专一于使用 HTML/CSS 进行显示和布局，并确保修改底层数据再也不须要对 HTML 进行任何的改变。dom

经过使用几行 JavaScript 代码，您就能够读取一个外部 XML 文件，并更新您的网页的数据内容。编辑器

XML 简化数据共享

在真实的世界中，计算机系统和数据使用不兼容的格式来存储数据。ide

XML 数据以纯文本格式进行存储，所以提供了一种独立于软件和硬件的数据存储方法。

这让建立不一样应用程序能够共享的数据变得更加容易。

XML 简化数据传输

对开发人员来讲，其中一项最费时的挑战一直是在互联网上的不兼容系统之间交换数据。

因为能够经过各类不兼容的应用程序来读取数据，以 XML 交换数据下降了这种复杂性。

XML 简化平台变动

升级到新的系统（硬件或软件平台），老是很是费时的。必须转换大量的数据，不兼容的数据常常会丢失。

XML 数据以文本格式存储。这使得 XML 在不损失数据的状况下，更容易扩展或升级到新的操做系统、新的应用程序或新的浏览器。

XML 使您的数据更有用

不一样的应用程序都可以访问您的数据，不只仅在 HTML 页中，也能够从 XML 数据源中进行访问。

经过 XML，您的数据可供各类阅读设备使用（掌上计算机、语音设备、新闻阅读器等），还能够供盲人或其余残障人士使用。

XML 用于建立新的互联网语言

不少新的互联网语言是经过 XML 建立的。

这里有一些实例：

XHTML
用于描述可用的 Web 服务的 WSDL
做为手持设备的标记语言的 WAP 和 WML
用于新闻 feed 的 RSS 语言
描述资本和本体的 RDF 和 OWL
用于描述针针对 Web 的多媒体的 SMIL

假如开发人员都是理性的

假如他们都是理性的，就让将来的应用程序使用 XML 来交换数据吧。

将来也许会出现某种字处理软件、电子表格程序以及数据库，它们可使用 XML 格式读取彼此的数据，而不须要使用任何的转换程序。

XML 语法规则

全部 XML 元素都须有关闭标签

在 HTML，常常会看到没有关闭标签的元素：

<p>This is a paragraph
<p>This is another paragraph

在 XML 中，省略关闭标签是非法的。全部元素都必须有关闭标签：

<p>This is a paragraph</p>
<p>This is another paragraph</p>

注释：您也许已经注意到 XML 声明没有关闭标签。这不是错误。声明不属于XML自己的组成部分。它不是 XML 元素，也不须要关闭标签。

XML 标签对大小写敏感

XML 元素使用 XML 标签进行定义。

XML 标签对大小写敏感。在 XML 中，标签与标签是不一样的。

必须使用相同的大小写来编写打开标签和关闭标签：

<Message>这是错误的。</message>

<message>这是正确的。</message>

注释：打开标签和关闭标签一般被称为开始标签和结束标签。不论您喜欢哪一种术语，它们的概念都是相同的。

XML 必须正确地嵌套

在 HTML 中，常会看到没有正确嵌套的元素：

<b><i>This text is bold and italic</b></i>

在 XML 中，全部元素都必须彼此正确地嵌套：

<b><i>This text is bold and italic</i></b>

在上例中，正确嵌套的意思是：因为 <i> 元素是在 <b> 元素内打开的，那么它必须在 <b> 元素内关闭。

XML 文档必须有根元素

XML 文档必须有一个元素是全部其余元素的父元素。该元素称为根元素。

<root>
  <child>
    <subchild>.....</subchild>
  </child>
</root>

XML 的属性值须加引号

与 HTML 相似，XML 也可拥有属性（名称/值的对）。

在 XML 中，XML 的属性值须加引号。请研究下面的两个 XML 文档。第一个是错误的，第二个是正确的：

<note date=08/08/2008>
<to>George</to>
<from>John</from>
</note> 
<note date="08/08/2008">
<to>George</to>
<from>John</from>
</note>

在第一个文档中的错误是，note 元素中的 date 属性没有加引号。

实体引用

在 XML 中，一些字符拥有特殊的意义。

若是你把字符 "<" 放在 XML 元素中，会发生错误，这是由于解析器会把它看成新元素的开始。

这样会产生 XML 错误：

<message>if salary < 1000 then</message>

为了不这个错误，请用实体引用来代替 "<" 字符：

<message>if salary &lt; 1000 then</message>

在 XML 中，有 5 个预约义的实体引用：

<	<	小于
>	>	大于
&	&	和号
'	'	单引号
"	"	引号

注释：在 XML 中，只有字符 "<" 和 "&" 确实是非法的。大于号是合法的，可是用实体引用来代替它是一个好习惯。

XML 中的注释

在 XML 中编写注释的语法与 HTML 的语法很类似：

<!-- This is a comment -->

在 XML 中，空格会被保留

HTML 会把多个连续的空格字符裁减（合并）为一个：

HTML:    Hello           my name is David.
输出:    Hello my name is David.

在 XML 中，文档中的空格不会被删节。

XML 以 LF 存储换行

在 Windows 应用程序中，换行一般以一对字符来存储：回车符 (CR) 和换行符 (LF)。这对字符与打字机设置新行的动做有类似之处。在 Unix 应用程序中，新行以 LF 字符存储。而 Macintosh 应用程序使用 CR 来存储新行。

XML 元素

XML 文档包含 XML 元素。

什么是 XML 元素？

XML 元素指的是从（且包括）开始标签直到（且包括）结束标签的部分。

元素可包含其余元素、文本或者二者的混合物。元素也能够拥有属性。

<bookstore>
<book category="CHILDREN">
  <title>Harry Potter</title> 
  <author>J K. Rowling</author> 
  <year>2005</year> 
  <price>29.99</price> 
</book>
<book category="WEB">
  <title>Learning XML</title> 
  <author>Erik T. Ray</author> 
  <year>2003</year> 
  <price>39.95</price> 
</book>
</bookstore>

在上例中，和都拥有 元素内容，由于它们包含了其余元素。只有 文本内容，由于它仅包含文本。

在上例中，只有元素拥有属性 (category="CHILDREN")。

XML 命名规则

XML 元素必须遵循如下命名规则：

名称能够含字母、数字以及其余的字符
名称不能以数字或者标点符号开始
名称不能以字符 “xml”（或者 XML、Xml）开始
名称不能包含空格

可以使用任何名称，没有保留的字词。

最佳命名习惯

使名称具备描述性。使用下划线的名称也很不错。

名称应当比较简短，好比：<book_title>，而不是：<the_title_of_the_book>。

避免 "-" 字符。若是您按照这样的方式进行命名："first-name"，一些软件会认为你须要提取第一个单词。

避免 "." 字符。若是您按照这样的方式进行命名："first.name"，一些软件会认为 "name" 是对象 "first" 的属性。

避免 ":" 字符。冒号会被转换为命名空间来使用（稍后介绍）。

XML 文档常常有一个对应的数据库，其中的字段会对应 XML 文档中的元素。有一个实用的经验，即便用数据库的名称规则来命名 XML 文档中的元素。

非英语的字母好比 éòá 也是合法的 XML 元素名，不过须要留意当软件开发商不支持这些字符时可能出现的问题。

XML 元素是可扩展的

XML 元素是可扩展，以携带更多的信息。

XML 属性

XML 元素能够在开始标签中包含属性，相似 HTML。

属性 (Attribute) 提供关于元素的额外（附加）信息。

XML 属性必须加引号

属性值必须被引号包围，不过单引号和双引号都可使用。好比一我的的性别，person 标签能够这样写：

避免 XML 属性？

因使用属性而引发的一些问题：

属性没法包含多重的值（元素能够）
属性没法描述树结构（元素能够）
属性不易扩展（为将来的变化）
属性难以阅读和维护

请尽可能使用元素来描述数据。而仅仅使用属性来提供与数据无关的信息。

不要作这样的蠢事（这不是 XML 应该被使用的方式）：

<note day="08" month="08" year="2008"
to="George" from="John" heading="Reminder" 
body="Don't forget the meeting!">
</note>

针对元数据的 XML 属性

有时候会向元素分配 ID 引用。这些 ID 索引可用于标识 XML 元素，它起做用的方式与 HTML 中 ID 属性是同样的。这个例子向咱们演示了这种状况：

<messages>
  <note id="501">
    <to>George</to>
    <from>John</from>
    <heading>Reminder</heading>
    <body>Don't forget the meeting!</body>
  </note>
  <note id="502">
    <to>John</to>
    <from>George</from>
    <heading>Re: Reminder</heading>
    <body>I will not</body>
  </note> 
</messages>

上面的 ID 仅仅是一个标识符，用于标识不一样的便签。它并非便签数据的组成部分。

在此咱们极力向您传递的理念是：元数据（有关数据的数据）应当存储为属性，而数据自己应当存储为元素。

XML 验证

拥有正确语法的 XML 被称为“形式良好”的 XML。

经过 DTD 验证的 XML 是“合法”的 XML。

形式良好的 XML 文档

“形式良好”或“结构良好”的 XML 文档拥有正确的语法。

“形式良好”（Well Formed）的 XML 文档会遵照前几章介绍过的 XML 语法规则：

XML 文档必须有根元素
XML 文档必须有关闭标签
XML 标签对大小写敏感
XML 元素必须被正确的嵌套
XML 属性必须加引号

XMLHttpRequest 对象

XMLHttpRequest 对象用于在后台与服务器交换数据。

什么是 XMLHttpRequest 对象？

XMLHttpRequest 对象用于在后台与服务器交换数据。

XMLHttpRequest 对象是开发者的梦想，由于您可以：

在不从新加载页面的状况下更新网页
在页面已加载后从服务器请求数据
在页面已加载后从服务器接收数据
在后台向服务器发送数据

全部现代的浏览器都支持 XMLHttpRequest 对象。

XML DOM

DOM （Document Object Model，文档对象模型）定义了访问和操做文档的标准方法。

XML DOM

XML DOM (XML Document Object Model) 定义了访问和操做 XML 文档的标准方法。

DOM 把 XML 文档做为树结构来查看。可以经过 DOM 树来访问全部元素。能够修改或删除它们的内容，并建立新的元素。元素，它们的文本，以及它们的属性，都被认为是节点。

在下面的例子中，咱们使用 DOM 引用从元素中获取文本：

xmlDoc.getElementsByTagName("to")[0].childNodes[0].nodeValue

xmlDoc -由解析器建立的 XML 文档
getElementsByTagName("to")[0] - 第一个元素
childNodes[0] - 元素的第一个子元素（文本节点）
nodeValue - 节点的值（文本自己）

XML 命名空间（XML Namespaces）

命名冲突

在 XML 中，元素名称是由开发者定义的，当两个不一样的文档使用相同的元素名时，就会发生命名冲突。

此文档带有某个表格中的信息：

<h:table>
   <h:tr>
   <h:td>Apples</h:td>
   <h:td>Bananas</h:td>
   </h:tr>
</h:table>

此 XML 文档携带着有关一件家具的信息：

<f:table>
   <f:name>African Coffee Table</f:name>
   <f:width>80</f:width>
   <f:length>120</f:length>
</f:table>

如今，命名冲突不存在了，这是因为两个文档都使用了不一样的名称来命名它们的

经过使用前缀，咱们建立了两种不一样类型的

元素 (<h:table> 和 <f:table>)。

使用命名空间（Namespaces）

这个 XML 文档携带着某个表格中的信息：

<h:table xmlns:h="http://www.w3.org/TR/html4/">
   <h:tr>
   <h:td>Apples</h:td>
   <h:td>Bananas</h:td>
   </h:tr>
</h:table>

此 XML 文档携带着有关一件家具的信息：

<f:table xmlns:f="http://www.w3school.com.cn/furniture">
   <f:name>African Coffee Table</f:name>
   <f:width>80</f:width>
   <f:length>120</f:length>
</f:table>

与仅仅使用前缀不一样，咱们为

元素。

放置于元素的开始标签之中，并使用如下的语法：

xmlns:namespace-prefix="namespaceURI"

当命名空间被定义在元素的开始标签中时，全部带有相同前缀的子元素都会与同一个命名空间相关联。

注释：用于标示命名空间的地址不会被解析器用于查找信息。其唯一的做用是赋予命名空间一个唯一的名称。不过，不少公司经常会做为指针来使用命名空间指向实际存在的网页，这个网页包含关于命名空间的信息。

请访问 http://www.w3.org/TR/html4/。

统一资源标识符（Uniform Resource Identifier (URI)）

统一资源标识符是一串能够标识因特网资源的字符。最经常使用的 URI 是用来标示因特网域名地址的统一资源定位器(URL)。另外一个不那么经常使用的 URI 是统一资源命名(URN)。在咱们的例子中，咱们仅使用 URL。

默认的命名空间（Default Namespaces）

为元素定义默认的命名空间可让咱们省去在全部的子元素中使用前缀的工做。

请使用下面的语法：

xmlns="namespaceURI"

这个 XML 文档携带着某个表格中的信息：

<table xmlns="http://www.w3.org/TR/html4/">
   <tr>
   <td>Apples</td>
   <td>Bananas</td>
   </tr>
</table>

此 XML 文档携带着有关一件家具的信息：

<table xmlns="http://www.w3school.com.cn/furniture">
   <name>African Coffee Table</name>
   <width>80</width>
   <length>120</length>
</table>

命名空间的实际应用

当开始使用 XSL 时，您不久就会看到实际使用中的命名空间。XSL 样式表用于将 XML 文档转换为其余格式，好比 HTML。

若是您仔细观察下面的这个 XSL 文档，就会看到大多数的标签是HTML标签。非 HTML 的标签都有前缀 xsl，并由此命名空间标示："http://www.w3.org/1999/XSL/Transform"：

<?xml version="1.0" encoding="ISO-8859-1"?>

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

<xsl:template match="/">
<html>
<body>
  <h2>My CD Collection</h2>
  <table border="1">
    <tr>
      <th align="left">Title</th>
      <th align="left">Artist</th>
    </tr>
    <xsl:for-each select="catalog/cd">
    <tr>
      <td><xsl:value-of select="title"/></td>
      <td><xsl:value-of select="artist"/></td>
    </tr>
    </xsl:for-each>
  </table>
</body>
</html>
</xsl:template>

</xsl:stylesheet>

XML Schema 简介

XML Schema 是基于 XML 的 DTD 替代者。

XML Schema 可描述 XML 文档的结构。

XML Schema 语言也可做为 XSD（XML Schema Definition）来引用。

什么是 XML Schema？

XML Schema 的做用是定义 XML 文档的合法构建模块，相似 DTD。

XML Schema:

定义可出如今文档中的元素
定义可出如今文档中的属性
定义哪一个元素是子元素
定义子元素的次序
定义子元素的数目
定义元素是否为空，或者是否可包含文本
定义元素和属性的数据类型
定义元素和属性的默认值以及固定值

XML Schema 是 DTD 的继任者

咱们认为 XML Schema 很快会在大部分网络应用程序中取代 DTD。

理由以下：

XML Schema 可针对将来的需求进行扩展
XML Schema 更完善，功能更强大
XML Schema 基于 XML 编写
XML Schema 支持数据类型
XML Schema 支持命名空间

XML Schema 是 W3C 标准

XML Schema 在 2001 年 5 月 2 日成为 W3C 标准。

XML Schema 支持数据类型

XML Schema 最重要的能力之一就是对数据类型的支持。

经过对数据类型的支持：

可更容易地描述容许的文档内容
可更容易地验证数据的正确性
可更容易地与来自数据库的数据一并工做
可更容易地定义数据约束（data facets）
可更容易地定义数据模型（或称数据格式）
可更容易地在不一样的数据类型间转换数据

编者注：数据约束，或称 facets，是 XML Schema 原型中的一个术语，中文可译为“面”，用来约束数据类型的允许值。

XML Schema 使用 XML 语法

另外一个关于 XML Schema 的重要特性是，它们由 XML 编写。

由 XML 编写 XML Schema 有不少好处：

没必要学习新的语言
可以使用 XML 编辑器来编辑 Schema 文件
可以使用 XML 解析器来解析 Schema 文件
可经过 XML DOM 来处理 Schema
可经过 XSLT 来转换 Schema

XML Schema 可保护数据通讯

当数据从发送方被发送到接受方时，其要点是双方应有关于内容的相同的“指望值”。

经过 XML Schema，发送方能够用一种接受方可以明白的方式来描述数据。

一种数据，好比 "03-11-2004"，在某些国家被解释为11月3日，而在另外一些国家为看成3月11日。

可是一个带有数据类型的 XML 元素，好比： 2004-03-11 ，可确保对内容一致的理解，这是由于 XML 的数据类型 "date" 要求的格式是 "YYYY-MM-DD"。

XML Schema 可扩展

XML Schema 是可扩展的，由于它们由 XML 编写。

经过可扩展的 Schema 定义，您能够：

在其余 Schema 中重复使用您的 Schema
建立由标准类型衍生而来的您本身的数据类型
在相同的文档中引用多重的 Schema

形式良好是不够的

咱们把符合 XML 语法的文档称为形式良好的 XML 文档，好比：

它必须以 XML 声明开头
它必须拥有惟一的根元素
开始标签必须与结束标签相匹配
元素对大小写敏感
全部的元素都必须关闭
全部的元素都必须正确地嵌套
必须对特殊字符使用实体

即便文档的形式良好，仍然不能保证它们不会包含错误，而且这些错误可能会产生严重的后果。

请考虑下面的状况：您订购的了 5 打激光打印机，而不是 5 台。经过 XML Schema，大部分这样的错误会被您的验证软件捕获到。

XSD - 元素

** 元素是每个 XML Schema 的根元素。**

<?xml version="1.0"?>
 
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3school.com.cn"
xmlns="http://www.w3school.com.cn"
elementFormDefault="qualified">

...
...
</xs:schema>

代码解释：

下面的片段：

xmlns:xs="http://www.w3.org/2001/XMLSchema"

显示 schema 中用到的元素和数据类型来自命名空间 "http://www.w3.org/2001/XMLSchema"。同时它还规定了来自命名空间 "http://www.w3.org/2001/XMLSchema" 的元素和数据类型应该使用前缀 xs：

这个片段：

targetNamespace="http://www.w3school.com.cn"

显示被此 schema 定义的元素 (note, to, from, heading, body) 来自命名空间： "http://www.w3school.com.cn"。

这个片段：

xmlns="http://www.w3school.com.cn"

指出默认的命名空间是 "http://www.w3school.com.cn"。

这个片段：

elementFormDefault="qualified"

指出任何 XML 实例文档所使用的且在此 schema 中声明过的元素必须被命名空间限定。

在 XML 文档中引用 Schema

此 XML 文档含有对 XML Schema 的引用：

<?xml version="1.0"?>

<note xmlns="http://www.w3school.com.cn"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.w3school.com.cn note.xsd">

<to>George</to>
<from>John</from>
<heading>Reminder</heading>
<body>Don't forget the meeting!</body>
</note>

代码解释：

下面的片段：

xmlns="http://www.w3school.com.cn"

规定了默认命名空间的声明。此声明会告知 schema 验证器，在此 XML 文档中使用的全部元素都被声明于 "http://www.w3school.com.cn" 这个命名空间。

一旦您拥有了可用的 XML Schema 实例命名空间：

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

您就可使用 schemaLocation 属性了。此属性有两个值。第一个值是须要使用的命名空间。第二个值是供命名空间使用的 XML schema 的位置：

xsi:schemaLocation="http://www.w3school.com.cn note.xsd"

XSD 简易元素

XML Schema 可定义 XML 文件的元素。

简易元素指那些只包含文本的元素。它不会包含任何其余的元素或属性。

什么是简易元素？

简易元素指那些仅包含文本的元素。它不会包含任何其余的元素或属性。

不过，“仅包含文本”这个限定却很容易形成误解。文本有不少类型。它能够是 XML Schema 定义中包括的类型中的一种（布尔、字符串、数据等等），或者它也能够是您自行定义的定制类型。

您也可向数据类型添加限定（即 facets），以此来限制它的内容，或者您能够要求数据匹配某种特定的模式。

定义简易元素

定义简易元素的语法：

<xs:element name="xxx" type="yyy"/>

此处 xxx 指元素的名称，yyy 指元素的数据类型。XML Schema 拥有不少内建的数据类型。

最经常使用的类型是：

xs:string
xs:decimal
xs:integer
xs:boolean
xs:date
xs:time

例子：

这是一些 XML 元素：

<lastname>Smith</lastname>
<age>28</age>
<dateborn>1980-03-27</dateborn>

这是相应的简易元素定义：

<xs:element name="lastname" type="xs:string"/>
<xs:element name="age" type="xs:integer"/>
<xs:element name="dateborn" type="xs:date"/>

简易元素的默认值和固定值

简易元素可拥有指定的默认值或固定值。

当没有其余的值被规定时，默认值就会自动分配给元素。

在下面的例子中，缺省值是 "red"：

<xs:element name="color" type="xs:string" default="red"/>

固定值一样会自动分配给元素，而且您没法规定另一个值。

在下面的例子中，固定值是 "red"：

<xs:element name="color" type="xs:string" fixed="red"/>

XSD 属性

全部的属性均做为简易类型来声明。

什么是属性？

简易元素没法拥有属性。假如某个元素拥有属性，它就会被看成某种复合类型。可是属性自己老是做为简易类型被声明的。

如何声明属性？

定义属性的语法是：

<xs:attribute name="xxx" type="yyy"/>

在此处，xxx 指属性名称，yyy 则规定属性的数据类型。XML Schema 拥有不少内建的数据类型。

最经常使用的类型是：

xs:string
xs:decimal
xs:integer
xs:boolean
xs:date
xs:time

实例

这是带有属性的 XML 元素：

<lastname lang="EN">Smith</lastname>

这是对应的属性定义：

<xs:attribute name="lang" type="xs:string"/>

属性的默认值和固定值

属性可拥有指定的默认值或固定值。

当没有其余的值被规定时，默认值就会自动分配给元素。

在下面的例子中，缺省值是 "EN"：

<xs:attribute name="lang" type="xs:string" default="EN"/>

固定值一样会自动分配给元素，而且您没法规定另外的值。

在下面的例子中，固定值是 "EN"：

<xs:attribute name="lang" type="xs:string" fixed="EN"/>

可选的和必需的属性

在缺省的状况下，属性是可选的。如需规定属性为必选，请使用 "use" 属性：

<xs:attribute name="lang" type="xs:string" use="required"/>

对内容的限定

当 XML 元素或属性拥有被定义的数据类型时，就会向元素或属性的内容添加限定。

假如 XML 元素的类型是 "xs:date"，而其包含的内容是相似 "Hello World" 的字符串，元素将不会（经过）验证。

经过 XML schema，您也可向您的 XML 元素及属性添加本身的限定。这些限定被称为 facet（编者注：意为(多面体的)面，可译为限定面）。您会在下一节了解到更多有关 facet 的知识。

限定（restriction）用于为 XML 元素或者属性定义可接受的值。对 XML 元素的限定被称为 facet。

对值的限定

下面的例子定义了带有一个限定且名为 "age" 的元素。age 的值不能低于 0 或者高于 120：

<xs:element name="age">

<xs:simpleType>
  <xs:restriction base="xs:integer">
    <xs:minInclusive value="0"/>
    <xs:maxInclusive value="120"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

对一组值的限定

如需把 XML 元素的内容限制为一组可接受的值，咱们要使用枚举约束（enumeration constraint）。

下面的例子定义了带有一个限定的名为 "car" 的元素。可接受的值只有：Audi, Golf, BMW：

<xs:element name="car">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:enumeration value="Audi"/>
    <xs:enumeration value="Golf"/>
    <xs:enumeration value="BMW"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

上面的例子也能够被写为：

<xs:element name="car" type="carType"/>

<xs:simpleType name="carType">
  <xs:restriction base="xs:string">
    <xs:enumeration value="Audi"/>
    <xs:enumeration value="Golf"/>
    <xs:enumeration value="BMW"/>
  </xs:restriction>
</xs:simpleType>

注释：在这种状况下，类型 "carType" 可被其余元素使用，由于它不是 "car" 元素的组成部分。

对一系列值的限定

如需把 XML 元素的内容限制定义为一系列可以使用的数字或字母，咱们要使用模式约束（pattern constraint）。

下面的例子定义了带有一个限定的名为 "letter" 的元素。可接受的值只有小写字母 a - z 其中的一个：

<xs:element name="letter">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:pattern value="[a-z]"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

下一个例子定义了带有一个限定的名为 "initials" 的元素。可接受的值是大写字母 A - Z 其中的三个：

<xs:element name="initials">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:pattern value="[A-Z][A-Z][A-Z]"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

下一个例子也定义了带有一个限定的名为 "initials" 的元素。可接受的值是大写或小写字母 a - z 其中的三个：

<xs:element name="initials">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:pattern value="[a-zA-Z][a-zA-Z][a-zA-Z]"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

下一个例子定义了带有一个限定的名为 "choice 的元素。可接受的值是字母 x, y 或 z 中的一个：

<xs:element name="choice">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:pattern value="[xyz]"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

下一个例子定义了带有一个限定的名为 "prodid" 的元素。可接受的值是五个阿拉伯数字的一个序列，且每一个数字的范围是 0-9：

<xs:element name="prodid">

<xs:simpleType>
  <xs:restriction base="xs:integer">
    <xs:pattern value="[0-9][0-9][0-9][0-9][0-9]"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

对一系列值的其余限定

下面的例子定义了带有一个限定的名为 "letter" 的元素。可接受的值是 a - z 中零个或多个字母：

<xs:element name="letter">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:pattern value="([a-z])*"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

下面的例子定义了带有一个限定的名为 "letter" 的元素。可接受的值是一对或多对字母，每对字母由一个小写字母后跟一个大写字母组成。举个例子，"sToP"将会经过这种模式的验证，可是 "Stop"、"STOP" 或者 "stop" 没法经过验证：

<xs:element name="letter">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:pattern value="([a-z][A-Z])+"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

下面的例子定义了带有一个限定的名为 "gender" 的元素。可接受的值是 male 或者 female：

<xs:element name="gender">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:pattern value="male|female"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

下面的例子定义了带有一个限定的名为 "password" 的元素。可接受的值是由 8 个字符组成的一行字符，这些字符必须是大写或小写字母 a - z 亦或数字 0 - 9：

<xs:element name="password">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:pattern value="[a-zA-Z0-9]{8}"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

对空白字符的限定

如需规定对空白字符（whitespace characters）的处理方式，咱们须要使用 whiteSpace 限定。

下面的例子定义了带有一个限定的名为 "address" 的元素。这个 whiteSpace 限定被设置为 "preserve"，这意味着 XML 处理器不会移除任何空白字符：

<xs:element name="address">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:whiteSpace value="preserve"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

这个例子也定义了带有一个限定的名为 "address" 的元素。这个 whiteSpace 限定被设置为 "replace"，这意味着 XML 处理器将移除全部空白字符（换行、回车、空格以及制表符）：

<xs:element name="address">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:whiteSpace value="replace"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

这个例子也定义了带有一个限定的名为 "address" 的元素。这个 whiteSpace 限定被设置为 "collapse"，这意味着 XML 处理器将移除全部空白字符（换行、回车、空格以及制表符会被替换为空格，开头和结尾的空格会被移除，而多个连续的空格会被缩减为一个单一的空格）：

<xs:element name="address">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:whiteSpace value="collapse"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

对长度的限定

如需限制元素中值的长度，咱们须要使用 length、maxLength 以及 minLength 限定。

本例定义了带有一个限定且名为 "password" 的元素。其值必须精确到 8 个字符：

<xs:element name="password">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:length value="8"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

这个例子也定义了带有一个限定的名为 "password" 的元素。其值最小为 5 个字符，最大为 8 个字符：

<xs:element name="password">

<xs:simpleType>
  <xs:restriction base="xs:string">
    <xs:minLength value="5"/>
    <xs:maxLength value="8"/>
  </xs:restriction>
</xs:simpleType>

</xs:element>

数据类型的限定

标签添加了一个 xmlns 属性，这样就为前缀赋予了一个与某个命名空间相关联的限定名称。

限定	描述
enumeration	定义可接受值的一个列表
fractionDigits	定义所容许的最大的小数位数。必须大于等于0。
length	定义所容许的字符或者列表项目的精确数目。必须大于或等于0。
maxExclusive	定义数值的上限。所容许的值必须小于此值。
maxInclusive	定义数值的上限。所容许的值必须小于或等于此值。
maxLength	定义所容许的字符或者列表项目的最大数目。必须大于或等于0。
minExclusive	定义数值的下限。所容许的值必需大于此值。
minInclusive	定义数值的下限。所容许的值必需大于或等于此值。
minLength	定义所容许的字符或者列表项目的最小数目。必须大于或等于0。
pattern	定义可接受的字符的精确序列。
totalDigits	定义所容许的阿拉伯数字的精确位数。必须大于0。
whiteSpace	定义空白字符（换行、回车、空格以及制表符）的处理方式。

XSD 复合类型指示器

混合的复合类型可包含属性、元素以及文本。

带有混合内容的复合类型

XML 元素，"letter"，含有文本以及其余元素：

<letter>
Dear Mr.<name>John Smith</name>.
Your order <orderid>1032</orderid>
will be shipped on <shipdate>2001-07-13</shipdate>.
</letter>

下面这个 schema 声明了这个 "letter" 元素：

<xs:element name="letter">
  <xs:complexType mixed="true">
    <xs:sequence>
      <xs:element name="name" type="xs:string"/>
      <xs:element name="orderid" type="xs:positiveInteger"/>
      <xs:element name="shipdate" type="xs:date"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

注释：为了使字符数据能够出如今 "letter" 的子元素之间，mixed 属性必须被设置为 "true"。xs:sequence 标签 (name、orderid 以及 shipdate ) 意味着被定义的元素必须依次出如今 "letter" 元素内部。

咱们也能够为 complexType 元素起一个名字，并让 "letter" 元素的 type 属性引用 complexType 的这个名称（经过这个方法，若干元素都可引用同一个复合类型）：

<xs:element name="letter" type="lettertype"/>

<xs:complexType name="lettertype" mixed="true">
  <xs:sequence>
    <xs:element name="name" type="xs:string"/>
    <xs:element name="orderid" type="xs:positiveInteger"/>
    <xs:element name="shipdate" type="xs:date"/>
  </xs:sequence>
</xs:complexType>

XSD 复合类型指示器

经过指示器，咱们能够控制在文档中使用元素的方式。

指示器

有七种指示器：

Order 指示器：

All
Choice
Sequence

Occurrence 指示器：

maxOccurs
minOccurs

Group 指示器：

Group name
attributeGroup name

Order 指示器

Order 指示器用于定义元素的顺序。

All 指示器

指示器规定子元素能够按照任意顺序出现，且每一个子元素必须只出现一次：

<xs:element name="person">
  <xs:complexType>
    <xs:all>
      <xs:element name="firstname" type="xs:string"/>
      <xs:element name="lastname" type="xs:string"/>
    </xs:all>
  </xs:complexType>
</xs:element>

注释：当使用指示器时，你能够把设置为 0 或者 1，而只能把指示器设置为 1（稍后将讲解以及）。

Choice 指示器

指示器规定可出现某个子元素或者可出现另一个子元素（非此即彼）：

<xs:element name="person">
  <xs:complexType>
    <xs:choice>
      <xs:element name="employee" type="employee"/>
      <xs:element name="member" type="member"/>
    </xs:choice>
  </xs:complexType>
</xs:element>

提示：如需设置子元素出现任意次数，可将（稍后会讲解）设置为 unbounded（无限次）。

Sequence 指示器

规定子元素必须按照特定的顺序出现：

<xs:element name="person">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="firstname" type="xs:string"/>
      <xs:element name="lastname" type="xs:string"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

Occurrence 指示器

Occurrence 指示器用于定义某个元素出现的频率。

注释：对于全部的 "Order" 和 "Group" 指示器（any、all、choice、sequence、group name 以及 group reference），其中的 maxOccurs 以及 minOccurs 的默认值均为 1。

maxOccurs 指示器

指示器可规定某个元素可出现的最大次数：

<xs:element name="person">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="full_name" type="xs:string"/>
      <xs:element name="child_name" type="xs:string" maxOccurs="10"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

上面的例子代表，子元素 "child_name" 可在 "person" 元素中最少出现一次（其中 minOccurs 的默认值是 1），最多出现 10 次。

minOccurs 指示器

指示器可规定某个元素可以出现的最小次数：

<xs:element name="person">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="full_name" type="xs:string"/>
      <xs:element name="child_name" type="xs:string"
      maxOccurs="10" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

上面的例子代表，子元素 "child_name" 可在 "person" 元素中出现最少 0 次，最多出现 10 次。

提示：如需使某个元素的出现次数不受限制，请使用 maxOccurs="unbounded" 这个声明：

一个实际的例子：

名为 "Myfamily.xml" 的 XML 文件：

<?xml version="1.0" encoding="ISO-8859-1"?>

<persons xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="family.xsd">

<person>
<full_name>Tony Smith</full_name>
<child_name>Cecilie</child_name>
</person>

<person>
<full_name>David Smith</full_name>
<child_name>Jogn</child_name>
<child_name>mike</child_name>
<child_name>kyle</child_name>
<child_name>mary</child_name>
</person>

<person>
<full_name>Michael Smith</full_name>
</person>

</persons>

上面这个 XML 文件含有一个名为 "persons" 的根元素。在这个根元素内部，咱们定义了三个 "person" 元素。每一个 "person" 元素必须含有一个 "full_name" 元素，同时它能够包含多至 5 个 "child_name" 元素。

这是schema文件"family.xsd"：

<?xml version="1.0" encoding="ISO-8859-1"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
elementFormDefault="qualified">

<xs:element name="persons">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="person" maxOccurs="unbounded">
        <xs:complexType>
          <xs:sequence>
            <xs:element name="full_name" type="xs:string"/>
            <xs:element name="child_name" type="xs:string"
            minOccurs="0" maxOccurs="5"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>
    </xs:sequence>
  </xs:complexType>
</xs:element>

</xs:schema>

Group 指示器

Group 指示器用于定义相关的数批元素。

元素组

元素组经过 group 声明进行定义：

<xs:group name="组名称">
  ...
</xs:group>

您必须在 group 声明内部定义一个 all、choice 或者 sequence 元素。下面这个例子定义了名为 "persongroup" 的 group，它定义了必须按照精确的顺序出现的一组元素：

<xs:group name="persongroup">
  <xs:sequence>
    <xs:element name="firstname" type="xs:string"/>
    <xs:element name="lastname" type="xs:string"/>
    <xs:element name="birthday" type="xs:date"/>
  </xs:sequence>
</xs:group>

在您把 group 定义完毕之后，就能够在另外一个定义中引用它了：

<xs:group name="persongroup">
  <xs:sequence>
    <xs:element name="firstname" type="xs:string"/>
    <xs:element name="lastname" type="xs:string"/>
    <xs:element name="birthday" type="xs:date"/>
  </xs:sequence>
</xs:group>

<xs:element name="person" type="personinfo"/>

<xs:complexType name="personinfo">
  <xs:sequence>
    <xs:group ref="persongroup"/>
    <xs:element name="country" type="xs:string"/>
  </xs:sequence>
</xs:complexType>

属性组

属性组经过 attributeGroup 声明来进行定义：

<xs:attributeGroup name="组名称">
  ...
</xs:attributeGroup>

下面这个例子定义了名为 "personattrgroup" 的一个属性组：

<xs:attributeGroup name="personattrgroup">
  <xs:attribute name="firstname" type="xs:string"/>
  <xs:attribute name="lastname" type="xs:string"/>
  <xs:attribute name="birthday" type="xs:date"/>
</xs:attributeGroup>

在您已定义完毕属性组以后，就能够在另外一个定义中引用它了，就像这样：

<xs:attributeGroup name="personattrgroup">
  <xs:attribute name="firstname" type="xs:string"/>
  <xs:attribute name="lastname" type="xs:string"/>
  <xs:attribute name="birthday" type="xs:date"/>
</xs:attributeGroup>

<xs:element name="person">
  <xs:complexType>
    <xs:attributeGroup ref="personattrgroup"/>
  </xs:complexType>
</xs:element>

XSD 元素

** 元素使咱们有能力经过未被 schema 规定的元素来拓展 XML 文档！**

元素

元素使咱们有能力经过未被 schema 规定的元素来拓展 XML 文档！

下面这个例子是从名为 "family.xsd" 的 XML schema 中引用的片断。它展现了一个针对 "person" 元素的声明。经过使用元素，咱们能够经过任何元素（在以后）扩展 "person" 的内容：

<xs:element name="person">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="firstname" type="xs:string"/>
      <xs:element name="lastname" type="xs:string"/>
      <xs:any minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

如今，咱们但愿使用 "children" 元素来扩展 "person" 元素。这此种状况下咱们就能够这么作，即便以上这个 schema 的做者没有声明任何 "children" 元素。

请看这个 schema 文件，名为 "children.xsd"：

<?xml version="1.0" encoding="ISO-8859-1"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3school.com.cn"
xmlns="http://www.w3school.com.cn"
elementFormDefault="qualified">

<xs:element name="children">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="childname" type="xs:string"
      maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>

</xs:schema>

下面这个 XML 文件（名为 "Myfamily.xml"），使用了来自两个不一样的 schema 中的成分，"family.xsd" 和 "children.xsd"：

<?xml version="1.0" encoding="ISO-8859-1"?>

<persons xmlns="http://www.microsoft.com"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:SchemaLocation="http://www.microsoft.com family.xsd
http://www.w3school.com.cn children.xsd">

<person>
<firstname>David</firstname>
<lastname>Smith</lastname>
<children>
  <childname>mike</childname>
</children>
</person>

<person>
<firstname>Tony</firstname>
<lastname>Smith</lastname>
</person>

</persons>

上面这个 XML 文件是有效的，这是因为 schema "family.xsd" 容许咱们经过在 "lastname" 元素后的可选元素来扩展 "person" 元素。

和都可用于制做可扩展的文档！它们使文档有能力包含未在主 XML schema 中声明过的附加元素。

一个 XSD 实例

本节会为您演示如何编写一个 XML Schema。您还将学习到编写 schema 的不一样方法。

XML 文档

让咱们看看这个名为 "shiporder.xml" 的 XML 文档：

<?xml version="1.0" encoding="ISO-8859-1"?>

<shiporder orderid="889923"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="shiporder.xsd">
 <orderperson>George Bush</orderperson>
 <shipto>
  <name>John Adams</name>
  <address>Oxford Street</address>
  <city>London</city>
  <country>UK</country>
 </shipto>
 <item>
  <title>Empire Burlesque</title>
  <note>Special Edition</note>
  <quantity>1</quantity>
  <price>10.90</price>
 </item>
 <item>
  <title>Hide your heart</title>
  <quantity>1</quantity>
  <price>9.90</price>
 </item>
</shiporder>

上面的XML文档包括根元素 "shiporder"，其中包含必须名为 "orderid" 的属性。"shiporder" 元素包含三个不一样的子元素："orderperson"、"shipto" 以及 "item"。"item" 元素出现了两次，它含有一个 "title"、一个可选 "note" 元素、一个 "quantity" 以及一个 "price" 元素。

上面这一行 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"，告知XML解析器根据某个 schema 来验证此文档。这一行：xsi:noNamespaceSchemaLocation="shiporder.xsd" 规定了 schema 的位置（在这里，它与 "shiporder.xml" 处于相同的文件夹）。

建立一个 XML Schema

如今，咱们须要为上面这个 XML 文档建立一个 schema。

咱们能够经过打开一个新的文件来开始，并把这个文件命名为 "shiporder.xsd"。要建立schema，咱们仅仅须要简单地遵循 XML 文档中的结构，定义咱们所发现的每一个元素。首先咱们开始定义一个标准的 XML 声明：

<?xml version="1.0" encoding="ISO-8859-1" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
...
...


</xs:schema>

在上面的 schema 中，咱们使用了标准的命名空间 (xs)，与此命名空间相关联的 URI 是 Schema 的语言定义（Schema language definition），其标准值是 http://www.w3.org/2001/XMLSchema。

接下来，咱们须要定义 "shiporder" 元素。此元素拥有一个属性，其中包含其余的元素，所以咱们将它认定为复合类型。"shiporder" 元素的子元素被 xs:sequence 元素包围，定义了子元素的次序：

<xs:element name="shiporder">
 <xs:complexType>
  <xs:sequence>
  ...
  ...
  </xs:sequence>
  ...
 </xs:complexType>
</xs:element>

而后咱们须要把 "orderperson" 元素定义为简易类型（这是由于它不包含任何属性或者其余的元素）。类型 (xs:string) 的前缀是由命名空间的前缀规定的，此命名空间与指示预约义的 schema 数据类型的 XML schema 相关联：

<xs:element name="orderperson" type="xs:string"/>

接下来，我须要把两个元素定义为复合类型："shipto" 和 "item"。咱们从定义 "shipto" 元素开始：

<xs:element name="shipto">
 <xs:complexType>
  <xs:sequence>
   <xs:element name="name" type="xs:string"/>
   <xs:element name="address" type="xs:string"/>
   <xs:element name="city" type="xs:string"/>
   <xs:element name="country" type="xs:string"/>
  </xs:sequence>
 </xs:complexType>
</xs:element>

经过 schema，咱们可以使用 maxOccurs 和 minOccurs 属性来定义某个元素可能出现的次数。maxOccurs 定义某元素出现次数的最大值，而 minOccurs 则定义某元素出现次数的最小值。maxOccurs 和 minOccurs 的默认值都是 1！

如今，咱们能够定义 "item" 元素了。这个元素可在 "shiporder" 元素内部出现屡次。这是经过把 "item" 元素的 maxOccurs 属性的值设定为 "unbounded" 来实现的，这样 "item" 元素就可出现创做者所但愿的任意屡次。请注意，"note" 元素是可选元素。咱们已经把此元素的 minOccurs 属性设定为 0 了：

<xs:element name="item" maxOccurs="unbounded">
 <xs:complexType>
  <xs:sequence>
   <xs:element name="title" type="xs:string"/>
   <xs:element name="note" type="xs:string" minOccurs="0"/>
   <xs:element name="quantity" type="xs:positiveInteger"/>
   <xs:element name="price" type="xs:decimal"/>
  </xs:sequence>
 </xs:complexType>
</xs:element>

如今，咱们能够声明 "shiporder" 元素的属性了。因为这是一个必选属性，咱们规定 use="required"。

注释：此属性的声明必须被置于最后：

<xs:attribute name="orderid" type="xs:string" use="required"/>

这是这个名为 "shiporder.xsd" 的 schema 文件的文档清单：

<?xml version="1.0" encoding="ISO-8859-1" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

<xs:element name="shiporder">
 <xs:complexType>
  <xs:sequence>
   <xs:element name="orderperson" type="xs:string"/>
   <xs:element name="shipto">
    <xs:complexType>
     <xs:sequence>
      <xs:element name="name" type="xs:string"/>
      <xs:element name="address" type="xs:string"/>
      <xs:element name="city" type="xs:string"/>
      <xs:element name="country" type="xs:string"/>
     </xs:sequence>
    </xs:complexType>
   </xs:element>
   <xs:element name="item" maxOccurs="unbounded">
    <xs:complexType>
     <xs:sequence>
      <xs:element name="title" type="xs:string"/>
      <xs:element name="note" type="xs:string" minOccurs="0"/>
      <xs:element name="quantity" type="xs:positiveInteger"/>
      <xs:element name="price" type="xs:decimal"/>
     </xs:sequence>
    </xs:complexType>
   </xs:element>
  </xs:sequence>
  <xs:attribute name="orderid" type="xs:string" use="required"/>
 </xs:complexType>
</xs:element>

</xs:schema>

分割 Schema

前面的设计方法很是容易，但当文档很复杂时却难以阅读和维护。

接下来介绍的设计方法基于首先对全部元素和属性的定义，而后再使用 ref 属性来引用它们。

这是用新方法设计的 schema 文件：

<?xml version="1.0" encoding="ISO-8859-1" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

<!-- 简易元素的定义 -->
<xs:element name="orderperson" type="xs:string"/>
<xs:element name="name" type="xs:string"/>
<xs:element name="address" type="xs:string"/>
<xs:element name="city" type="xs:string"/>
<xs:element name="country" type="xs:string"/>
<xs:element name="title" type="xs:string"/>
<xs:element name="note" type="xs:string"/>
<xs:element name="quantity" type="xs:positiveInteger"/>
<xs:element name="price" type="xs:decimal"/>

<!-- 属性的定义 -->
<xs:attribute name="orderid" type="xs:string"/>

<!-- 复合元素的定义 -->
<xs:element name="shipto">
 <xs:complexType>
  <xs:sequence>
   <xs:element ref="name"/>
   <xs:element ref="address"/>
   <xs:element ref="city"/>
   <xs:element ref="country"/>
  </xs:sequence>
 </xs:complexType>
</xs:element>
<xs:element name="item">
 <xs:complexType>
  <xs:sequence>
   <xs:element ref="title"/>
   <xs:element ref="note" minOccurs="0"/>
   <xs:element ref="quantity"/>
   <xs:element ref="price"/>
  </xs:sequence>
 </xs:complexType>
</xs:element>

<xs:element name="shiporder">
 <xs:complexType>
  <xs:sequence>
   <xs:element ref="orderperson"/>
   <xs:element ref="shipto"/>
   <xs:element ref="item" maxOccurs="unbounded"/>
  </xs:sequence>
  <xs:attribute ref="orderid" use="required"/>
 </xs:complexType>
</xs:element>

</xs:schema>

使用指定的类型（Named Types）

第三种设计方法定义了类或者类型，这样使咱们有能力重复使用元素的定义。具体的方式是：首先对简易元素和复合元素进行命名，而后经过元素的 type 属性来指向它们。

这是利用第三种方法设计的 schema 文件 ("shiporder.xsd")：

<?xml version="1.0" encoding="ISO-8859-1" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

<xs:simpleType name="stringtype">
 <xs:restriction base="xs:string"/>
</xs:simpleType>

<xs:simpleType name="inttype">
 <xs:restriction base="xs:positiveInteger"/>
</xs:simpleType>

<xs:simpleType name="dectype">
 <xs:restriction base="xs:decimal"/>
</xs:simpleType>

<xs:simpleType name="orderidtype">
 <xs:restriction base="xs:string">
  <xs:pattern value="[0-9]{6}"/>
 </xs:restriction>
</xs:simpleType>

<xs:complexType name="shiptotype">
 <xs:sequence>
  <xs:element name="name" type="stringtype"/>
  <xs:element name="address" type="stringtype"/>
  <xs:element name="city" type="stringtype"/>
  <xs:element name="country" type="stringtype"/>
 </xs:sequence>
</xs:complexType>

<xs:complexType name="itemtype">
 <xs:sequence>
  <xs:element name="title" type="stringtype"/>
  <xs:element name="note" type="stringtype" minOccurs="0"/>
  <xs:element name="quantity" type="inttype"/>
  <xs:element name="price" type="dectype"/>
 </xs:sequence>
</xs:complexType>

<xs:complexType name="shipordertype">
 <xs:sequence>
  <xs:element name="orderperson" type="stringtype"/>
  <xs:element name="shipto" type="shiptotype"/>
  <xs:element name="item" maxOccurs="unbounded" type="itemtype"/>
 </xs:sequence>
 <xs:attribute name="orderid" type="orderidtype" use="required"/>
</xs:complexType>

<xs:element name="shiporder" type="shipordertype"/>

</xs:schema>

restriction 元素显示出数据类型源自于 W3C XML Schema 命名空间的数据类型。所以，下面的片断也就意味着元素或属性的值必须是字符串类型的值：

<xs:restriction base="xs:string">

restriction 元素常被用于向元素施加限制。请看下面这些来自以上 schema 的片断：

<xs:simpleType name="orderidtype">
 <xs:restriction base="xs:string">
  <xs:pattern value="[0-9]{6}"/>
 </xs:restriction>
</xs:simpleType>

这段代码指示出，元素或属性的值必须为字符串，而且必须是连续的六个字符，同时这些字符必须是 0-9 的数字。

Blog: https://blog.yilon.top

XML 学习笔记

XML 简介

XML 用途

XML 把数据从 HTML 分离

XML 简化数据共享

XML 简化数据传输

XML 简化平台变动

XML 使您的数据更有用

XML 用于建立新的互联网语言

假如开发人员都是理性的

XML 语法规则

全部 XML 元素都须有关闭标签

XML 标签对大小写敏感

XML 必须正确地嵌套

XML 文档必须有根元素

XML 的属性值须加引号

实体引用

XML 中的注释

在 XML 中，空格会被保留

XML 以 LF 存储换行

XML 元素

什么是 XML 元素？

XML 命名规则

最佳命名习惯

XML 元素是可扩展的

XML 属性

XML 属性必须加引号

避免 XML 属性？

针对元数据的 XML 属性

XML 验证

形式良好的 XML 文档

XMLHttpRequest 对象

什么是 XMLHttpRequest 对象？

XML DOM

XML DOM

XML 命名空间（XML Namespaces）

命名冲突

使用命名空间（Namespaces）

使用命名空间（Namespaces）

统一资源标识符（Uniform Resource Identifier (URI)）

默认的命名空间（Default Namespaces）

命名空间的实际应用

XML Schema 简介

什么是 XML Schema？

XML Schema:

XML Schema 是 DTD 的继任者

理由以下：

XML Schema 是 W3C 标准

XML Schema 支持数据类型

经过对数据类型的支持：

XML Schema 使用 XML 语法

由 XML 编写 XML Schema 有不少好处：

XML Schema 可保护数据通讯

XML Schema 可扩展

经过可扩展的 Schema 定义，您能够：

形式良好是不够的

XSD - 元素

代码解释：

在 XML 文档中引用 Schema

代码解释：

XSD 简易元素

什么是简易元素？

定义简易元素

定义简易元素的语法：

最经常使用的类型是：

例子：

简易元素的默认值和固定值

XSD 属性

什么是属性？

如何声明属性？

定义属性的语法是：

最经常使用的类型是：

实例

属性的默认值和固定值

可选的和必需的属性

对内容的限定

XSD 限定 / Facets

对值的限定

对一组值的限定

对一系列值的限定