Schema 介绍

XML Schema是以XML语言为基础的，它用于可替代DTD。

一份XML schema文件描述了XML文档的结构。

XML Schema语言也被称为XML Schema Definition (XSD)（XML Schema定义）.

What You Should Already Know
你应该已经掌握的知识

在继续之前你应对以下内容有基本了解：

  • HTML / XHTML
  • XML and XML Namespaces
    XML 和 XML 名称空间
  • A basic understanding of DTD
    对DTD有基本的了解

如果你想先学这些内容，请看我们主页上的的学习教程

What is an XML Schema?
什么是XML Schema？

XML Schema的作用是定义一份XML文档的合法组件群，就像DTD的作用一样

一份XML Schema

  • 定义了可以出现在文档里的元素
  • 定义了可以出现在文档里的属性
  • 定义了哪些元素是子元素
  • 定义了子元素的顺序
  • 定义了子元素的数量
  • 定义了一个元素应是否能包含文本，或应该是空的
  • 定义了元素和属性的数据类型
  • 定义了元素和属性的默认值和固定值

XML Schemas are the Successors of DTDs
XML Schema 是DTD的“接任者”

我们认为XML Schema很快就会替代DTD在大多数的网络应用程序中被广泛使用。

  • XML Schema针对将来的额外内容是可扩展的
  • XML Schema内容比DTD丰富，作用也更大
  • XML Schema是以XML语言编写而成的
  • XML Schema支持数据类型
  • XML Schema支持名称空间（namespaces）

XML Schema is a W3C Standard
XML Schema是W3C定义的标准

XML Schema于2001年5月2日成为W3C推荐使用的标准

在W3C 教程中你能阅读到更多关于XML Schema标准。


为何使用 XML Schemas

XML Schema比DTD作用更加强大。

XML Schemas Support Data Types
XML Schema支持数据类型

XML Schema的最好用的地方之一就是它支持数据类型

支持数据类型所带来的好处：

  • 更易于描述被允许的文档内容
  • 更易于检验数据的正确性
  • 更易于与数据库中的数据一起协同工作
  • 更易于定义数据的使用面（关于数据的限制）
  • 更易于定义数据样式（数据格式）
  • 更易于把数据转换成不同的数据类型

XML Schemas use XML Syntax
XML Schema使用XML的语法

XML Schema另一个好处就是他们是用XML编写成的。

用XML编写的好处是：

  • 可以不需要再学一种新语言
  • 可以用XML编辑器来编辑Schema文件
  • 可以用XML解析器解析Schema文件
  • 可以用XML DOM 处理Schema
  • 可以用XSLT转换Schema

XML Schemas Secure Data Communication
XML Schema安全数据通讯

当数据由发送者被传向接受者时，双方对“数据内容理解的一致性”就显得非常重要了

在XML Schema里，发送者可以用接受者能够理解的方式描述数据。

像这样格式的日期："03-11-2004"，一些国家会解释成11月3日，而别的国家会解释成3月11日

然而，一个有着像这样的数据种类的XML元素：<date type="date">2004-03-11</date>，就确保了双方都能理解其内容，因为XML数据类型的"date"要求规定为"YYYY-MM-DD"的格式。

XML Schemas are Extensible
XML Schema是可扩展的

因为XML Schema文件是由XML编写的，所以它们是可扩展的。

Schema可扩展意味着你可以：

  • 在别的Schema文件里再次用到你的Schema
  • 从标准的数据类型中派生出你自己的数据类型
  • 在相同的文档中参考多种Schema。

Well-Formed is not Enough
光有“规范”仍然是不够的

规范的XML文档是符合XML语法规则的文档，就像这样：

  • 开头必须有XML声明
  • 必须有一个独特的根目录元素
  • 开始标签（start-tag）必须和结束标签（end-tag）匹配
  • 元素是有大小写区分的
  • 元素必须有结束
  • 所有的元素必须被合理嵌套
  • 所有属性值必须写在引号里
  • 用特殊字符时必须用到实体

即使文档是规范的，它们也可能包含错误。这些错误可能会引起严重的后果。

试想下面的情况：你预定了 5罗（1罗=12打=144台）激光打印机，而不是5台打印机。在XML Schema文件里，大多数像这样的错误会由检验软件产生。


如何制定 XSD

XML文档能和一份DTD或XML Schema文件相关联。

A Simple XML Document
一份简单的XML文档

请看下面名为"note.xml"的一份简易的XML文档

<?xml version="1.0"?>
<note>
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body>Don't forget me this weekend!</body>
</note>

A DTD File
一份DTD文件

下面的例子是名为"note.dtd"的DTD文件，它定义了上述XML文档("note.xml")的元素。

