> For the complete documentation index, see [llms.txt](https://rocape.gitbook.io/xmllanguage/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://rocape.gitbook.io/xmllanguage/di-wu-zhang-xmlschema/53xmlschema-de-yu-fa.md).

# 5.3 XML Schema 的语法

\###5.3 XML Schema的语法

* XML Schema文档
* 大多数XML Schema单独保存在一个XML文档（\*.xsd）中，形式上类似于外部DTD
* 一个XML文档可引用一个定义了一种模式的XML Schema +遵循某个特定XML Schema模式的XML文档称为该XML Schema的一个实例（Instance）文档
* `<Schema>`声明
* \`\`\`是XML Schema的根元素
* 在`<Schema>`中声明命名空间信息和文档中声明的默认值
* 还可插入版本属性

```
<schema targetNamespace="URL" attributeFormDefault="qualified or unqualified" elementFormDefault="qualified or unqualified" version="version number">
```

\*　XML Schema的命名空间

* 常用三个形式之一

```
<schema xmlns=“http://www.w3.org/2001/XMLSchema”>
<xs:schema xmlns:xs=“http://www.w3.org/2001/XMLSchema”>
<xsd:schema xmlns:xsd=“http://www.w3.org/2001/XMLSchema”>
```

* XML Schema推荐标准自身使用xs前缀
* 目标命名空间
* XML Schema主要用于声明词汇（Vocabulary
* 词汇由targetNamespace属性指定的一个命名空间来标识
* 不是所有的XML Schema定义都有一个targetNamespace属性
* 声明targetNamespace属性时，必需一个相匹配的命名空间声明

```
<Schema xmlns=“http://www.w3.org/2001/XMLSchema” targetNamespace=“http://www.example.com/name” xmlns:target=“http://www.example.com/name”>
```

```
<xs:Schema xmlns:xs=“http://www.w3.org/2001/XMLSchema” targetNamespace=“http://www.example.com/name” xmlns=“http://www.example.com/name”>
```

```
<?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">
```

* xmlns:xs="<http://www.w3.org/2001/XMLSchema表示schema中用到的声明和数据类型来自命名空间http://www.w3.org/2001/XMLSchema，其前缀为xs。>
* targetNamespace="<http://www.w3school.com.cn>" 表示schema定义的元素来自命名空间<http://www.w3school.com.cn>
* xmlns="<http://www.w3school.com.cn>" 表示默认命名空间<http://www.w3school.com.cn> +　elementFormDefault="qualified"表示任何XML实例文档所使用的且在此schema中声明过的元素必须被命名空间限定
* 元素和属性限定词 +　在XML实例文档中，元素和属性可以是限定的（qualified）或非限定的（unqualified）
* 如果一个元素或属性关联到一个命名空间，则是限定的
* 非限定元素没有关联的命名空间

```
<name xmlns=“http://www.example.com/name”>
    <first>John</first>
    <middle>Fitzgerald</middle>
    <last>Doe</last>
</name>
```

```
<n:name xmlns:n=“http://www.example.com/name”>
    <n:first>John</n:first>
    <n:middle>Fitzgerald</n:middle>
    <n:last>Doe</n:last>
</n:name>
```

```
<n:name xmlns:n=“http://www.example.com/name”>
    <first>John</first>
    <middle>Fitzgerald</middle>
    <last>Doe</last>
</n:name>
```

* XML Schema的默认格式是将限定与非限定元素组合使用
* 使用elementFormDefault和arrtibuteFormDefault指定元素的限定方式，默认限定值都是unqualified
  * XML实例文档中的全局元素声明必须在XML实例文档中受到限定，大多数文档中应该限定文档的全部元素，即总是把elementFormDefault设置为qualified
  * XML文档的大多数属性都是非限定的，则一般保持attributeFormDefault的默认值，但全局声明的属性在XML实例文档中必须限定
* `<element>`声明
* 指定元素名和定义元素内容

```
<element 
    name=“name of the element”
    type=“global type”
    ref=“global element declaration”
    form=“qualified or unqualified”
    minOccurs=“non negative number”
    maxOccurs=“non negative number or ‘unbounded’”
    default=“default value”
    fixed=“fixed value”>
```

* 元素内容由type属性决定，元素类型分为简单类型和复杂类型
  * 简单类型不包含任何子元素和属性的元素，只包含文本内容，或者为不包含属性的空元素（文本内容为空)
  * 复杂类型包含子元素和/或属性的元素（其中属性的声明包含在元素的复杂类型定义中）
* 主要可用两种方法指定元素类型
  * 创建一个局部类型
  * 使用一个全局类型
* 还可通过引用一个全局元素声明重用已有的元素声明，引用时不必指定类型
* 全局与局部
* XML Schema声明可分为两类
  * 全局声明（Global Declaration）作为元素的直接子元素声明，可以在整个XML Schema中重用
  * 局部声明（Local Declaration）没有元素作为其直接双亲，并只能在指定的上下文内使用

```
<?xml version=“1.0”?>
<schema xmlns=“http://www.w3.org/2001/XMLSchema”     
    xmlns:target=“http://www.example.com/name” 
    targetNamespace=“http://www.example.com/name” 
    elementFormDefault=“qualified”>
    <element name=“name”>
        <complexType>
            <sequence>
                <element name=“first” type=“string”/>
                <element name=“middle” type=“string”/>
                <element name=“last” type=“string”/>
            </sequence>
            <attribute name=“title” type=“string”/>
        </complexType>
    </element>
</schema>
```

```
+ `<element name=“name”>`为全局声明（元素）
+  `<element name=“first” type=“string”/><element name=“middle” type=“string”/><element name=“last” type=“string”/>`为局部声明（元素）
```

```
<Schema xmlns=“http://www.w3.org/2001/XMLSchema” 
    xmlns:target=“http://www.example.com/name” 
    targetNamespace=“http://www.example.com/name” 
    elementFormDefault=“qualified”>
    <complexTypename=“NameType”>
        <sequence>
            <element name=“first” type=“string”/>
            <element name=“middle” type=“string”/>
            <element name=“last” type=“string”/>
        </sequence>
        <attribute name=“title” type=“string”/>
    </complexType>
    <element name=“name” type=“target:NameType”/>
</Schema> 
```

```
+ `<complexTypename=“NameType”>`为全局声明（元素）
+ `<element name=“name” type=“target:NameType”/>`为全局声明（类型）
```

* 创建局部类型，只需在元素中插入类型声明，作为元素声明的孩子
* 同一个元素声明，`<complexType>`和`<simpleType>`不能同时存在

```
<element name=“name”>
    <complexType>
        <sequence>
            <element name=“first” type=“string”/>
            <element name=“middle” type=“string”/>
            <element name=“last” type=“string”/>
        </sequence> <attribute name=“title” type=“string”/>
    </complexType>
</element>
```

```
<element name=“name”>
    <simpleType>
        <restriction base=“string”> 
            <enumeration value=“Home”/>
            <enumeration value=“Work”/>
            <enumeration value=“Cell”/>
            <enumeration value=“Fax”/>
        </restriction>
    </simpleType>
</element> 
```

* 对相同内容的元素，可使用全局类型避免重复声明局部类型
* 在元素声明中通过类型名引用一个全局类型 `<element name=“first” type=“string”/>` 全局类型（内置数据类型string）
* 自定义全局声明并引用

```
<Schema xmlns=“http://www.w3.org/2001/XMLSchema” 
    xmlns:target=“http://www.example.com/name” 
    targetNamespace=“http://www.example.com/name” 
    elementFormDefault=“qualified”>
    <complexTypename=“NameType”>
        <sequence>
            <element name=“first” type=“string”/>
            <element name=“middle” type=“string”/>
            <element name=“last” type=“string”/>
        </sequence>
        <attribute name=“title” type=“string”/>
    </complexType>
    <element name=“name” type=“target:NameType”/>
</Schema>
```

```
+ `<element name=“name” type=“target:NameType”/>`全局类型仍然是目标命名空间的一部分
```

```
<xs:schemaxmlns:xs=“http://www.w3.org/2001/XMLSchema” 
    xmlns=“http://www.example.com/name” 
    targetNamespace=“http://www.example.com/name” 
    elementFormDefault=“qualified”>
    <xs:complexTypename=“NameType”>
        <xs:sequence>
            <xs:elementname=“first” type=“xs:string”/>
            <xs:elementname=“middle” type=“xs:string”/>
            <xs:elementname=“last” type=“xs:string”/>
        </xs:sequence>
        <xs:attributename=“title” type=“xs:string”/>
    </xs:complexType>
    <xs:elementname=“name” type=“NameType”/>
</xs:schema>
```

```
+ `<xs:elementname=“name” type=“NameType”/>`目标命名空间没有前缀
```

* 自定义全局声明并引用
  * 当类型声明为元素的直接子元素时，才是一个全局类型
  * 给全局类型增加name属性，便于引用该全局类型
* 引用已存在的全局元素
  * 重用整个元素声明，不仅仅是类型声明
  * 引用全局元素声明，只需加入一个ref属性，其值为全局元素名 `<element ref=“target:first”/>`
  * 引用全局元素声明时，不使用type属性和局部类型声明，在引用中使用`<element>`声明中的类型
  * XML Schema推荐标准允许有多个全局`<element>`声明，但XML实例文档中只允许有一个根元素
* 元素命名
* 使用name属性
* 遵循XML命名规则
* 不需指定命名空间

```
<element name=”first” type=“string”/>
<element name=”description” type=“string”/>
<element name=“2ndElement” type=”string”/>
<element name=“target:middle” type=”string”/>
```

* 元素的限定形式
* 使用form属性可覆盖元素限定形式的默认值
* 限定的元素在XML实例文档中必须有一个相应的命名空间前缀
* 元素没有form属性则使用中定义的elementFromDefault属性值
* 全局声明的元素都是限定的
* 基数（Cardinality)
* 基数表示某个元素在内容模型中出现的次数
* XML Schema通过最小出现次数（minOccurs）和最大出现次数（maxOccurs）属性设置基数
  * minOccurs和maxOccurs的默认值都是1，即元素默认必须出现且仅出现一次
  * minOccurs可为0，则元素为可选的
  * maxOccurs可为unbounded，则元素可出现无穷多次
  * 两个属性可同时出现，也可单独出现
  * maxOccurs>=minOccurs
* 全局元素不允许定义minOccurs和maxOccurs属性，但可在内容模型中引用元素时使用

```
<element name=“first” type=“string” minOccurs=“2” maxOccurs=“2”/>
<element ref=“target:first” maxOccurs=“10”/>
<element name=“location” “minOccurs=“0” maxOccurs=“unbounded”/>
```

* 默认值和固定值
* XML Schema可声明元素的默认值和固定值
* 声明默认值只能设置一个文本值
* 元素的内容模型如果有其他元素，则不允许设置默认值
* 设置默认值可确保其作为XML实例文档的一部分
* 使用default属性设置默认值
* 如果设置了默认值的元素不在XML实例文档中，或者已经有内容，则默认值不起作用

```
<element name=“last” type=“string” default=“Doe”/>
<last></last>
<last/>
<last>Doe</last>
```

* XML Schema中的元素和属性都可以有固定值
* 希望元素的值不变化则可设置固定值
* 使用fixed属性设置固定值
* 设置了固定值的元素，XML实例文档中元素的内容要与固定属性值匹配
* 如果设置了默认值的元素在XML实例文档没有内容，则解析器插入固定值

```
<element name=“version” type=“string” fixed=“1.0”/>
<version>1.0</version> <version></version> <version/> 
<version>2.0</vers
```

* 元素通配符（Wildcard）
* 不用显示声明就可以在XML Schema中包含某些元素，包括自身命名空间中声明的任一元素，或来自另一个命名空间中的任何元素

```
<any 
minOccurs=“non negative number” 
maxOccurs=“non negative number or unbounded” 
namespace=“allowable namespaces” 
processContents=“lax or skip or strict”>
```

```
<element name=“name”>
    <complexTypename=“NameType”>
        <sequence>
            <element ref=“target:first”/>
            <element ref=“target:middle”/>
            <element ref=“target:last”/>
            <!-- allow any element from any namespace -->
            <any namespace=“##any” processContents=“lax” minOccurs=“0” maxOccurs=“unbounded”/>
        </sequence>
        <attribute name=“title” type=“string”/>
    </complexType>
</element>
```

````
    <any 
        namespace=“##any”
        processContents=“lax”
        minOccurs=“0”
        maxOccurs=“unbounded”/>
```来自所有命名空间的元素都被定义为通配符的一部分

* 元素通配符（Wildcard）
 + 包含任何命名空间中的元素声明称为元素通配符
* 利用通配符可以把来自一个命名空间的任何一个元素插入到XML Schema中
* 使用<any>声明创建通配符
 + 只能出现在内容模型，不允许创建全局的<any>声明
 + 可以使用基数，控制通配符在实例文档中出现的次数
 + 通过processContents属性验证通配符元素
    + skip: 解析器将忽略XML实例文档中的所有通配符元素
    + lax: 如果解析器可访问通配符的XML Schema定义，则验证通配符元素；找不到定义则忽略
    + strict: 默认值，解析器验证通配符元素，如果找不到其XML Schema定义，则报告错误
 + 使用namespace属性控制元素来自哪个命名空间

|值|说明|
|-|-|
|##any|通配符包括了来自所有名称空间的元素|
|##other|通配符包括了除targetNamespace之外其他命名空间的元素|
|##targetNamespace|通配符指包括来自targetNamespace命名空间的元素|
|##local|通配符包括所有没有命名空间限定的元素|
|由命名空间URI组成的以空白符分隔的列表|通配符包括了来自命名空间列表的元素，列表可包括##targetNamespace和##local|
* `<complexType>`声明
 + 定义元素内容
`<complexType 
        mixed=“true or false” 
        name=“Name of complexType”>`
 + 全局`<complexType>`定义需要命名，局部不需要
````

\`\`\` \`\`\` \`\`\` + 使用mixed属性建立混合内容模型，同时插入文本和元素内容 \`\`\` \`\`\` \`\`\` Jeff is a developer & author for Beginning XML *4th edition* © 2006 Wiley Publishing.\
Jeff **loves** XML! \`\`\`为混合内容 \`\`\` \`\`\` \`\`\` John Smith \`\`\` + 空内容模型表明元素没有文本内容或子元素，在实例文档中必须是空元素 + + \`\`定义中可以包含\`\`声明 + 声明空元素时仍可插入\`\`声明 \`\`\` \`\`\` \`\`\` \`\`\` \`\`\` \`\`\` \* \`\`声明 + 定义可重用的组元素 + 全局声明必须被命名 + 符合XML命名规则，不含前缀 + 允许在内容模型中引用全局元素组 \`\`\` \`\`\` \`\` + 只能用来建立一个可重用的内容模型 + \`\`声明为某个元素或某一类元素定义内容 \`\`\` \`\`\` + \`\`\`\`引用可不包含子元素

* 内容模型
* 可使用`<complexType>`和`<group>`声明定义元素内容模型
* XML Schema提供比DTD更灵活的功能创建复杂内容模型
  * `<sequence>`, `<choice>`和`<all>`声明，全局声明的引用
  * 4种声明可采用多种方法定义某个类型的内容模型，每个声明可包含
    * 内部内容模型，元素声明和元素通配符
* `<sequence>`声明
* 确定元素在XML实例文档中出现的顺序

```
<sequence 
    minOccurs=“non negative number” 
    maxOccurs=“non negative number or unbounded”>
<sequence>
    <element name=“first” type=“string” minOccurs=“1”  maxOccurs=“unbounded”/>
    <element name=“middle” type=“string” minOccurs=“0” maxOccurs=“1”/>     
    <element name=“last” type=“string”/>
</sequence>

<first>John</first>
<middle>Fitzgerald Johansen</middle>
<last>Doe</last> 
```

* `<choice>`声明
* 类似DTD的选择组合，定义多个子声明，但在XML实例文档中只允许使用一个

```
<choice 
    minOccurs=“non negative number” 
    maxOccurs=“non negative number or unbounded”>
<choice> 
<element 
    name=“first”
    type=“string”
    minOccurs=“1”
    maxOccurs=“unbounded”/>
<element 
    name=“middle”
    type=“string”
    minOccurs=“0”
    maxOccurs=“1”/>
<element 
    name=“last”
    type=“string”/>
</choice>
* `<all>`声明
 + 表示内容模型中的元素可以按任意顺序出现，常用于内容已知，但顺序不确定的情况中
`<all minOccours="0 or 1" maxOccours="1">`
    + 必须是`<complexType>`定义的唯一内容模型声明，并且也是`<complexType>`的子声明
    + 只可包含`<element>`声明作为其子声明
    + 子声明可能每一个在XML实例文档中都出现1次（minOccurs和maxOccurs默认值为1）
 + 对`<all>`声明的限制能确保模式验证器能够容易理解并处理对应于<all>声明中XML Schema的实例文档 
```

\`\`\` John Fitzgerald Doe or John Doe Fitzgerald \* \`\`声明 + 属性声明与元素声明类似 \* 两种方法指定属性类型 + 创建一个局部类型 + 使用一个全局类型 \* 属性声明只限于简单类型，属性只包含文本内容 + 复杂类型用来定义包含属性或元素的类型 + 简单类型用来限制纯文本内容 \* 可通过引用全局属性声明来重用属性 + 属性类型已包括在全局属性声明中，不需在属性引用中指定 \`\`\` \`\`\` \* 创建局部类型 + 在属性中插入类型声明，作为\`\`的子元素 + 属性声明可以只包含一个\`\`定义 \`\`\` \`\`\` \* 使用全局类型 + 许多属性有相同类型的值，可建立全局\`\`来重用 + 属性声明中可通过名字引用全局类型 + 全局类型可以是XML Schema内置的数据类型之一，也可建立并引用自定义的全局类型 \` \`

```
<schema xmlns=“http://www.w3.org/2001/XMLSchema” 
    xmlns:contacts=“http://www.example.com/contacts” 
    targetNamespace=“http://www.example.com/contacts” 
    elementFormDefault=“qualified”>
    <simpleTypename=“KindType”>
        <!-- type information -->
    </simpleType>
    <element name=“phone”>
        <complexType>
            <!-- content model information -->
            <attribute name=“kind” type=“contacts:KindType”/>     
        </complexType>
    </element>
</schema> 
```

```
<xs:schema xmlns:xs=“http://www.w3.org/2001/XMLSchema”     
    xmlns=“http://www.example.com/contacts”     
    targetNamespace=“http://www.example.com/contacts” 
    elementFormDefault=“qualified”>     
    <xs:simpleTypename=“KindType”>
        <!-- type information -->
    </xs:simpleType>
    <xs:elementname=“phone”>
        <xs:complexType>
            <!-- content model information -->
            <xs:attributename=“kind” type=“KindType”/>
        </xs:complexType>
    </xs:element>
</xs:schema> 
```

* 引用一个已存在的全局属性
* 引用全局`<simpleType>`定义，可重用属性类型
* 经常需要重用整个属性声明，而不限于类型声明
* XML Schema允许在`<complexType>`定义中重用全局属性声明
  * 在`<attribute>`声明中插入ref属性，其值为全局属性名
  * 属性名必须用命名空间限定
  * 不使用type属性和局部类型声明，而使用被引用的`<attribute>`声明中的类型
  * 被全局声明的属性必须用XML实例文档中的命名空间限定，由于默认命名空间对属性不起作用，因此必须使用命名空间前缀来限定，会导致XML实例文档变得复杂与混乱`<attribute ref=“contacts:kind”/>`
* 命名属性
* 属性名必须符合XML命名规则
* XML Schema可感知命名空间，只需指定属性名，模式验证器可识别XML实例文档中使用的任何前缀
* 属性的限定形式
* 属性限定与元素限定功能类似，form属性可覆盖属性限定的默认值
* 一个限定的属性，在XML实例文档中必须有一个关联的命名空间
* 默认命名空间对XML实例文档中的属性不起作用，只能使用命名空间前缀来限定一个属性
* 如果没有定义form属性，则模式验证器使用attibuteFormDefault属性值，在中定义
  * 任何全局声明的属性都是限定（qualified）属性nnXML实例文档中常有非限定属性，故很少使用form
* 属性的使用
* 在`<attribute>`声明中使用use属性设定其在XML实例文档中的出现方式
* prohibited表明该属性不会出现在XML实例文档中
* 属性通配符和prohibited通常结合使用
* required表明该属性必须出现在XML实例文档中
* optional是use的默认值，表明该属性是可选的 +如果为属性声明定义了一个默认值，则use只能为optional
* 全局`<attribute>`声明不可以使用use
* 属性的默认值和固定值
* 使用default赋予默认值 `<attribute name=“kind” type=“contacts:KindType” default=“Home”/>`
  * 如果模式验证器发现元素没有kind属性，则插入该属性并将属性值设为Home
* 使用fixed赋予固定值
  * 如果属性存在固定值，则解析器检查属性值与固定值是否相同，不同则提示模式验证错误
  * 如果某属性在Schema中设置了固定值，而XML实例文档中其对应的元素没有该属性，则解析器插入该属性并赋予固定值 `<attribute name=“version” type=“string” fixed=“1.0”/>`
* 默认值或固定值必须与对应属性的类型相符
* 不能在同一个属性声明中同时使用默认值和固定值
* 属性通配符
* 包括来自一个命名空间的任何属性的声明称为属性通配符 `<anyAttributenamespace=“allowable namespaces” processContents=“lax or skip or strict”>`
  * `<anyAttribute>`只能出现在`<complexType>`或`<attrbuteGourp`>中，不能建立全局的`<anyAttribute>`声明
  * 可以插入namespace属性来控制属性可使用的命名空间
* 属性通配符 |namespace 属性允许值|说明| |-|-| |##any|包括来自所有命名空间的属性| |##other|包括除了targetNamespace之外其他命名空间的属性| |##targetNamespace|只包括来自targetNamespace命名空间的属性| |##local|包括所有没有命名空间限定的属性| |由命名空间URI组成的，以空白符分隔的列表|包括来自命名空间列表中的属性，列表可包括##targetNamespace和##local的属性|

```
<complexType>
    <anyAttributenamespace=“##local http://www.w3.org/XML/1998/namespace” processContents=“lax”/> </complexType> 
```

```
+ 包括任何非限定属性以及来自`http://www.w3.org/XML/1998/namespace`命名空间的属性
```

* 对于包含属性通配符声明的元素，模式验证器根据processContents的值验证XML实例文档
  * skip: 跳过元素中的所有通配符属性
  * lax: 不严格验证，如果验证器可以访问XML Schema，则对通配符属性进行验证
  * strict（默认值）或没有使用processContents属性: 对通配符属性进行验证，如果没有找到使用通配符属性的元素的全局XML Schema定义，则产生一个验证错误
* `<attributeGroup>`声明
* 用同一组属性描述多个元素，可建立一个能在`<complexType>`定义中重用的全局属性组 `<attributeGroupname=“name of global attribute group”>`
* 必须给全局`<attributeGroup>`声明定义name属性并指定合适的名字\`\`\` \<attributeGroupname=“ContactsAttributes”>

\`\`\` ＋ \`\`声明中允许有\`\`声明作为其子声明，还允许属性通配符和对全局\`\`和\`\`的引用，但不能递归引用自己 + 使用\`\`，可在\`\`中插入一个引用或\`\`全局声明 \* 用简单内容和属性创建元素 + 如果元素只包含简单内容和属性 + \`\`声明表明\`\`中不含子元素 + 可以有属性，但必须被定义为简单类型 + 使用\`\`声明可增加属性声明，扩展现有数据类型 + 该声明的base属性可引用任何全局\`\`类型 \`\`\` \`\`\` \`\`\` \`\`\`

* 数据类型
* 内置数据类型
* 用户自定义数据类型 ![](/files/LAjiVnlUXdjQ1Qaf1nm4) ![](/files/e938cbTLVMqV1OFpS2EM) ![](/files/opwvAX5q1UouuQg6aEq6) ![](/files/0F6D76pRrnZTAh0aJckc) ![](/files/pZ2AKlpziJAqHpN50UJM) ![](/files/CgCY6ZlsC03CgaXG4GpP) ![](/files/xQFAiLE3iGLKZRuYjWWI) ![](/files/CgtQWzg4OMG6oAF4R5HN) ![](/files/ygpgktWk7NKE7WmQmqji) ![](/files/JTP5O8qnXAeUtetVdntJ)

|                    | 字符串类型                                                                                                                                 |
| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------- |
| string             | string数据类型的取值可以是任意字符串，其中可以包含空格、LF、CR和制表符等空白字符。对于string数据类型，XML解析器将不会修改其内容                                                             |
| normalizedString   | normalizedString数据类型派生于string数据类型。normalizedString数据类型的值可以包含任意字符，但是XML解析器将删除其中的LF、CR和制表符等空白字符；换句话说，normalizedString数据类型是不包含上述特殊字符的字符串 |
| token              | token数据类型也是string数据类型的派生类型，其中可以包含任意字符，但是XML解析器将删除其中的LF、CR和制表符等空白字符、开头和结尾的空格，以及连续的空格                                                   |
| language           | 包含合法语言id字符串                                                                                                                           |
| Name               | 包含合法xml名称的字符串，可以包含命名空间前缀                                                                                                              |
|                    |                                                                                                                                       |
| NCName             | 包含合法 XML名称的字符串 ， 不可以包含命名空间前缀                                                                                                          |
| ID、IDREFS、NMTOKEN等 | 这些数据类型来自于DTD,在XML Schema中保留了这些数据类型，并且与DTD中的使用方式相同，这些类型只能用于元素的属性                                                                       |
|                    |                                                                                                                                       |
| ...                | ...                                                                                                                                   |

|                    | 数值类型                                                             |
| ------------------ | ---------------------------------------------------------------- |
| float              | IEEE的单精度32位浮点数                                                   |
| decimal            | 可以使用十进制数字表示的实数                                                   |
| integer            | 派生于decimal，限制条件是十进制整数                                            |
| long               | 派生于integer,限制条件是最大值为9220072036854775807、最小值为-9220072036854775807 |
| int                | 派生于long，限制条件是最大值为2147483647、最小值为-2147483648                      |
| nonPositiveInteger | 派生于integer,限制条件是最大值为0                                            |
| ...                | ...                                                              |

|                        | 日期、时间类型                                                                                                                                         |
| ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| data                   | 用于指定一个日期，具体格式为YYYY-MM-DD，其中：YYYY表示年：MM表示月；DD表示日。假如`<xsd:element name="start" type="xsd:date"/>`那么该元素可以为`<start>2002-09-24<start>`               |
| time                   | 用于指定一个时间，具体格式为：hh:mm:ss，其中：hh表示时；mm表示分；ss表示秒。假如`<xsd:element name="start" type="xsd:time"/>`那么该元素可以为`<start>09:00:00<start>`                    |
| datetime               | 用于指定一日期和时间，具体格式为YYYY-MM-DDThh:mm:ss。假如`<xsd:element name="startdate" type="xsd:dateTime"/>`那么该元素可以为`<startdate>2002-05-30T09:00:00</startdate>` |
| duration               | 指定一个时间间隔，具体格式为PnYnMnTnHnMnS,其中：P表示时间间隔（必需的）；nY表示年数；nM表示月数；以此类推                                                                                  |
|                        | 其他类型                                                                                                                                            |
| boolean                | 用于指定true或者false。合法的取值包括：true、false、1（表示true）、0（表示false）                                                                                         |
| base64Binary、hexBinary | 用于表示二进制格式的数据，base64Binary表示Base64编码的二进制数据，hexBinary表示十六进制编码的二进制数据。                                                                              |
| anyURI                 | 用于表示一个URI,如果其中包括空格，必须使用%20进行替换                                                                                                                  |

* 任何一种类型都可以用来限制元素和属性的内容

```
<element name=“latitude” type=“float”/>
<element name=“longitude” type=“float”/> 
```

* 用户自定义数据类型
  * 内置数据类型不能包括所有的数据类型
    * 合法但无效的数据值 kind=“Walkie-Talkie”
    * 使用`<simpleType>`定义建立一个新类型
* `<simpleType>`声明
* 可以建立用户自定义的数据类型
  * 必须以现有数据类型为基础
    * 内置的XML Schema数据类型
    * 另一个自定义数据类型
* 包括三个主要的派生类型
  * 约束（Restriction）类型
  * 列表（List）类型
  * 联合（Union）类型

`<simpleTypename=“name of the simpleType” final=“#all or list or union or restriction”>` `<restriction>`声明

* 最常见的`<simpleType>`派生类型
* 定义的派生类型是基类型的一个子集 `<restriction base="name of the simpleType you are deriving from">`
* 约束面（Facet）控制了XML Schema的全部简单类型
* 约束面是`<simpleType>`独有的
  * 通过定义现有类型的约束面，可以创建更多自定义约束类型
    * nonNegativeInteger由Integer派生，相当于将Integer的约束面minInclusive为0
  * 不是所有类型都使用每个约束面
  * 使用base属性定义约束类型
    * base属性值是一个对全局`<simpleType>`或内置数据类型的引用
* `<restriction>`声明

```
<attribute name=“kind”>
    <simpleType>
        <restriction base=“string”>
            <enumerationvalue=“Home”/>
            <enumerationvalue=“Work”/>
            <enumerationvalue=“Cell”/>
            <enumerationvalue=“Fax”/>
        </restriction>
    </simpleType>
</attribute> 
```

* 基类型string，用多个枚举约束面定义kind类型的允许值列表
* `<restriction>`声明 |约束面|描述| |-|-| |enumeration|定义一组合法的取值| |fractionDidits|指定最大的位数，必须大于或等于零| |length|指定字符串中字符或列表数据类型中项的数目，必须大于或等于零| |maxExclusive|指定数值类型值的上限（取值必须小于这个上限）| |manInclusive|指定数值类型值的上限（取值必须小于或等于这个上限）| |maxLength|指定字符串中字符或列表数据类型中项的最大数目，必须大于或等于零| |minExclusive|指定数值类型值的下限（取值必须大于这个上限）| |minInclusive|指定数值类型值的下限（取值必须大于或等于这个上限）| |minLength|指定字符串中字符或列表数据类型中项的最小数目，必须大于或等于零| |pattern|指定一个正则表达式，描述合法的字符序列| |totaIDigits|指定最大的位数，必须大于或等于零| |whiteSpace|指定如何处理空白字符（CR、LF、Space和Tab）|
* `<restriction>`声明
* 通过设置最大值或最小值，对数值类型取值的范围进行约束

```
<xsd:elementname="MyIntegerElement" type="MyInteger"/>
    <xsd:simpleTypename="MyInteger">
        <xsd:restrictionbase="xsd:integer">
            <xsd:minInclusivevalue="0"/>
            <xsd:maxInclusivevalue="100"/>
        </xsd:restriction>
    </xsd:simpleType>
    <xsd:elementname="MyIntegerElement"><xsd:simpleType>
    <xsd:restrictionbase="xsd:integer"><xsd:minInclusivevalue="0"/>
    <xsd:maxInclusivevalue="100"/></xsd:restriction>     
    </xsd:simpleType>
<xsd:element>
```

* 通过枚举，将取值空间约束为一组合法的取值

```
<xsd:simpleType><xsd:restrictionbase="xsd:string">
<xsd:enumerationvalue="Audi"/><xsd:enumerationvalue="Golf"/>
<xsd:enumerationvalue="BMW"/></xsd:restriction></xsd:simpleType>
```

* `<restriction>`声明
* 通过给定一个正则表达式，约束字符串内容的模式

```
<xsd:simpleType><xsd:restrictionbase="xsd:string">
<xsd:patternvalue="[a-z]"/></xsd:restriction></xsd:simpleType>
<xsd:simpleTypename="Telephone"><xsd:restrictionbase="xsd:string">
<xsd:patternvalue="(\d{4}-\d{8})|(\d{3}-\d{8})|(\d{4}-\d{7})"/>
</xsd:restriction> </xsd:simpleType>
```

* 约束文本内容中字符串的长度

```
<xsd:simpleType><xsd:restrictionbase="xsd:string">
<xsd:lengthvalue="8"/></xsd:restriction></xsd:simpleType>
<xsd:simpleType><xsd:restrictionbase="xsd:string">
<xsd:minLengthvalue="5"/><xsd:maxLengthvalue="8"/>
</xsd:restriction></xsd:simpleType>
```

* 约束文本内容中数值的位数和小数位数

```
<xsd:simpleType><xsd:restrictionbase="xsd:decimal">
<xsd:totalDigitsvalue="4"/><xsd:fractionDigitsvalue="2"/>
</xsd:restriction> </xsd:simpleType>
```

* 在通过约束派生简单数据类型时，必须注意取值空间的有效性
* 对于所有的约束方面，不允许在进行约束的同时扩大基本数据类型的值空间
* `<list>`声明
* 创建基于某个`<simpleType>`类型的列表项
* 列表内由空白符分隔，则列表本身不能包含空白符
* 包含空白符的类型不能作为itemType，则itemType属性本身不能为列表
* 用itemType属性可定义列表项的类型
* 属性值是对全局`<simpleType>`或内置数据类型的引用
* 该引用是一个命名空间限定的值，需要使用前缀
* 也可建立一个局部的`<simpleType>`定义说明itemType的内容 `<list itemType=“name of simpleTypeused for validating items in the list”>`