<!ELEMENT note (to, from, heading, body)>
<!ELEMENT to (#PCDATA)>
<!ELEMENT from (#PCDATA)>
<!ELEMENT heading (#PCDATA)>
<!ELEMENT body (#PCDATA)>

第一行定义了含有"to, from, heading, body".四个子元素的“note”元素。

第2到5行定义了"#PCDATA". 类型的“to, from, heading, body”四个元素

An XML Schema
一份XML Schema

下面的例子当中，一个名为"note.xsd"的XML Schema文件定义了上述XML文档（"note.xml"）中的元素

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

xmlns="http://www.w3schools.com"
elementFormDefault="qualified">
<xs:element name="note">
<xs:complexType>
<xs:sequence>
    <xs:element name="to" type="xs:string"/>
    <xs:element name="from" type="xs:string"/>
    <xs:element name="heading" type="xs:string"/>
    <xs:element name="body" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>

Note元素是复合类型（complex type）因为它包含了其他元素，其他元素（to, from, heading, body）属于简单类型（simple type），因为它不包含其他元素。在下面几章里你会学到更多关于简单类型和复合类型的相关知识。

A Reference to a DTD
和DTD相关

XML文档和DTD相关：

<?xml version="1.0"?>
<!DOCTYPE note SYSTEM  "http://www.w3schools.com/dtd/note.dtd">
<note>
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body>Don't forget me this weekend!</body>
</note>

A Reference to an XML Schema
和XML Schema相关

下面的XML文档和XML Schema相关：

<?xml version="1.0"?>
<note
xmlns="http://www.w3schools.com"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.w3schools.com note.xsd">
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body>Don't forget me this weekend!</body>

</note>


XSD - <schema> 元素

<schema>元素是每个XML Schema文件的根元素。

The <schema> Element
<schema>元素

<schema>元素是每份XML Schema文件的根元素。

<?xml version="1.0"?>
<xs:schema>
...  ...
</xs:schema>

<schema>元素也可以含有一些属性，一个schema声明经常写成这样：

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

看下面的片段：

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

指明了在schema中使用的元素和数据种类来自http://www.w3.org/2001/XMLSchema名称空间（namespace）。它也指定了来自"http://www.w3.org/2001/XMLSchema"名称空间（namespace）的元素和数据种类必须带前缀“xs:”

This fragment:
这个片段：

targetNamespace="http://www.w3schools.com"

暗示了由这份schema(note, to, from, heading, body.)定义的元素来自"http://www.w3schools.com"名称空间（namespace）

This fragment:
这个片段：

xmlns="http://www.w3schools.com"

指明了默认名称空间（namespace）是http://www.w3schools.com.

This fragment:
这个片段

elementFormDefault="qualified"

指明了由这份schema声明的XML实例文档里用到的任何元素，都必须是有效的名称空间（namespace qualified）。

Referencing a Schema in an XML Document
在一份XML文档里提到Schema

一份XML文档里提提到XML Schiema

<?xml version="1.0"?>
<note xmlns="http://www.w3schools.com"  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    xsi:schemaLocation="http://www.w3schools.com note.xsd">
<to>Tove</to>  <from>Jani</from>  <heading>Reminder</heading>  <body>Don't forget me this weekend!</body>    </note>

The following fragment:
下面的片段：

xmlns="http://www.w3schools.com"

指定了默认的名称空间（default namespace）声明。这个声明告诉schema-检验器：这份XML文档里用到的所有元素都在http://www.w3schools.com的名称空间（namespace）中声明过。

一旦你有了可以利用的XML Schema Instance的名称空间（namespace）：

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

你可以用到SchemaLocation属性。这个属性有两个值。第一个值是要用到的名称空间（namespace）。第二个值是为名称空间（namespace）指定了需要使用的XML schema的位置。

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


XSD Simple 元素

XML Schemas（XML公式）定义了XML文件的元素

简单元素是只含有文本的XML元素。它不可以含有其他元素或属性

What is a Simple Element?
什么是简单元素？

简单元素是只含有文本的XML元素。它不可以含有其他元件或属性

但是，“只含文本”这个限定条件是非常容易引起误解的，文本可以有很多的不同类型。它可以是XML Schema定义里的文本类型之一（逻辑值，字符串，日期，等等），也可以是自定义文本类型。

你可以通过给数据类型添加限定条件来限制它的内容，或者你可以要求数据与指定的式样相匹配。

Defining a Simple Element
定义一个简明元素

定义简明元素的语法为：

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

在这里， xxx是元素名称，yyy是元素的数据类型

XML Schema本身有很多数据种类。最常见的种类有：
  • xs:string
    xs:字符
  • xs:decimal
    xs: 小数
  • xs:integer
    xs:整数
  • xs:boolean
    xs:逻辑值
  • xs:date
    xs:日期
  • xs:time
    xs:时间

Example
例子

这里是一些XML元素

<lastname>Refsnes</lastname>  <age>36</age>  <dateborn>1970-03-27</dateborn>

下面是相应的简单元素定义

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

Default and Fixed Values for Simple Elements
简单元素的默认值和固定值

简单元素也许会有指定的默认值或固定值

值没有被指定时，属性自动会设置成默认值

下面例子里默认值是"red":

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

固定值是也是自动分派给属性的，并且，一旦有了固定值，你就不能指定其他值了。

下面例子里固定值是"red":

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


XSD 属性

所有属性都是以简单类型来声明的。

What is an Attribute?
属性是什么？

简单的元素没有属性。当元素含有属性时，它会被认为是复合元素。但属性本身总是被声明为简单类型。

How to Define an Attribute?
怎么样定义属性？

定义一项属性的语法是：

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

其中，xxx是属性的名称，yyy指定了属性的数据类型

XML Schema本身有很多数据类型。最常见的数据类型有：
  • xs:string
    xs:字符串
  • xs:decimal
    xs:小数
  • xs:integer
    xs:整数
  • xs:boolean
    xs:逻辑值
  • xs:date
    xs:日期
  • xs:time
    xs:时间

Example
例子

这是一个有属性的XML元素：

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

而这个相应的属性定义：

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

Default and Fixed Values for Attributes
属性的默认值和固定值

属性也许有指定的默认值或固定值

值没有被指定时，属性自动会设成默认值

下面例子里默认值是"EN":

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

固定值是也是自动分派给属性的，并且，一旦有了固定值，你就不能指定其他值了。

下面例子里固定值是"EN":

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

Optional and Required Attributes
任意属性和必需属性

默认时属性是任意的，要指明属性是必需的，须用到"use"属性

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

Restrictions on Content
对内容的约束

当XML元素或属性有了已定义的数据类型，元素或属性的内容会有约束

如果一个XML元素是"xs:date"类型，并包含着象"Hello World"的字符串，元素就不会进行检验

你也可以用XML Schema给XML元素和属性添加约束限制。这些约束称为“面（facet）”。在下章里你可以读到更多关于“面”的内容


XSD Restrictions/Facets

约束用于给XML元素或属性定义可接受的值，关于对XML元素的约束称之为“面（facet）”

Restrictions on Values
对单个值的约束

下面的例子给叫做"age"的元件定义了一个“约束（restriction）”。“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>

Restrictions on a Set of Values
对一组值的约束

为了限制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"元素的一部分

Restrictions on a Series of Values
对一系列值的约束

为了限制XML元件的内容以定义一系列可被使用的数字或字母，我们可以用“式样约束（pattern constraints）”。

下面的例子给叫做"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之间的3个大写字母

<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的5个阿拉伯数字的排列，

<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>

Other Restrictions on a Series of Values
对一系列值的其他约束

下面的例子给叫做"letter"的元素定义了一个约束。唯一符合条件的值是a 到z的小写字母（可以有多个）或0

<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>

Restrictions on Whitespace Characters
对空白符的约束

为了指定空白符该怎样被处理，我们可以用空白符约束

下面的例子给叫做"address"的元素定义了一个约束。空白符设为"preserve"（保留），这意味着XML处理器不会删除任何空白字符：

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

下面的例子也给叫做"address"的元素定义了一个约束。空白符设为" replace "（替代），这意味着XML处理器会用空格替代所有的空白字符（换行符, 制表符, 空格符, 回车符)）

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

下面的例子也给叫做"address"的元素定义了一个约束。空白符设为"collapse"（消除），这意味着XML处理器会清除所有的空白字符（换行符, 制表符, 空格符以及回车符都被空格符代替。头尾空格会被清除，多个空格也会减少为一个）

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

Restrictions on Length
对长度的约束

为了限制元素的长度值，我们会用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>

Restrictions for Datatypes
对数据类型的约束

Constraint 约束 | Description 说明
enumeration | Defines a list of acceptable values 定义了一系列的有效值
fractionDigits | Specifies the maximum number of decimal places allowed. Must be equal to or greater than zero 指定了允许的小数位数的最多位数。必须大于等于0
length | Specifies the exact number of characters or list items allowed. Must be equal to or greater than zero 指定了允许的字符或列表项的个数。必须大于等于0
maxExclusive | Specifies the upper bounds for numeric values (the value must be less than this value) 指定了数值的上限（数值要比这个值小）
maxInclusive | Specifies the upper bounds for numeric values (the value must be less than or equal to this value) 指定了数值上限（数值必须小于等于这个值）
maxLength | Specifies the maximum number of characters or list items allowed. Must be equal to or greater than zero 指定了所允许的字符或列表项的最多个数。必须大于等于0
minExclusive | Specifies the lower bounds for numeric values (the value must be greater than this value) 指定了数值的下限 （数值要比这个值小）
minInclusive | Specifies the lower bounds for numeric values (the value must be greater than or equal to this value) 指定了数值的下限（数值必须大于等于这个值）
minLength | Specifies the minimum number of characters or list items allowed. Must be equal to or greater than zero 指定了所允许的字符或列表的最少个数。必须等于大于0个
pattern | Defines the exact sequence of characters that are acceptable 定义了符合要求的字符的确切排列顺序
totalDigits | Specifies the exact number of digits allowed. Must be greater than zero 指定了所允许的字符的确切个数。必须大于0
whiteSpace | Specifies how white space (line feeds, tabs, spaces, and carriage returns) is handled 指定了空白该怎样被处理（换行符，制表符，空格符和回车符）


XSD Complex 元素

一个复合元素（Complex Elements）包含其他元素和/或属性

What is a Complex Element?
什么是复合元素（Complex Elements）？

复合元素（Complex Elements）是含有其他元素和/或属性的XML元素

有四种复合元素（Complex Elements）：

  • 空元素
  • 只含有其他元素的元素
  • 只含有文本的元素
  • 含有文本和其他元素的元素

注意：这些元素中的每一个也许还含有属性!

Examples of Complex Elements
复合元素（Complex Elements）的例子

一个空的复合XML元素"product"：

<product pid="1345"/>

只含有其他元素的复合XML元素, "employee"

<employee>  <firstname>John</firstname>  <lastname>Smith</lastname>  </employee>

只含有文本的复合XML元素， "food"：

<food type="dessert">Ice cream</food>

A complex XML element, "description", which contains both elements and text:
含有元素和文本的复合XML元素, "description"：

<description>    It happened on <date lang="norwegian">03.03.99</date> ....  </description>

How to Define a Complex Element
怎样定义一个复合元素（Complex Elements）？

Look at this complex XML element, "employee", which contains only other elements:
看这个只含有其他元素的复合XML元素，"employee"：

<employee>
<firstname>John</firstname>
<lastname>Smith</lastname>
</employee>

我们有两种方法可以在一篇XML Schema里定义一个复合元素（Complex Elements）：

1. "employee"元素可以直接通过命名元素的方式被声明，像这样：

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

如果你用了上面的方法，那么只有"employee"元素才可以用指定的复合类型。注意子元素"firstname" 和 "lastname",它们是被包围在<sequence>“指示器”元素里的。这意味着子元素必须以它们被声明的顺序出现。在XSD指示器这章里你可以学到关于指示器更多内容。

2. "employee"元素可以有个类型属性，其所指的是要用的复合类型的名称

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

如果你用上述方法，几个元素指的可以是相同的复合类型，就像这样：

<xs:element name="employee" type="personinfo"/>
<xs:element name="student" type="personinfo"/>
<xs:element name="member" type="personinfo"/>
<xs:complexType name="personinfo">
 <xs:sequence>

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

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

</xs:sequence>  </xs:complexType>

你也可以在现存的复合元素（Complex Elements）上再加上一个复合元素（Complex Elements），并添加一些元素，就像这样：

<xs:element name="employee" type="fullpersoninfo"/>
<xs:complexType name="personinfo">
<xs:sequence>

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

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

<xs:complexContent>
<xs:extension base="personinfo">

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


XSD Complex 空元素

一个空的复合元素不能含有内容，只能含有属性。

Complex Empty Elements
复合空元素（Complex Empty Elements）

一个空的XML元素：

<product prodid="1345" />

上述"product"元素完全不含内容。为定义不含内容的类型，我们必须定义一个内容中只允许出现元素的类型，但我们不需要声明任何元素，就像这样：

<xs:element name="product">      <xs:complexType>      <xs:complexContent>        <xs:restriction base="xs:integer">          <xs:attribute name="prodid" type="xs:positiveInteger"/>          </xs:restriction>      </xs:complexContent>    </xs:complexType>  </xs:element>

上述例子中，我们定义了一个有复合内容的复合类型。复合内容的元素表示了我们想要约束或扩充的复合类型的内容模式。对整数的约束声明了一个属性，但并没有介绍任何元素内容。

但是，可以更加简洁地声明"product"元素，就像这样：

<xs:element name="product">    <xs:complexType>        <xs:attribute name="prodid" type="xs:positiveInteger"/>    </xs:complexType>  </xs:element>

或者你可以给complexType元素起个名称，并让"product"元素有个类型属性，而且类型属性引用的是complexType的名称（如果你用这个方法，几个元素可以引用相同的复合类型）：

<xs:element name="product" type="prodtype"/>
<xs:complexType name="prodtype">    <xs:attribute name="prodid" type="xs:positiveInteger"/>  </xs:complexType>


XSD 复合类型 - 纯元素

“只有元素（Elements-only）”复合类型含有一个只包含其他元素的元素

Complex Types Containing Elements Only
复合类型只含有元素

一个XML元素, "person",只含有其他元素：

<person>  <firstname>John</firstname>  <lastname>Smith</lastname>  </person>

你可以在一篇schema里定义"person"元素，就像这样

<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>

注意<xs:sequence>标签。这表示所定义的元素("firstname" 和 "lastname")必须在"person"元素里以那样的次序出现。

或者你可以给complexType元素取个名字，让"person"元素有个类型属性，这个类型属性的名字可以参考使用complexType元素的名字（如果你用这个方法，几个元素可以同时参考使用相同的复合类型）。

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


XSD 复合文字 - 纯元素

一个复合只含文本元素（Complex Text-Only Elements）可以含有文本和属性。

Complex Text-Only Elements
复合只含文本元素（Complex Text-Only Elements）

这种类型只含有简单内容（文本和属性），因此我们在内容周围添加一个simpleContent元素，当用到简单内容时，你必须在simpleContent元素里定义一个扩展或约束，就像这样：

<xs:element name="somename">      <xs:complexType>      <xs:simpleContent>        <xs:extension base="basetype">          ....          ....        </xs:extension>           </xs:simpleContent>    </xs:complexType>    </xs:element>

OR

<xs:element name="somename">    <xs:complexType>      <xs:simpleContent>        <xs:restriction base="basetype">            ....          ....        </xs:restriction>           </xs:simpleContent>    </xs:complexType>  </xs:element>

提示：用extension/restriction元素扩展或限制元素的基本简单类型（base simple type）。

Here is an example of an XML element, "shoesize", that contains text-only:
这儿是只含有文本的一个XML元素, "shoesize"：

<shoesize country="france">35</shoesize>

下面的例子声明了一个复合类型，"shoesize"元素。内容定义为整数值，"shoesize"元件含有名为"country"的属性。

<xs:element name="shoesize">    <xs:complexType>      <xs:simpleContent>        <xs:extension base="xs:integer">          <xs:attribute name="country" type="xs:string" />          </xs:extension>      </xs:simpleContent>    </xs:complexType>  </xs:element>

我们可以给complexType元件起个名字，让"shoesize"元件有种类属性，种类属性的名字就是complexType元件的名字。（如果你用这种方法，几个元素指的可以是相同的复合类型）

<xs:element name="shoesize" type="shoetype"/>
<xs:complexType name="shoetype">      <xs:simpleContent>      <xs:extension base="xs:integer">        <xs:attribute name="country" type="xs:string" />      </xs:extension>      </xs:simpleContent>  </xs:complexType>


XSD 混合内容的复合类型

混合内容的复合类型元素（XSD Complex Types Element With Mixed Content ）可以含有属性，元素，和文本。

Complex Types with Mixed Content
混合内容的复合类型

一个XML元素，"letter",既含有文本又含有其他元素：

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

下面的XML公式声明了"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"元素有一个引用了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 指示器复合类型

用指示器（Indicators）我们可以控制文件中元素的使用方法（HOW TO USE）。

Indicators
指示器（Indicators）

有7种指示器（Indicators）

Order indicators:
顺序指示器（Indicators）

  • All
    全部
  • Choice
    选择
  • Sequence
    按顺序

Occurrence indicators:
出现次数指示器（Indicators）：

  • maxOccurs
    最多出现次数
  • minOccurs
    最少出现次数

Group indicators:
组指示器（Indicators）：

  • Group name
    组名
  • attributeGroup name
    属性组名称

Order Indicators
顺序指示器（Indicators）

顺序指示器（Indicators）用于指定元素的顺序。

All Indicator
全部指示器（Indicators）

<all>指示器（Indicators）指明了子元件可以以任何次序出现，并且每个子元件只能出现一次：

<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>

注意：用<all>指示器（Indicators）时你可以把<minOccurs>指示器（Indicators）设为0或1，<maxOccurs>指示器（Indicators）只能设为1（<minOccurs> 和 <maxOccurs> 我们后头再说）

Choice Indicator
选择指示器（Indicators）

<choice>指示器（Indicators）指明了随便的子元素都可以出现：

<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>

Sequence Indicator
有序指示器（Indicators）

<sequence>指示器（Indicators）指定了子元素必须以一个指明的顺序出现：

<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 Indicators
出现次数指示器（Indicators）

出现次数指示器（Indicators）用于定义一个元素可以出现的次数

注意：对所有的"Order"和"Group"指示器（Indicators）(any, all, choice, sequence，group name, 和 group reference)来说，maxOccurs 和 minOccurs的默认值都是1

maxOccurs Indicator
最多出现次数指示器（Indicators）

最多出现次数指示器（Indicators）指明了一个元素可以出现的最多次数：

<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"元素里最少出现1次（minOccurs的默认值为1），最多出现10次

minOccurs Indicator
最少出现次数指示器（Indicators）

最少出现次数指示器（Indicators）指明了一个元素要出现的最小次数：

<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次（minOccurs的默认值为1），最多出现10次

提示：为使元件可以重复出现无数次，可以设置maxOccurs="unbounded"的状态

A working example:
实际作用例子：

名为"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>Hege Refsnes</full_name>  <child_name>Cecilie</child_name>  </person>
<person>    <full_name>Tove Refsnes</full_name>  <child_name>Hege</child_name>  <child_name>Stale</child_name>  <child_name>Jim</child_name>  <child_name>Borge</child_name>    </person>
<person>  <full_name>Stale Refsnes</full_name>  </person>
</persons>

上面XML文件含有一个名为"persons"的根元素，这个根元素里面里我们已经定义了3个"person"元素。每个"person"元素必须含有一个"full_name"元素，而且最多可有5个"child_name"元素。

下面是名为"family.xsd"的schema文件：

<?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 Indicators
组指示器（Indicators）

组指示器（Indicators）用于定义相关的元素组。

Element Groups
元素组

元素组要定义组声明，像这样：

<xs:group name="groupname">      ...  </xs:group>

你必须在组声明里定义一个all, choice,或sequence元素。下面的例子定义了一个名为"persongroup"的组，这个定义了一组元素必须以一定顺序出现：

<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: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>

Attribute Groups
属性组

属性组定义有attributeGroup（属性组）声明，像这样：

<xs:attributeGroup name="groupname">    ...  </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 <any> 元素

<any>元素可以使我们在XML文档中添加没有被schema 定义过的新元素从而扩充XML文档。

The <any> Element
<any>元素

<any>元素可以使我们在XML文档中添加没有被schema 定义过的新元素从而扩充XML文档。

下面的例子是名为"family.xsd"的一份XML schema片段。它展示了"person"元素的声明。用上<any>元素，我们可以在"person"元素的内容里扩充任意元素（在<lastname>的后面）

<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>

现在我们想在"person"元素中添加"children"元素，即使这篇schema的作者从未声明过什么"children"元素，我们也可以做到。

请看下面名为"children.xsd"的schema文件：

<?xml version="1.0" encoding="ISO-8859-1"?>    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"  targetNamespace="http://www.w3schools.com"  xmlns="http://www.w3schools.com"  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"），用上了来自"family.xsd" 和"children.xsd"两篇不同schema的组件

<?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.w3schools.com children.xsd">
<person>  <firstname>Hege</firstname>  <lastname>Refsnes</lastname>    <children>    <childname>Cecilie</childname>  </children>  </person>
<person>  <firstname>Stale</firstname>    <lastname>Refsnes</lastname>  </person>
</persons>

上述XML文件是有效的，因为"family.xsd" schema允许我们在"person"元素里的"lastname"元素后面扩充一个任意元素。

<any> 和<anyAttribute>元素是用于制造可扩展文档的！它们允许文档含有没有在主要XML schema里声明过的其它新元素。


XSD <anyAttribute> 元素

<anyAttribute>元素可使我们在XML文档中添加未被schema指定过的属性

<anyAttribute>元素

<anyAttribute>元素可使我们在XML文档中添加未被schema指定过的属性

下面是名为"family.xsd"的XML schema片段。它显示了"person"元素的声明。通过使用<anyAttribute>元素我们可以给"person"元素添加任意数量的属性。

<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:anyAttribute/>
  </xs:complexType>

</xs:element>

现在我们想在"person"元素中添加"gender"属性，即使这篇schema的作者从未声明过什么"gender"属性，我们也可以做到。

请看下面名为"attribute.xsd"的schema文件：

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

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3schools.com"
xmlns="http://www.w3schools.com"
elementFormDefault="qualified">
<xs:attribute name="gender">
  <xs:simpleType>

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

下面的XML文件（叫做"Myfamily.xml"），用上了来自"family.xsd" 和"attribute.xsd"两篇不同的schema组件。

<?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.w3schools.com attribute.xsd">
<person gender="female">
<firstname>Hege</firstname>
<lastname>Refsnes</lastname>

</person>
<person gender="male">
<firstname>Stale</firstname>
<lastname>Refsnes</lastname>
</person>
</persons>

上述XML文件是有效的，因为"family.xsd" schema允许我们在"person"元素里添加属性

<any> 和<anyAttribute>元素是用于扩展文档的！它们允许文档含有没有在主要XML schema里声明过的其它新元素。


XSD 元素替代

用XML Schema，一个元素可替代另一元素。

Element Substitution
元素替代（Element Substitution）

假设有两个分别来自英国和挪威的使用者，我们很希望有能力能让他或她进行选择，在XML文档里的元素名称中选择他们所擅长的语言，是英文呢？还是挪威文呢？

为解决这个问题，我们在XML schema里定义了替代组。首先，我们声明了一个标题元素，接着，我们声明已说明可替代标题元素的其他元素

<xs:element name="name" type="xs:string"/>
<xs:element name="navn" substitutionGroup="name"/>

在上面的例子里，"name"元素是标题元素，"navn"元素可以替代"name"。

看下面的XML schema片段：

<xs:element name="name" type="xs:string"/>
<xs:element name="navn" substitutionGroup="name"/>
<xs:complexType name="custinfo">
  <xs:sequence>
    <xs:element ref="name"/>
  </xs:sequence>
</xs:complexType>
<xs:element name="customer" type="custinfo"/>
<xs:element name="kunde" substitutionGroup="customer"/>

一份有效 的XML文档（根据上述schema的XML文档）应该像这样：

<customer>
  <name>John Smith</name>

</customer>

或者像这样：

<kunde>

  <navn>John Smith</navn>
</kunde>

Blocking Element Substitution
关闭元素替代（Element Substitution）

为了防止其他元素被已指定的元素替代（Element Substitution），可以用block属性：

<xs:element name="name" type="xs:string" block="substitution"/>

看这段XML schema片段：

<xs:element name="name" type="xs:string" block="substitution"/>

<xs:element name="navn" substitutionGroup="name"/>
<xs:complexType name="custinfo">
  <xs:sequence>
    <xs:element ref="name"/>

  </xs:sequence>
</xs:complexType>
<xs:element name="customer" type="custinfo" block="substitution"/>
<xs:element name="kunde" substitutionGroup="customer"/>

一份有效的XML文档（根据上述的schema的XML文档）应该像这样：

<customer>

  <name>John Smith</name>
</customer>

但是这样就不再有效了

<kunde>
  <navn>John Smith</navn>
</kunde>

Using substitutionGroup
使用替代组（substitutionGroup）

可替代元素类型应和标题元素的类型相同，或是从中派生出来的。如果可替代元素类型和标题元素的类型相同，你就不需要再指明可替代元素的类型了

注意在可替代元素组里的所有元素（标题元素和可替代元素）必须声明为“全域元素（global element）”，否则它是不会作用的！

What are Global Elements?
什么是“全域元素”？

“全域元素”是"schema"元素下面的直接子元素。“本地元素”是嵌套在别的元素里的元素。


XSD 实例

这章将示范如何写一份XML Schema.你也会了解到可以使用不同的方法书写schema。

An XML Document
一份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>John Smith</orderperson>   <shipto>    <name>Ola Nordmann</name>    <address>Langgt 23</address>      <city>4000 Stavanger</city>    <country>Norway</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"文件待在相同的文件夹里）。

Create an XML Schema
创建一篇XML Schema

现在我们想要为上面的XML文档创建一份schema

开始先打开叫做"shiporder.xsd"的新文件。为创建新的schema，我们可以简单地按照XML文档的结构，每当发现一个元素时就进行定义。一开始先作标准的XML声明，接下来是定义了schema的xs:schema元素：

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

在上述schema里我们用了标准的名称空间(xs),并且和这个名称空间相联系的URI是Schema语言定义，它有个标准值http://www.w3.org/2001/XMLSchema.

接下来，我们必须定义"shiporder”元素。这个元素有个属性，并包含着其他的元素，因此我们把它看成是复合类型。"shiporder"元素的子元素由xs:sequence元素包围着，xs:sequence元素定义了子元素一定顺序的排列。

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

那么我们必须将"orderperson"元件定义为简单类型（因为它不含有任何属性或其它元素）。种类用名称空间（namespace）的前缀使用与XML Schema相关的名称空间前缀化，这里的XML Schema指明了一个前缀的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"实现，属性为"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>

Divide the Schema
划分Schema

上面的设计方法非常简单，但因为文件是复合（或复杂的，Complex）的，所以难于阅读和利用。

下面的设计方法是：先定义所有的元素和属性，然后用ref属性引用它们。

下面是schema文件的新设计方式("shiporder.xsd"):

<?xml version="1.0" encoding="ISO-8859-1" ?>    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<!-- definition of simple elements -->  <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"/>
<!-- definition of attributes -->  <xs:attribute name="orderid" type="xs:string"/>
<!-- definition of complex elements -->  <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>

Using Named Types
使用有名称的类型

第三种设计方法定义了种类或类型，这使我们能重新用元素定义。通过给简单类型和复合类型元素命名，接着在元素的种类属性类型里指明它们的方法来做到这点。

这是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>

约束元素指出了这个数据类型是由一个W3C XML Schema名称空间数据类型派生出来的。所以，下面的片段意味着元素或属性的值必须是一个字符串的值

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

约束元素常常用于给元素添加约束。请看上述schema中的几行：

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

这指出了元素或属性的值必须是字符串，而且必须是一排6个从0到9之间的数字。


XSD 字符串数据类型

符串数据类型用于定义字符串的值的。

String Data Type
字符串数据类型

字符串数据类型包括字符，换行符，回车符，和制表符

下面是关于字符在schema（XML公式）里的声明方法的例子：

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

你文档中也许有这样的元素：

<customer>John Smith</customer>

它也许会是这样：

<customer>	John Smith	</customer>

注意：如果你用字符串数据类型，XML处理器将不会修改数值。

NormalizedString Data Type
规格化的字符串数据类型（NormalizedString Data Type）

规格化的字符串数据类型是从字符数据类型里派生出来的。

规格化的字符串数据类型也包括字符，但XML processor会清除换行符，回车符和制表符

下面的是关于一个规格化的字符串数据类型（normalizedString）在Schema中声明方法的例子：

<xs:element name="customer" type="xs:normalizedString"/>

你的文档中也许有像这样的元素：

<customer>John Smith</customer>

或者它也许会是这样：

<customer>	John Smith	</customer>

注意：上述例子里XML处理器会用空格符替代制表符

Token Data Type
记号（token）数据类型

记号数据类型也是从字符串数据类型里派生出来的

记号数据类型也包括字符，但XML处理器会清除换行符，回车符，制表符，头尾的空格，以及对于的空格。

下面是关于符号（token）在schema中声明的例子：

<xs:element name="customer" type="xs:token"/>

你文档中的元素也许像这样：

<customer>John Smith</customer>

或者它也有可能像这样：

<customer>	John Smith	</customer>

注意：在上述例子里，XML处理器会清除制表符

String Data Types
字符串数据类型

要注意下面所有的数据类型都是从字符串数据类型里派生出来的（除了字符串本身）

Name 名称 | Description 解释
ENTITIES |
ENTITY |
ID | A string that represents the ID attribute in XML (only used with schema attributes) 象征XML的ID属性的字符串（只用在schema属性里）
IDREF | A string that represents the IDREF attribute in XML (only used with schema attributes) 象征XML里的IDREF属性的字符串（只能和schema属性一起使用）
IDREFS |
language | A string that contains a valid language id 含有正确的语言ID的字符串
Name | A string that contains a valid XML name 含有一个有效的XML名称的字符串
NCName |
NMTOKEN | A string that represents the NMTOKEN attribute in XML (only used with schema attributes) 象征XML里的NMTOKEN属性的字符串（只能和schema属性一起使用）
NMTOKENS |
normalizedString | A string that does not contain line feeds, carriage returns, or tabs 不含有换行符，回车符或制表符的字符串
QName |
string | A string 一个字符串
token | A string that does not contain line feeds, carriage returns, tabs, leading or trailing spaces, or multiple spaces 不含有换行符，回车符，制表符，头尾空格，或重复空格的字符串

Restrictions on String Data Types
对字符串数据类型的约束（Restrictions on String Data Types）

Restrictions that can be used with String data types:
可约束的字符串数据类型：

  • enumeration
    列举
  • length
    长度
  • maxLength
    最大长度
  • minLength
    最小长度
  • pattern (NMTOKENS, IDREFS, and ENTITIES cannot use this constraint)
    式样（不能约束NMTOKENS, IDREFS,和 ENTITIES）
  • whiteSpace
    空白


XSD 日期数据类型

日期和时间数据类型（Date and time data types）用于定义日期和时间数据的。

Date Data Type
日期数据类型

日期数据类型用于指定一个具体的日期

日期由下面的"YYYY-MM-DD"形式指定。

  • YYYY指示年份
  • MM指示月份
  • DD 指示日期

注意：所有组件都是必需的。

下面是schema（XML公式）里的声明日期的例子

<xs:element name="start" type="xs:date"/>

你文档中的某个元素也许是这样的：

<start>2002-09-24</start>

Time Zones
时间区

为指定一个时间区，你既可以通过在日期的后面加个"Z"访问UTC时间格式的日期，就像这样：

<start>2002-09-24Z</start>

也可以UTC时间后加、减一个时间值，就像这样：

<start>2002-09-24-06:00</start>
or
<start>2002-09-24+06:00</start>

Time Data Type
时间数据类型

时间数据类型用于指定一个时间

时间由下面的"hh:mm:ss"形式指定：

  • hh指示小时
  • mm 指示分钟
  • ss指示秒钟

注意：所有的组件都是必需的

下面是schema（XML公式）里的时间声明的例子

<xs:element name="start" type="xs:time"/>

你文档中或许有这样的元素：

<start>09:00:00</start>

或者是这样的：

<start>09:30:10.5</start>

Time Zones
时间区

为指定一个时间区，你既可以通过在日期的后面加个"Z"访问UTC时间格式的日期，就像这样：

<start>09:30:10Z</start>

也可以UTC时间后加、减一个时间值，就像这样：

<start>09:30:10-06:00</start>
or
<start>09:30:10+06:00</start>

DateTime Data Type
日期时间数据类型（DateTime Data Type）

日期时间数据类型用于指定一个日期和一个时间

The dateTime is specified in the following form "YYYY-MM-DDThh:mm:ss" where:
日期时间由"YYYY-MM-DDThh:mm:ss"的形式指定：

  • YYYY indicates the year
    YYYY指示时间
  • MM indicates the month
    MM指示月份
  • DD indicates the day
    DD 指示时间
  • T indicates the start of the required time section
    T指示时间区的开头
  • hh indicates the hour
    hh指示小时
  • mm indicates the minute
    mm指示分钟
  • ss indicates the second
    ss指示秒钟

Note: All components are required!
注意：所有组件都是必需的

The following is an example of a dateTime declaration in a schema:
下面是schema（XML公式）里的日期时间声明的例子

<xs:element name="startdate" type="xs:dateTime"/>

An element in your document might look like this:
你文档中或许有这样的元素：

<startdate>2002-05-30T09:00:00</startdate>

Or it might look like this:
或者是这样的：

<startdate>2002-05-30T09:30:10.5</startdate>

Time Zones
时间区

为指定一个时间区，你既可以通过在日期的后面加个"Z"访问UTC时间格式的日期，就像这样：

<startdate>2002-05-30T09:30:10Z</startdate>

也可以UTC时间后加、减一个时间值，就像这样：

<startdate>2002-05-30T09:30:10-06:00</startdate>
or
<startdate>2002-05-30T09:30:10+06:00</startdate>

Duration Data Type
持续时间数据类型（或“时间段数据类型”）（Duration Data Type）

The duration data type is used to specify a time interval.
持续时间数据类型（或“时间段数据类型”）用于定义一段时间间隔

The time interval is specified in the following form "PnYnMnDTnHnMnS" where:
时间间隔由"PnYnMnDTnHnMnS"形式定义的

  • P indicates the period (required)
    P指示
  • nY indicates the number of years
    nY指示年数
  • nM indicates the number of months
    nM指示月数
  • nD indicates the number of days
    nD指示天数
  • T indicates the start of a time section (required if you are going to specify hours, minutes, or seconds)
    T指示时间部分的开头（如果你要指定时间，分钟，或秒数，就必须用到T）
  • nH indicates the number of hours
    nH指示小时数
  • nM indicates the number of minutes
    nM指示分钟数
  • nS indicates the number of seconds
    nS指示秒数

下面是schema（XML公式）里的时间段声明的例子

<xs:element name="period" type="xs:duration"/>

An element in your document might look like this:
你文档中或许有这样的元素：

<period>P5Y</period>

The example above indicates a period of five years.
上面的例子指示了5年的时间段

Or it might look like this:
或者也可以像这样：

<period>P5Y2M10D</period>

The example above indicates a period of five years, two months, and 10 days.
上面的例子指出了5年2个月零10天的时间段

Or it might look like this:
它也可以这样：

<period>P5Y2M10DT15H</period>

The example above indicates a period of five years, two months, 10 days, and 15 hours.
上面的例子指出了5年2个月零10天的时间段

Or it might look like this:
或者它会是可以这样：

<period>PT15H</period>

The example above indicates a period of 15 hours.
上面的例子指出了15小时的时间段

Negative Duration
负时间段

To specify a negative duration, enter a minus sign before the P:
为定义负的时间段，在P之前添个负号

<period>-P10D</period>

The example above indicates a period of minus 10 days.
上面的例子指出里负10天的时间段

Date and Time Data Types
日期和时间数据类型

Name 名称 | Description 解释
date | Defines a date value 定义日期的值
dateTime | Defines a date and time value 定义了日期和时间值
duration | Defines a time interval 定义了时间间隔
gDay | Defines a part of a date - the day (DD) 定义了日期的部分定义了时间的一部分——日部分(DD)
gMonth | Defines a part of a date - the month (MM) 定义了日期的一部分——月部分(MM)
gMonthDay | Defines a part of a date - the month and day (MM-DD) 定义了日期的一部分——月和日部分(MM-DD)
gYear | Defines a part of a date - the year (YYYY) 定义了日期的年部分(YYYY)
gYearMonth | Defines a part of a date - the year and month (YYYY-MM) 定义了日期的一部分——年和月部分(YYYY-MM)
time | Defines a time value 定义时间值

Restrictions on Date Data Types
对日期数据类型的约束

Restrictions that can be used with Date data types:
对日期数据类型可进行约束

  • enumeration
    列举
  • maxExclusive
    除去最大值
  • maxInclusive
    包括最大值
  • minExclusive
    除去最小值排外
  • minInclusive
    包括最小值
  • pattern
    式样
  • whiteSpace
    空白


XSD 小数数据类型

小数数据类型用于定义数值

Decimal Data Type
小数数据类型

小数数据类型用于指定一个数值

下面是在schema（XML公式）里关于小数声明的例子

<xs:element name="prize" type="xs:decimal"/>

你文档中的一个元素也许会像这样：

<prize>999.50</prize>

或者会像这样：

<prize>+999.5450</prize>

又或者像这样：

<prize>-999.5230</prize>

也可能这样：

<prize>0</prize>

Or it might look like this:
当然，也会是这样：

<prize>14</prize>

注意：可以指定的小数位数最多是18位。

Integer Data Type
整数数据类型

整数数据类型用于指定没有小数部分的数值。

下面是的关于整数在schema里的声明方法的例子。

<xs:element name="prize" type="xs:integer"/>

你文档中也许有这样的元素：

<prize>999</prize>

或许是这样：

<prize>+999</prize>

也可能是这样：

<prize>-999</prize>

当然也会是这样：

<prize>0</prize>

Numeric Data Types
数字数据类型

要注意的是下面所有的数据类型都是从小数数据类型里派生出来的（除了小数自身）

Name 名称 | Description 解释
byte | A signed 8-bit integer 最大8位的带符号整数
decimal | A decimal value 小数数值
int | A signed 32-bit integer 最大32位的带符号整数
integer | An integer value 整数值
long | A signed 64-bit integer 最大64位的带符号整数
negativeInteger | An integer containing only negative values ( .., -2, -1.) 含有负值的整数 ( .., -2, -1.)
nonNegativeInteger | An integer containing only non-negative values (0, 1, 2, ..) 含有非负值的整数 (0, 1, 2, ..)
nonPositiveInteger | An integer containing only non-positive values (.., -2, -1, 0) 含有非正值的整数 (.., -2, -1, 0)
positiveInteger | An integer containing only positive values (1, 2, ..) 只含有正值的整数(1, 2, ..)
short | A signed 16-bit integer 最大16位的带符号整数
unsignedLong | An unsigned 64-bit integer 最大64位的不带符号整数
unsignedInt | An unsigned 32-bit integer 最大32位的不带符号整数
unsignedShort | An unsigned 16-bit integer 最大16位的不带符号整数
unsignedByte | An unsigned 8-bit integer 最大8位的不带符号整数

Restrictions on Numeric Data Types
对字数据类型的约束

Restrictions that can be used with Numeric data types:
可用于约束的数字数据类型：

  • enumeration
    列举
  • fractionDigits
    小数位数
  • maxExclusive
    ? 除去最大值
  • maxInclusive
    包括最大值
  • minExclusive
    除去最小值
  • minInclusive
    包括最小值
  • pattern
    式样类型
  • totalDigits
    总的数字位数
  • whiteSpace
    空白部分


XSD 逻辑值数据类型

其他混合的数据类型包括逻辑值（boolean），基本的64个二进制数、十六进位数、浮点精度小数、双精度型数、anyURI、限定名称（QName）和符号。

Boolean Data Type
逻辑值数据类型

逻辑型数据类型用于指定值为真或假。

以下是在schema（XML公式）里有关逻辑声明的例子

<xs:attribute name="disabled" type="xs:boolean"/>

你文档里或许有这样的元素：

<prize disabled="true">999</prize>

注意：合法的逻辑值是真，假，1（指示真），0（指示假）

Binary Data Types
二进制数据类型

二进制数据用于表示二进制的数据

我们有两种二进制数据类型：

  • base64Binary (Base64-encoded binary data)
    基础64二进制（64码基础的二进制数据Base64-encoded binary data）
  • hexBinary (hexadecimal-encoded binary data)
    16进制（16进位编码的二进制数据hexadecimal-encoded binary data）

以下是关于十六进位数在schema里的声明方法：

<xs:element name="blobsrc" type="xs:hexBinary"/>

AnyURI Data Type
anyURI数据类型

anyURI数据类型用于指定一个URI.

以下是关于anyURI在schema里的声明方法：

<xs:attribute name="src" type="xs:anyURI"/>

你文档里也许有这个元素：

<pic src="http://www.w3schools.com/images/smiley.gif" />

注意：如果URI包含空格，可以用“%20”替代它们。

Miscellaneous Data Types
混合数据类型

Name 名称 | Description 描述
anyURI |
base64Binary |
boolean |
double |
float |
hexBinary |
NOTATION |
QName |

Restrictions on Miscellaneous Data Types
对混合数据类型的约束

Restrictions that can be used with the other data types:
可用于约束的其他数据类型：

  • enumeration (a Boolean data type cannot use this constraint)
    列举（不能用此约束逻辑值数据类型）
  • length (a Boolean data type cannot use this constraint)
    长度（不能用此约束逻辑值数据类型）
  • maxLength (a Boolean data type cannot use this constraint)
    最大长度（不能用此约束逻辑值数据类型）
  • minLength (a Boolean data type cannot use this constraint)
    最短长度（不能用此约束逻辑值数据类型）
  • pattern
    式样
  • whiteSpace
    空白


XML Schema总结

这篇教程教你如何描述XML文档的结构

你已经学习了怎样使用XML Schema（XML 公式），就是象DTD一样给XML文档定义合法元素。我们认为很快XML Schema（XML 公式）就会取代DTD而被大多数的网络应用程序所使用。

你已经知道了 XML公式语言是很丰富的。和DTD不同，它支持数据类型和名称空间。

想更多地了解XML Schema 的信息，请看我们的XML Schema 参考。

Now You Know XML Schema, What's Next?
现在你知道了XML Schema，那接着学什么呢？

下步是学习有关WSDL.

WSDL 是描述网络服务以及描述怎样访问它们的一种以schema为基础的语言

WSDL描述网络服务，以及与网络服务有关的信息格式和协议细节。

想学习更多与WSDL有关的内容，请浏览我们的WSDL 教程.


XML Schema 参考

XSD Elements
XSD元素

Element 元素 | Explanation 解释
all | Specifies that the child elements can appear in any order. Each child element can occur 0 or 1 time 指明了子元素可以以任意顺序出现，每个子元素出现0到1次
annotation | Specifies the top-level element for schema comments 为schema注释指定了最高阶层的元素
any | Enables the author to extend the XML document with elements not specified by the schema 让编者能够用没有被schema指定的元素来扩展XML文件
anyAttribute | Enables the author to extend the XML document with attributes not specified by the schema 让编者能够用没有被schema指定的属性来扩展XML文件
appInfo | Specifies information to be used by the application (must go inside annotation) 指定了将被应用程序所用到的信息（必须在annotation里）
attribute | Defines an attribute 定义属性
attributeGroup | Defines an attribute group to be used in complex type definitions 定义了用于复合种类定义的属性组
choice | Allows only one of the elements contained in the <choice> declaration to be present within the containing element 只允许<choice>声明里的元素里的一个元素出现在所含的元素中。
complexContent | Defines extensions or restrictions on a complex type that contains mixed content or elements only 在包含混合内容和元素的复合类型（complex type）上定义扩展或限制
complexType | Defines a complex type element 定义了复合类型元素（complex type element）
documentation | Defines text comments in a schema (must go inside annotation) 定义了schema里的文本注释（必须在annotation里）
element | Defines an element 定义元素
extension | Extends an existing simpleType or complexType element 扩展一个现存的简单类型或复合类型元素
field | Specifies an XPath expression that specifies the value used to define an identity constraint 指明一个XPath表达式，以指明用于定义身份约束的值
group | Defines a group of elements to be used in complex type definitions 定义了将用于复合类型说明的一组元素
import | Adds multiple schemas with different target namespace to a document 用不同的目标名称空间把多项schema添加到一份文件
include | Adds multiple schemas with the same target namespace to a document 用同一目标名称空间把多项schema添加到文件
key | Specifies an attribute or element value as a key (unique, non-nullable, and always present) within the containing element in an instance document 在实例文档包含的元素里指明某属性或元素值，使它们成为“钥匙”（特殊的，非零的，经常是存在的）
keyref | Specifies that an attribute or element value correspond to those of the specified key or unique element 定义用于回应已指明关键或特殊元素的属性或元素值
list | Defines a simple type element as a list of values 一张值的列表的形式定义一个简单类型元素
notation | Describes the format of non-XML data within an XML document 描述在XML文档里的非XML形式数据的格式
redefine | Redefines simple and complex types, groups, and attribute groups from an external schema 从外部的schema中重新定义简单和复合类型，群，以及属性群
restriction | Defines restrictions on a simpleType, simpleContent, or a complexContent 在简单类型，简单文本或复合文本上定义约束
schema | Defines the root element of a schema 定义schema的根元素
selector | Specifies an XPath expression that selects a set of elements for an identity constraint 指明一段可为身份约束选择一组节点的XPath表达
sequence | Specifies that the child elements must appear in a sequence. Each child element can occur from 0 to any number of times 指明了子元素必须以一定顺序出现。每个子元素可以出现任意次
simpleContent | Contains extensions or restrictions on a text-only complex type or on a simple type as content and contains no elements 包含着作为只有文本的复合类型或简单类型的文本的扩展和约束，不包含元素
simpleType | Defines a simple type and specifies the constraints and information about the values of attributes or text-only elements 定义了简单类型，指定了关于属性值或只有文本的元素的信息
union | Defines a simple type as a collection (union) of values from specified simple data types 从已指定的简单数据类型里定义简单种类，作为值的集合
unique | Defines that an element or an attribute value must be unique within the scope 定义了在所属范围内一个元素或属性值必须是独特（没有重复的）

XSD Restrictions/Facets for Datatypes
XSD对各种数据类型的约束

Look at XSD Restrictions!
下面看一看关于XSD的约束

Constraint 约束 | Description 描述
enumeration | Defines a list of acceptable values 定义了一系列可接受的属性的值
fractionDigits | Specifies the maximum number of decimal places allowed. Must be equal to or greater than zero 指明了所允许的最多小数位数。必须等于大于0
length | Specifies the exact number of characters or list items allowed. Must be equal to or greater than zero 指明了所允许的字符或列表项的确切个数。必须等于大于零
maxExclusive | Specifies the upper bounds for numeric values (the value must be less than this value) 指明了最大数值（数值必须小于最大数值）
maxInclusive | Specifies the upper bounds for numeric values (the value must be less than or equal to this value) 指明了数值上限（数值必须小于等于数值上限）
maxLength | Specifies the maximum number of characters or list items allowed. Must be equal to or greater than zero 指明了所允许的字符或列表项的最多个数。必须大于等于0
minExclusive | Specifies the lower bounds for numeric values (the value must be greater than this value) 指明了数值的下限（数值必须比这个值大）
minInclusive | Specifies the lower bounds for numeric values (the value must be greater than or equal to this value) 指明了数值的下限（数值要大于等于这个值）
minLength | Specifies the minimum number of characters or list items allowed. Must be equal to or greater than zero 指明了所允许的字符和列表项的最少个数。必须大于等于0个
pattern | Defines the exact sequence of characters that are acceptable 定义了可接受字符的确切顺序
totalDigits | Specifies the exact number of digits allowed. Must be greater than zero 定义了所允许的阿拉伯数字的确切个数。必须比0个多
whiteSpace | Specifies how white space (line feeds, tabs, spaces, and carriage returns) is handled 定义了各种空白区域（white space） (换行符、制表符、空格、回车符）是如何被处理的。