當前位置：首頁 > 编程资源 > 编程问答 >内容正文

编程问答

XSD(Schema)教程

發布時間：2024/4/17 编程问答 27 豆豆

生活随笔收集整理的這篇文章主要介紹了 XSD(Schema)教程小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

http://www.cnblogs.com/caoxch/archive/2006/11/17/563856.html

XSD(Schema)教程 [轉]

schema教程

XML Schema是以XML語言為基礎的，它用于可替代DTD。
一份XML schema文件描述了XML文檔的結構
XML Schema語言也被稱為XML Schema Definition (XSD)（XML Schema定義）.
在本章教程你將學習如何讀取和建立XML Schemas，以及為什么XML Schemas比DTDs的功能更為強大，還有如何在你的程序中使用XML Schema語言

XML Schema 參考資料

你可以找到完整的有效的XML Schema元素

XML Schema 參考

Schema 介紹
w3pop.com / 2006-09-19

為何使用 XML Schemas?

XML Schema is an XML-based alternative to DTD.
XML Schema是以XML語言為基礎的，它用于可替代DTD。

An XML schema describes the structure of an XML document.
一份XML schema文件描述了XML文檔的結構。

The XML Schema language is also referred to as XML Schema Definition (XSD).
XML Schema語言也被稱為XML Schema Definition (XSD)（XML Schema定義）.

What You Should Already Know
你應該已經掌握的知識

Before you continue you should have a basic understanding of the following:
在繼續之前你應對以下內容有基本了解：

HTML / XHTML
XML and XML Namespaces
XML 和 XML 名稱空間
A basic understanding of DTD
對DTD有基本的了解

If you want to study these subjects first, find the tutorials on our Home page.
如果你想先學這些內容，請看我們主頁上的的學習教程

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

The purpose of an XML Schema is to define the legal building blocks of an XML document, just like a DTD.
XML Schema的作用是定義一份XML文檔的合法組件群，就像DTD的作用一樣

An XML Schema:
一份XML Schema

defines elements that can appear in a document
定義了可以出現在文檔里的元素
defines attributes that can appear in a document
定義了可以出現在文檔里的屬性
defines which elements are child elements
定義了哪些元素是子元素
defines the order of child elements
定義了子元素的順序
defines the number of child elements
定義了子元素的數量
defines whether an element is empty or can include text
定義了一個元素應是否能包含文本，或應該是空的
defines data types for elements and attributes
定義了元素和屬性的數據類型
defines default and fixed values for elements and attributes
定義了元素和屬性的默認值和固定值

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

We think that very soon XML Schemas will be used in most Web applications as a replacement for DTDs. Here are some reasons:
我們認為XML Schema很快就會替代DTD在大多數的網絡應用程序中被廣泛使用。

XML Schemas are extensible to future additions
XML Schema針對將來的額外內容是可擴展的
XML Schemas are richer and more powerful than DTDs
XML Schema內容比DTD豐富，作用也更大
XML Schemas are written in XML?
XML Schema是以XML語言編寫而成的
XML Schemas support data types
XML Schema支持數據類型
XML Schemas support namespaces?
XML Schema支持名稱空間（namespaces）

XML Schema is a W3C Standard
XML Schema是W3C定義的標準

XML Schema became a W3C Recommendation 02. May 2001.
XML Schema于2001年5月2日成為W3C推薦使用的標準

You can read more about the XML Schema standard in our W3C tutorial.
在W3C 教程中你能閱讀到更多關于XML Schema標準。

為何使用 XML Schemas?
w3pop.com / 2006-09-21

Schema 介紹如何制定 XSD

XML Schemas are much more powerful than DTDs.
XML Schema比DTD作用更加強大。

XML Schemas Support Data Types
XML Schema支持數據類型

One of the greatest strength of XML Schemas is the support for data types.
XML Schema的最好用的地方之一就是它支持數據類型

With support for data types:
支持數據類型所帶來的好處：

It is easier to describe allowable document content
更易于描述被允許的文檔內容
It is easier to validate the correctness of data
更易于檢驗數據的正確性
It is easier to work with data from a database
更易于與數據庫中的數據一起協同工作
It is easier to define data facets (restrictions on data)
更易于定義數據的使用面（關于數據的限制）
It is easier to define data patterns (data formats)
更易于定義數據樣式（數據格式）
It is easier to convert data between different data types
更易于把數據轉換成不同的數據類型

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

Another great strength about XML Schemas is that they are written in XML.
XML Schema另一個好處就是他們是用XML編寫成的。

Some benefits of that XML Schemas are written in XML:
用XML編寫的好處是：

You don't have to learn a new language
可以不需要再學一種新語言
You can use your XML editor to edit your Schema files
可以用XML編輯器來編輯Schema文件
You can use your XML parser to parse your Schema files
可以用XML解析器解析Schema文件
You can manipulate your Schema with the XML DOM
可以用XML DOM 處理Schema
You can transform your Schema with XSLT
可以用XSLT轉換Schema

XML Schemas Secure Data Communication
XML Schema安全數據通訊

When sending data from a sender to a receiver, it is essential that both parts have the same "expectations" about the content.
當數據由發送者被傳向接受者時，雙方對“數據內容理解的一致性”就顯得非常重要了

With XML Schemas, the sender can describe the data in a way that the receiver will understand.
在XML Schema里，發送者可以用接受者能夠理解的方式描述數據。

A date like: "03-11-2004" will, in some countries, be interpreted as 3.November and in other countries as 11.March.
像這樣格式的日期："03-11-2004"，一些國家會解釋成11月3日，而別的國家會解釋成3月11日

However, an XML element with a data type like this:
<date type="date">2004-03-11</date>
ensures a mutual understanding of the content, because the XML data type "date" requires the format "YYYY-MM-DD".
然而，一個有著像這樣的數據種類的XML元素：<date type="date">2004-03-11</date>，就確保了雙方都能理解其內容，因為XML數據類型的"date"要求規定為"YYYY-MM-DD"的格式。

XML Schemas are Extensible
XML Schema是可擴展的

XML Schemas are extensible, because they are written in XML.
因為XML Schema文件是由XML編寫的，所以它們是可擴展的。

With an extensible Schema definition you can:
Schema可擴展意味著你可以：

Reuse your Schema in other Schemas
在別的Schema文件里再次用到你的Schema
Create your own data types derived from the standard types
從標準的數據類型中派生出你自己的數據類型
Reference multiple schemas in the same document
在相同的文檔中參考多種Schema。

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

A well-formed XML document is a document that conforms to the XML syntax rules, like:
規范的XML文檔是符合XML語法規則的文檔，就像這樣：

it must begin with the XML declaration
? 開頭必須有XML聲明
it must have one unique root element
? 必須有一個獨特的根目錄元素
start-tags must have matching end-tags
? 開始標簽（start-tag）必須和結束標簽（end-tag）匹配
elements are case sensitive
? 元素是有大小寫區分的
all elements must be closed
? 元素必須有結束
all elements must be properly nested
? 所有的元素必須被合理嵌套
all attribute values must be quoted
? 所有屬性值必須寫在引號里
entities must be used for special characters
? 用特殊字符時必須用到實體

Even if documents are well-formed they can still contain errors, and those errors can have serious consequences.
即使文檔是規范的，它們也可能包含錯誤。這些錯誤可能會引起嚴重的后果。

Think of the following situation: you order 5 gross of laser printers, instead of 5 laser printers. With XML Schemas, most of these errors can be caught by your validating software.
試想下面的情況：你預定了 5羅（1羅=12打=144臺）激光打印機，而不是5臺打印機。在XML Schema文件里，大多數像這樣的錯誤會由檢驗軟件產生。

如何制定 XSD
w3pop.com / 2006-09-21

為何使用 XML Schemas? XSD - <schema> 元素

XML documents can have a reference to a DTD or to an XML Schema.
XML文檔能和一份DTD或XML Schema文件相關聯。

A Simple XML Document
一份簡單的XML文檔

Look at this simple XML document called "note.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文件

The following example is a DTD file called "note.dtd" that defines the elements of the XML document above ("note.xml"):
下面的例子是名為"note.dtd"的DTD文件，它定義了上述XML文檔("note.xml")的元素。

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

The first line defines the note element to have four child elements: "to, from, heading, body".
第一行定義了含有"to, from, heading, body".四個子元素的“note”元素。

Line 2-5 defines the to, from, heading, body elements to be of type "#PCDATA".
第2到5行定義了"#PCDATA". 類型的“to, from, heading, body”四個元素

An XML Schema
?一份XML Schema

The following example is an XML Schema file called "note.xsd" that defines the elements of the XML document above ("note.xml"):
下面的例子當中，一個名為"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>

The note element is a complex type because it contains other elements. The other elements (to, from, heading, body) are simple types because they do not contain other elements. You will learn more about simple and complex types in the following chapters.
Note元素是復合類型（complex type）因為它包含了其他元素，其他元素（to, from, heading, body）屬于簡單類型（simple type），因為它不包含其他元素。在下面幾章里你會學到更多關于簡單類型和復合類型的相關知識。

A Reference to a DTD
和DTD相關

This XML document has a reference to a 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相關

This XML document has a reference to an 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> 元素
w3pop.com / 2006-09-21

如何制定 XSD XSD Simple 元素

The <schema> element is the root element of every XML Schema.
<schema>元素是每個XML Schema文件的根元素。

The <schema> Element
<schema>元素

The <schema> element is the root element of every XML Schema:
<schema>元素是每份XML Schema文件的根元素。

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

The <schema> element may contain some attributes. A schema declaration often looks something like this:
<schema>元素也可以含有一些屬性，一個schema聲明經常寫成這樣：

The following fragment:
看下面的片段：

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

indicates that the elements and data types used in the schema come from the "http://www.w3.org/2001/XMLSchema" namespace. It also specifies that the elements and data types that come from the "http://www.w3.org/2001/XMLSchema" namespace should be prefixed with xs:
指明了在schema中使用的元素和數據種類來自http://www.w3.org/2001/XMLSchema名稱空間（namespace）。它也指定了來自"http://www.w3.org/2001/XMLSchema"名稱空間（namespace）的元素和數據種類必須帶前綴“xs:”

This fragment:
這個片段：

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

indicates that the elements defined by this schema (note, to, from, heading, body.) come from the "http://www.w3schools.com" namespace.
暗示了由這份schema(note, to, from, heading, body.)定義的元素來自"http://www.w3schools.com"名稱空間（namespace）

This fragment:
這個片段：

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

indicates that the default namespace is http://www.w3schools.com.
指明了默認名稱空間（namespace）是http://www.w3schools.com.

This fragment:
這個片段

elementFormDefault="qualified"

indicates that any elements used by the XML instance document which were declared in this schema must be namespace qualified.
指明了由這份schema聲明的XML實例文檔里用到的任何元素，都必須是有效的名稱空間（namespace qualified）。

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

This XML document has a reference to an 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"

specifies the default namespace declaration. This declaration tells the schema-validator that all the elements used in this XML document are declared in the "http://www.w3schools.com" namespace.
指定了默認的名稱空間（default namespace）聲明。這個聲明告訴schema-檢驗器：這份XML文檔里用到的所有元素都在http://www.w3schools.com的名稱空間（namespace）中聲明過。

Once you have the XML Schema Instance namespace available:
一旦你有了可以利用的XML Schema Instance的名稱空間（namespace）：

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

you can use the schemaLocation attribute. This attribute has two values. The first value is the namespace to use. The second value is the location of the XML schema to use for that namespace:
你可以用到SchemaLocation屬性。這個屬性有兩個值。第一個值是要用到的名稱空間（namespace）。第二個值是為名稱空間（namespace）指定了需要使用的XML schema的位置。

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

XSD Simple 元素
w3pop.com / 2006-09-21

XSD - <schema> 元素 XSD 屬性

XML Schemas define the elements of your XML files.
XML Schemas（XML公式）定義了XML文件的元素

A simple element is an XML element that contains only text. It cannot contain any other elements or attributes.
簡單元素是只含有文本的XML元素。它不可以含有其他元素或屬性

What is a Simple Element?
什么是簡單元素？

A simple element is an XML element that can contain only text. It cannot contain any other elements or attributes.
簡單元素是只含有文本的XML元素。它不可以含有其他元件或屬性

However, the "only text" restriction is quite misleading. The text can be of many different types. It can be one of the types included in the XML Schema definition (boolean, string, date, etc.), or it can be a custom type that you can define yourself.
但是，“只含文本”這個限定條件是非常容易引起誤解的，文本可以有很多的不同類型。它可以是XML Schema定義里的文本類型之一（邏輯值，字符串，日期，等等），也可以是自定義文本類型。

You can also add restrictions (facets) to a data type in order to limit its content, or you can require the data to match a specific pattern.
你可以通過給數據類型添加限定條件來限制它的內容，或者你可以要求數據與指定的式樣相匹配。

Defining a Simple Element
定義一個簡明元素

The syntax for defining a simple element is:
定義簡明元素的語法為：

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

where xxx is the name of the element and yyy is the data type of the element.
在這里， xxx是元素名稱，yyy是元素的數據類型

XML Schema has a lot of built-in data types. The most common types are:
XML Schema本身有很多數據種類。最常見的種類有：

xs:string
xs:字符
xs:decimal
xs: 小數
xs:integer
xs:整數
xs:boolean
xs:邏輯值
xs:date
xs:日期
xs:time
xs:時間

Example
例子

Here are some XML elements:
這里是一些XML元素

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

And here are the corresponding simple element definitions:
下面是相應的簡單元素定義

<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
簡單元素的默認值和固定值

Simple elements may have a default value OR a fixed value specified.
簡單元素也許會有指定的默認值或固定值

A default value is automatically assigned to the element when no other value is specified.
值沒有被指定時，屬性自動會設置成默認值

In the following example the default value is "red":
下面例子里默認值是"red":

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

A fixed value is also automatically assigned to the element, and you cannot specify another value.
固定值是也是自動分派給屬性的，并且，一旦有了固定值，你就不能指定其他值了。

In the following example the fixed value is "red":
下面例子里固定值是"red":

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

XSD 屬性
w3pop.com / 2006-09-21

XSD Simple 元素 XSD Restrictions/Facets

All attributes are declared as simple types.
所有屬性都是以簡單類型來聲明的。

What is an Attribute?
屬性是什么？

Simple elements cannot have attributes. If an element has attributes, it is considered to be of a complex type. But the attribute itself is always declared as a simple type.
簡單的元素沒有屬性。當元素含有屬性時，它會被認為是復合元素。但屬性本身總是被聲明為簡單類型。

How to Define an Attribute?
怎么樣定義屬性？

The syntax for defining an attribute is:
定義一項屬性的語法是：

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

where xxx is the name of the attribute and yyy specifies the data type of the attribute.
其中，xxx是屬性的名稱，yyy指定了屬性的數據類型

XML Schema has a lot of built-in data types. The most common types are:
XML Schema本身有很多數據類型。最常見的數據類型有：

xs:string
xs:字符串
xs:decimal
xs:小數
xs:integer
xs:整數
xs:boolean
xs:邏輯值
xs:date
xs:日期
xs:time
xs:時間

Example
例子

Here is an XML element with an attribute:
這是一個有屬性的XML元素：

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

And here is the corresponding attribute definition:
而這個相應的屬性定義：

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

Default and Fixed Values for Attributes
屬性的默認值和固定值

Attributes may have a default value OR a fixed value specified.
屬性也許有指定的默認值或固定值

A default value is automatically assigned to the attribute when no other value is specified.
值沒有被指定時，屬性自動會設成默認值

In the following example the default value is "EN":
下面例子里默認值是"EN":

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

A fixed value is also automatically assigned to the attribute, and you cannot specify another value.
固定值是也是自動分派給屬性的，并且，一旦有了固定值，你就不能指定其他值了。

In the following example the fixed value is "EN":
下面例子里固定值是"EN":

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

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

Attributes are optional by default. To specify that the attribute is required, use the "use" attribute:
默認時屬性是任意的，要指明屬性是必需的，須用到"use"屬性

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

Restrictions on Content
對內容的約束

When an XML element or attribute has a data type defined, it puts restrictions on the element's or attribute's content.
當XML元素或屬性有了已定義的數據類型，元素或屬性的內容會有約束

If an XML element is of type "xs:date" and contains a string like "Hello World", the element will not validate.
如果一個XML元素是"xs:date"類型，并包含著象"Hello World"的字符串，元素就不會進行檢驗

With XML Schemas, you can also add your own restrictions to your XML elements and attributes. These restrictions are called facets.?You can read more about facets in the next chapter.
你也可以用XML Schema給XML元素和屬性添加約束限制。這些約束稱為“面（facet）”。在下章里你可以讀到更多關于“面”的內容

XSD Restrictions/Facets
w3pop.com / 2006-09-21

XSD 屬性 XSD Complex 元素

Restrictions are used to define acceptable values for XML elements or attributes. Restrictions on XML elements are called facets.
約束用于給XML元素或屬性定義可接受的值，關于對XML元素的約束稱之為“面（facet）”

Restrictions on Values
對單個值的約束

The following example defines an element called "age" with a restriction. The value of age cannot be lower than 0 or greater than 120:
下面的例子給叫做"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
對一組值的約束

To limit the content of an XML element to a set of acceptable values, we would use the enumeration constraint.
為了限制XML元素的內容得到一組符合條件的值，我們會用到“列舉約束（enumeration constraint）”。

The example below defines an element called "car" with a restriction. The only acceptable values are: Audi, Golf, BMW:
下面的例子給叫做"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>

The example above could also have been written like this:
上面的例子也可以寫成這樣：

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

Note: In this case the type "carType" can be used by other elements because it is not a part of the "car" element.
注意：在這種情況下"carType"類型可以被其他元件所使用，因為它不是"car"元素的一部分

Restrictions on a Series of Values
對一系列值的約束

To limit the content of an XML element to define a series of numbers or letters that can be used, we would use the pattern constraint.
為了限制XML元件的內容以定義一系列可被使用的數字或字母，我們可以用“式樣約束（pattern constraints）”。

The example below defines an element called "letter" with a restriction. The only acceptable value is ONE of the LOWERCASE letters from a to z:
下面的例子給叫做"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>

The next example defines an element called "initials" with a restriction. The only acceptable value is THREE of the UPPERCASE letters from a to z:
接下來的例子給叫做"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>

The next example also defines an element called "initials" with a restriction. The only acceptable value is THREE of the LOWERCASE OR UPPERCASE letters from a to z:
下面的例子給叫做"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>

The next example defines an element called "choice" with a restriction. The only acceptable value is ONE of the following letters: x, y, OR z:
下面的例子給叫做"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>

The next example defines an element called "prodid" with a restriction. The only acceptable value is FIVE digits in a sequence, and each digit must be in a range from 0 to 9:
下面的例子給叫做"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
對一系列值的其他約束

The example below defines an element called "letter" with a restriction. The acceptable value is zero or more occurrences of lowercase letters from a to z:
下面的例子給叫做"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>

The next example also defines an element called "letter" with a restriction. The acceptable value is one or more pairs of letters, each pair consisting of a lower case letter followed by an upper case letter. For example, "sToP" will be validated by this pattern, but not "Stop" or "STOP" or "stop":
下面的例子也給叫做"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>

The next example defines an element called "gender" with a restriction. The only acceptable value is male OR female:
下面的例子也給叫做"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>

The next example defines an element called "password" with a restriction. There must be exactly eight characters in a row and those characters must be lowercase or uppercase letters from a to z, or a number from 0 to 9:
下面的例子也給叫做"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
對空白符的約束

To specify how whitespace characters should be handled, we would use the whiteSpace constraint.
為了指定空白符該怎樣被處理，我們可以用空白符約束

This example defines an element called "address" with a restriction. The whiteSpace constraint is set to "preserve", which means that the XML processor WILL NOT remove any white space 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>

This example also defines an element called "address" with a restriction. The whiteSpace constraint is set to "replace", which means that the XML processor WILL REPLACE all white space characters (line feeds, tabs, spaces, and carriage returns) with spaces:
下面的例子也給叫做"address"的元素定義了一個約束。空白符設為" replace "（替代），這意味著XML處理器會用空格替代所有的空白字符（換行符, 制表符, 空格符, 回車符)）

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

This example also defines an element called "address" with a restriction. The whiteSpace constraint is set to "collapse", which means that the XML processor WILL REMOVE all white space characters (line feeds, tabs, spaces, carriage returns are replaced with spaces, leading and trailing spaces are removed, and multiple spaces are reduced to a single space):
下面的例子也給叫做"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
對長度的約束

To limit the length of a value in an element, we would use the length, maxLength, and minLength constraints.
為了限制元素的長度值，我們會用length, maxLength, 和 minLength 約束。

This example defines an element called "password" with a restriction. The value must be exactly eight characters:
下面的例子給叫做"password"的元素定義了一個約束。值必須正好有8個字符：

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

This example defines another element called "password" with a restriction. The value must be minimum five characters and maximum eight characters:
下面的例子給叫做"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 元素
w3pop.com / 2006-09-21

XSD Restrictions/Facets XSD Complex 空元素

A complex element contains other elements and/or attributes.
一個復合元素（Complex Elements）包含其他元素和/或屬性

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

A complex element is an XML element that contains other elements and/or attributes.
復合元素（Complex Elements）是含有其他元素和/或屬性的XML元素

There are four kinds of complex elements:
有四種復合元素（Complex Elements）：

empty elements
空元素
elements that contain only other elements
只含有其他元素的元素
elements that contain only text
只含有文本的元素
elements that contain both other elements and text
含有文本和其他元素的元素

Note: Each of these elements may contain attributes as well!
注意：這些元素中的每一個也許還含有屬性!

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

A complex XML element, "product", which is empty:
一個空的復合XML元素"product"：

A complex XML element, "employee", which contains only other elements:
只含有其他元素的復合XML元素, "employee"

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

A complex XML element, "food", which contains only text:
只含有文本的復合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>

We can define a complex element in an XML Schema two different ways:
我們有兩種方法可以在一篇XML Schema里定義一個復合元素（Complex Elements）：

1. The "employee" element can be declared directly by naming the element, like this:
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>

If you use the method described above, only the "employee" element can use the specified complex type. Note that the child elements, "firstname" and "lastname", are surrounded by the <sequence> indicator. This means that the child elements must appear in the same order as they are declared. You will learn more about indicators in the XSD Indicators chapter.
如果你用了上面的方法，那么只有"employee"元素才可以用指定的復合類型。注意子元素"firstname" 和 "lastname",它們是被包圍在<sequence>“指示器”元素里的。這意味著子元素必須以它們被聲明的順序出現。在XSD指示器這章里你可以學到關于指示器更多內容。

2. The "employee" element can have a type attribute that refers to the name of the complex type to use:
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>

If you use the method described above, several elements can refer to the same complex type, like this:
如果你用上述方法，幾個元素指的可以是相同的復合類型，就像這樣：

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

You can also base a complex element on an existing complex element and add some elements, like this:
你也可以在現存的復合元素（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 空元素
w3pop.com / 2006-09-21

XSD Complex 元素 XSD 復合類型 - 純元素

An empty complex element cannot have contents, only attributes.
一個空的復合元素不能含有內容，只能含有屬性。

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

An empty XML element:
一個空的XML元素：

The "product" element above has no content at all. To define a type with no content, we must define a type that allows only elements in its content, but we do not actually declare any elements, like this:
上述"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>

In the example above, we define a complex type with a complex content. The complexContent element signals that we intend to restrict or extend the content model of a complex type, and the restriction of integer declares one attribute but does not introduce any element content.
上述例子中，我們定義了一個有復合內容的復合類型。復合內容的元素表示了我們想要約束或擴充的復合類型的內容模式。對整數的約束聲明了一個屬性，但并沒有介紹任何元素內容。

However, it is possible to declare the "product" element more compactly, like this:
但是，可以更加簡潔地聲明"product"元素，就像這樣：

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

Or you can give the complexType element a name, and let the "product" element have a type attribute that refers to the name of the complexType (if you use this method, several elements can refer to the same complex type):
或者你可以給complexType元素起個名稱，并讓"product"元素有個類型屬性，而且類型屬性引用的是complexType的名稱（如果你用這個方法，幾個元素可以引用相同的復合類型）：

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

XSD 復合類型 - 純元素
w3pop.com / 2006-09-21

XSD Complex 空元素 XSD 復合文字 - 純元素

An "elements-only" complex type contains an element that contains only other elements.
“只有元素（Elements-only）”復合類型含有一個只包含其他元素的元素

Complex Types Containing Elements Only
復合類型只含有元素

An XML element, "person", that contains only other elements:
一個XML元素, "person",只含有其他元素：

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

You can define the "person" element in a schema, like this:
你可以在一篇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>

Notice the <xs:sequence> tag. It means that the elements defined ("firstname" and "lastname") must appear in that order inside a "person" element.
注意<xs:sequence>標簽。這表示所定義的元素("firstname" 和 "lastname")必須在"person"元素里以那樣的次序出現。

Or you can give the complexType element a name, and let the "person" element have a type attribute that refers to the name of the complexType (if you use this method, several elements can refer to the same complex type):
或者你可以給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 復合文字 - 純元素
w3pop.com / 2006-09-21

XSD 復合類型 - 純元素 XSD 混合內容的復合類型

A complex text-only element can contain text and attributes.
一個復合只含文本元素（Complex Text-Only Elements）可以含有文本和屬性。

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

This type contains only simple content (text and attributes), therefore we add a simpleContent element around the content. When using simple content, you must define an extension OR a restriction within the simpleContent element, like this:
這種類型只含有簡單內容（文本和屬性），因此我們在內容周圍添加一個simpleContent元素，當用到簡單內容時，你必須在simpleContent元素里定義一個擴展或約束，就像這樣：

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

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

Tip: Use the extension/restriction element to expand or to limit the base simple type for the element.
提示：用extension/restriction元素擴展或限制元素的基本簡單類型（base simple type）。

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

The following example declares a complexType, "shoesize". The content is defined as an integer value, and the "shoesize" element also contains an attribute named "country":
下面的例子聲明了一個復合類型，"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>

We could also give the complexType element a name, and let the "shoesize" element have a type attribute that refers to the name of the complexType (if you use this method, several elements can refer to the same complex type):
我們可以給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 混合內容的復合類型
w3pop.com / 2006-09-21

XSD 復合文字 - 純元素 XSD 指示器復合類型

A mixed complex type element can contain attributes, elements, and text.
混合內容的復合類型元素（XSD Complex Types Element With Mixed Content ）可以含有屬性，元素，和文本。

Complex Types with Mixed Content
混合內容的復合類型

An XML element, "letter", that contains both text and other elements:
一個XML元素，"letter",既含有文本又含有其他元素：

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

The following schema declares the "letter" element:
下面的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>

Note: To enable character data to appear between the child-elements of "letter", the mixed attribute must be set to "true". The <xs:sequence> tag means that the elements defined (name, orderid and shipdate) must appear in that order inside a "letter" element.
注意：為了使字符數據能出現在"letter"子元件之間，mixed屬性必須設置為"true"。<xs:sequence>標簽指出了已定義的元素(name, orderid 和shipdate)在"letter"元素里必須以指定的順序出現

We could also give the complexType element a name, and let the "letter" element have a type attribute that refers to the name of the complexType (if you use this method, several elements can refer to the same complex type):
我們可以給這個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 指示器復合類型
w3pop.com / 2006-09-21

XSD 混合內容的復合類型 XSD <any> 元素

We can control HOW elements are to be used in documents with indicators.
用指示器（Indicators）我們可以控制文件中元素的使用方法（HOW TO USE）。

Indicators
指示器（Indicators）

There are seven indicators:
有7種指示器（Indicators）

Order indicators:
順序指示器（Indicators）

All
全部
Choice
選擇
Sequence
按順序

Occurrence indicators:
出現次數指示器（Indicators）：

maxOccurs
最多出現次數
minOccurs
最少出現次數

Group indicators:
組指示器（Indicators）：

Group name
組名
attributeGroup name
屬性組名稱

Order Indicators
順序指示器（Indicators）

Order indicators are used to define the order of the elements.
順序指示器（Indicators）用于指定元素的順序。

All Indicator
全部指示器（Indicators）

The <all> indicator specifies that the child elements can appear in any order, and that each child element must occur only once:
<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>

Note: When using the <all> indicator you can set the <minOccurs> indicator to 0 or 1 and the <maxOccurs> indicator can only be set to 1 (the <minOccurs> and <maxOccurs> are described later).
注意：用<all>指示器（Indicators）時你可以把<minOccurs>指示器（Indicators）設為0或1，<maxOccurs>指示器（Indicators）只能設為1（<minOccurs> 和 <maxOccurs> 我們后頭再說）

Choice Indicator
選擇指示器（Indicators）

The <choice> indicator specifies that either one child element or another can occur:
<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）

The <sequence> indicator specifies that the child elements must appear in a specific order:
<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）

Occurrence indicators are used to define how often an element can occur.
出現次數指示器（Indicators）用于定義一個元素可以出現的次數

Note: For all "Order" and "Group" indicators (any, all, choice, sequence, group name, and group reference) the default value for maxOccurs and minOccurs is 1.
注意：對所有的"Order"和"Group"指示器（Indicators）(any, all, choice, sequence，group name, 和 group reference)來說，maxOccurs 和 minOccurs的默認值都是1

maxOccurs Indicator
最多出現次數指示器（Indicators）

The <maxOccurs> indicator specifies the maximum number of times an element can occur:
最多出現次數指示器（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>

The example above indicates that the "child_name" element can occur a minimum of one time (the default value for minOccurs is 1) and a maximum of ten times in the "person" element.
上面的例子指明了"child_name"元素在"person"元素里最少出現1次（minOccurs的默認值為1），最多出現10次

minOccurs Indicator
最少出現次數指示器（Indicators）

The <minOccurs> indicator specifies the minimum number of times an element can occur:
最少出現次數指示器（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>

The example above indicates that the "child_name" element can occur a minimum of zero times and a maximum of ten times in the "person" element.
上面的例子指明了"child_name"元素在"person"元素里最少出現0次（minOccurs的默認值為1），最多出現10次

Tip: To allow an element to appear an unlimited number of times, use the maxOccurs="unbounded" statement:
提示：為使元件可以重復出現無數次，可以設置maxOccurs="unbounded"的狀態

A working example:
實際作用例子：

An XML file called "Myfamily.xml":
名為"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>

The XML file above contains a root element named "persons". Inside this root element we have defined three "person" elements. Each "person" element must contain a "full_name" element and it can contain up to five "child_name" elements.
上面XML文件含有一個名為"persons"的根元素，這個根元素里面里我們已經定義了3個"person"元素。每個"person"元素必須含有一個"full_name"元素，而且最多可有5個"child_name"元素。

Here is the schema file "family.xsd":
下面是名為"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）

Group indicators are used to define related sets of elements.
組指示器（Indicators）用于定義相關的元素組。

Element Groups
元素組

Element groups are defined with the group declaration, like this:
元素組要定義組聲明，像這樣：

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

You must define an all, choice, or sequence element inside the group declaration. The following example defines a group named "persongroup", that defines a group of elements that must occur in an exact sequence:
你必須在組聲明里定義一個all, choice,或sequence元素。下面的例子定義了一個名為"persongroup"的組，這個定義了一組元素必須以一定順序出現：

After you have defined a group, you can reference it in another definition, like this:
定義了一個組后，你可以在另一個組參考它，像這樣：

<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
屬性組

Attribute groups are defined with the attributeGroup declaration, like this:
屬性組定義有attributeGroup（屬性組）聲明，像這樣：

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

The following example defines an attribute group named "personattrgroup":
下面的例子定義了叫做"personattrgroup"的一個屬性組：

After you have defined an attribute group, you can reference it in another definition, like this:
定義了一個屬性組之后，你可以在別的定義里參考它，像這樣：

<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> 元素
w3pop.com / 2006-09-21

XSD 指示器復合類型 XSD <anyAttribute> 元素

The <any> element enables us to extend the XML document with elements not specified by the schema!
<any>元素可以使我們在XML文檔中添加沒有被schema 定義過的新元素從而擴充XML文檔。

The <any> Element
<any>元素

The <any> element enables us to extend the XML document with elements not specified by the schema.
<any>元素可以使我們在XML文檔中添加沒有被schema 定義過的新元素從而擴充XML文檔。

The following example is a fragment from an XML schema called "family.xsd". It shows a declaration for the "person" element. By using the <any> element we can extend (after <lastname>) the content of "person" with any element:
下面的例子是名為"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>

Now we want to extend the "person" element with a "children" element. In this case we can do so, even if the author of the schema above never declared any "children" element.
現在我們想在"person"元素中添加"children"元素，即使這篇schema的作者從未聲明過什么"children"元素，我們也可以做到。

Look at this schema file, called "children.xsd":
請看下面名為"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>

The XML file below (called "Myfamily.xml"), uses components from two different schemas; "family.xsd" and "children.xsd":
下面的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>

The XML file above is valid because the schema "family.xsd" allows us to extend the "person" element with an optional element after the "lastname" element.
上述XML文件是有效的，因為"family.xsd" schema允許我們在"person"元素里的"lastname"元素后面擴充一個任意元素。

The <any> and <anyAttribute> elements are used to make EXTENSIBLE documents! They allow documents to contain additional elements that are not declared in the main XML schema.
<any> 和<anyAttribute>元素是用于制造可擴展文檔的！它們允許文檔含有沒有在主要XML schema里聲明過的其它新元素。

XSD <anyAttribute> 元素
w3pop.com / 2006-09-21

XSD <any> 元素 XSD 元素替代

The <anyAttribute> element enables us to extend the XML document with attributes not specified by the schema!
<anyAttribute>元素可使我們在XML文檔中添加未被schema指定過的屬性

The <anyAttribute> Element
<anyAttribute>元素

The <anyAttribute> element enables us to extend the XML document with attributes not specified by the schema.
<anyAttribute>元素可使我們在XML文檔中添加未被schema指定過的屬性

The following example is a fragment from an XML schema called "family.xsd". It shows a declaration for the "person" element. By using the <anyAttribute> element we can add any number of attributes to the "person" element:
下面是名為"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>

Now we want to extend the "person" element with a "gender" attribute. In this case we can do so, even if the author of the schema above never declared any "gender" attribute.
現在我們想在"person"元素中添加"gender"屬性，即使這篇schema的作者從未聲明過什么"gender"屬性，我們也可以做到。

Look at this schema file, called "attribute.xsd":
請看下面名為"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>

The XML file below (called "Myfamily.xml"), uses components from two different schemas; "family.xsd" and "attribute.xsd":
下面的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>

The XML file above is valid because the schema "family.xsd" allows us to add an attribute to the "person" element.
上述XML文件是有效的，因為"family.xsd" schema允許我們在"person"元素里添加屬性

The <any> and <anyAttribute> elements are used to make EXTENSIBLE documents! They allow documents to contain additional elements that are not declared in the main XML schema.
<any> 和<anyAttribute>元素是用于擴展文檔的！它們允許文檔含有沒有在主要XML schema里聲明過的其它新元素。

XSD 元素替代
w3pop.com / 2006-09-21

XSD <anyAttribute> 元素 XSD 實例

With XML Schemas, one element can substitute another element.
用XML Schema，一個元素可替代另一元素。

Element Substitution
元素替代（Element Substitution）

Let's say that we have users from two different countries: England and Norway. We would like the ability to let the user choose whether he or she would like to use the Norwegian element names or the English element names in the XML document.
假設有兩個分別來自英國和挪威的使用者，我們很希望有能力能讓他或她進行選擇，在XML文檔里的元素名稱中選擇他們所擅長的語言，是英文呢？還是挪威文呢？

To solve this problem, we could define a substitutionGroup in the XML schema. First, we declare a head element and then we declare the other elements which state that they are substitutable for the head element.
為解決這個問題，我們在XML schema里定義了替代組。首先，我們聲明了一個標題元素，接著，我們聲明已說明可替代標題元素的其他元素

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

In the example above, the "name" element is the head element and the "navn" element is substitutable for "name".
在上面的例子里，"name"元素是標題元素，"navn"元素可以替代"name"。

Look at this fragment of an XML schema:
看下面的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"/>

A valid XML document (according to the schema above) could look like this:
一份有效的XML文檔（根據上述schema的XML文檔）應該像這樣：

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

or like this:
或者像這樣：

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

Blocking Element Substitution
關閉元素替代（Element Substitution）

To prevent other elements from substituting with a specified element, use the block attribute:
為了防止其他元素被已指定的元素替代（Element Substitution），可以用block屬性：

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

Look at this fragment of an XML schema:
看這段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"/>

A valid XML document (according to the schema above) looks like this:
一份有效的XML文檔（根據上述的schema的XML文檔）應該像這樣：

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

BUT THIS IS NO LONGER VALID:
但是這樣就不再有效了

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

Using substitutionGroup
使用替代組（substitutionGroup）

The type of the substitutable elements must be the same as, or derived from, the type of the head element. If the type of the substitutable element is the same as the type of the head element you will not have to specify the type of the substitutable element.
可替代元素類型應和標題元素的類型相同，或是從中派生出來的。如果可替代元素類型和標題元素的類型相同，你就不需要再指明可替代元素的類型了

Note that all elements in the substitutionGroup (the head element and the substitutable elements) must be declared as global elements, otherwise it will not work!
注意在可替代元素組里的所有元素（標題元素和可替代元素）必須聲明為“全域元素（global element）”，否則它是不會作用的！

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

Global elements are elements that are immediate children of the "schema" element! Local elements are elements nested within other elements.
“全域元素”是"schema"元素下面的直接子元素。“本地元素”是嵌套在別的元素里的元素。

XSD 實例
w3pop.com / 2006-09-21

XSD 元素替代 XSD 字符串數據類型

This chapter will demonstrate how to write an XML Schema. You will also learn that a schema can be written in different ways.
這章將示范如何寫一份XML Schema.你也會了解到可以使用不同的方法書寫schema。

An XML Document
一份XML文檔

Let's have a look at this XML document called "shiporder.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>

The XML document above consists of a root element, "shiporder", that contains a required attribute called "orderid". The "shiporder" element contains three different child elements: "orderperson", "shipto" and "item". The "item" element appears twice, and it contains a "title", an optional "note" element, a "quantity", and a "price" element.
上述XML文檔有根目錄元素"shiporder"，它有個必需的屬性叫做"orderid"，"shiporder"元素包含了三個不同的子元素："orderperson", "shipto" 和 "item"."item"元素出現了兩次，它包含了一個"title"元素，一個任意的"note"元素，一個"quantity"元素和一個"price"元素。

The line above: xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" tells the XML parser that this document should be validated against a schema. The line:
xsi:noNamespaceSchemaLocation="shiporder.xsd" specifies WHERE the schema resides (here it is in the same folder as "shiporder.xml").
上面的一行xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"，告訴了XML解析器這個文檔應該被一份schema檢驗。xsi:noNamespaceSchemaLocation="shiporder.xsd"指定了schema應該所在位置（這里它以"shiporder.xml"文件待在相同的文件夾里）。

Create an XML Schema
創建一篇XML Schema

Now we want to create a schema for the XML document above.
現在我們想要為上面的XML文檔創建一份schema

We start by opening a new file that we will call "shiporder.xsd". To create the schema we could simply follow the structure in the XML document and define each element as we find it. We will start with the standard XML declaration followed by the xs:schema element that defines a 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>

In the schema above we use the standard namespace (xs), and the URI associated with this namespace is the Schema language definition, which has the standard value of http://www.w3.org/2001/XMLSchema.
在上述schema里我們用了標準的名稱空間(xs),并且和這個名稱空間相聯系的URI是Schema語言定義，它有個標準值http://www.w3.org/2001/XMLSchema.

Next, we have to define the "shiporder" element. This element has an attribute and it contains other elements, therefore we consider it as a complex type. The child elements of the "shiporder" element is surrounded by a xs:sequence element that defines an ordered sequence of sub elements:
接下來，我們必須定義"shiporder”元素。這個元素有個屬性，并包含著其他的元素，因此我們把它看成是復合類型。"shiporder"元素的子元素由xs:sequence元素包圍著，xs:sequence元素定義了子元素一定順序的排列。

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

Then we have to define the "orderperson" element as a simple type (because it does not contain any attributes or other elements). The type (xs:string) is prefixed with the namespace prefix associated with XML Schema that indicates a predefined schema data type:
那么我們必須將"orderperson"元件定義為簡單類型（因為它不含有任何屬性或其它元素）。種類用名稱空間（namespace）的前綴使用與XML Schema相關的名稱空間前綴化，這里的XML Schema指明了一個前綴的Schema數據類型。

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

Next, we have to define two elements that are of the complex type: "shipto" and "item". We start by defining the "shipto" element:
接下來，我們必須定義兩個復合類型的元素，"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>

With schemas we can define the number of possible occurrences for an element with the maxOccurs and minOccurs attributes. maxOccurs specifies the maximum number of occurrences for an element and minOccurs specifies the minimum number of occurrences for an element. The default value for both maxOccurs and minOccurs is 1!
用schema，我們可以用maxOccurs（最多出現次數）和minOccurs（最少出現次數）屬性來定義一個元素的可能出現次數。maxOccurs指定了一個元素的最多出現次數，minOccurs指定了一個元素的最少出現次數。maxOccurs
和minOccurs的默認值都是1。

Now we can define the "item" element. This element can appear multiple times inside a "shiporder" element. This is specified by setting the maxOccurs attribute of the "item" element to "unbounded" which means that there can be as many occurrences of the "item" element as the author wishes. Notice that the "note" element is optional. We have specified this by setting the minOccurs attribute to zero:
現在我們可以來定義"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>

We can now declare the attribute of the "shiporder" element. Since this is a required attribute we specify use="required".
我們現在可以聲明"shiporder"元素的屬性了。因為這是項必須屬性，我們可以指定：use="required"。

Note: The attribute declarations must always come last:
注意:屬性聲明必須總是放在最后

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

Here is the complete listing of the schema file called "shiporder.xsd":
下面是"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

The previous design method is very simple, but can be difficult to read and maintain when documents are complex.
上面的設計方法非常簡單，但因為文件是復合（或復雜的，Complex）的，所以難于閱讀和利用。

The next design method is based on defining all elements and attributes first, and then referring to them using the ref attribute.
下面的設計方法是：先定義所有的元素和屬性，然后用ref屬性引用它們。

Here is the new design of the schema file ("shiporder.xsd"):
下面是schema文件的新設計方式("shiporder.xsd"):

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

Using Named Types
使用有名稱的類型

The third design method defines classes or types, that enables us to reuse element definitions. This is done by naming the simpleTypes and complexTypes elements, and then point to them through the type attribute of the element.
第三種設計方法定義了種類或類型，這使我們能重新用元素定義。通過給簡單類型和復合類型元素命名，接著在元素的種類屬性類型里指明它們的方法來做到這點。

Here is the third design of the schema file ("shiporder.xsd"):
這是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>

The restriction element indicates that the datatype is derived from a W3C XML Schema namespace datatype. So, the following fragment means that the value of the element or attribute must be a string value:
約束元素指出了這個數據類型是由一個W3C XML Schema名稱空間數據類型派生出來的。所以，下面的片段意味著元素或屬性的值必須是一個字符串的值

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

The restriction element is more often used to apply restrictions to elements. Look at the following lines from the schema above:
約束元素常常用于給元素添加約束。請看上述schema中的幾行：

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

This indicates that the value of the element or attribute must be a string, it must be exactly six characters in a row, and those characters must be a number from 0 to 9.
這指出了元素或屬性的值必須是字符串，而且必須是一排6個從0到9之間的數字。

XSD 字符串數據類型
w3pop.com / 2006-09-21

XSD 實例 XSD 日期數據類型

String data types are used for values that contains character strings.
字符串數據類型用于定義字符串的值的。

String Data Type
字符串數據類型

The string data type can contain characters, line feeds, carriage returns, and tab characters.
字符串數據類型包括字符，換行符，回車符，和制表符

The following is an example of a string declaration in a schema:
下面是關于字符在schema（XML公式）里的聲明方法的例子：

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

An element in your document might look like this:
你文檔中也許有這樣的元素：

<customer>John Smith</customer>

Or it might look like this:
它也許會是這樣：

<customer> John Smith </customer>

Note: The XML processor will not modify the value if you use the string data type.
注意：如果你用字符串數據類型，XML處理器將不會修改數值。

NormalizedString Data Type
規格化的字符串數據類型（NormalizedString Data Type）

The normalizedString data type is derived from the String data type.
規格化的字符串數據類型是從字符數據類型里派生出來的。

The normalizedString data type also contains characters, but the XML processor will remove line feeds, carriage returns, and tab characters.
規格化的字符串數據類型也包括字符，但XML processor會清除換行符，回車符和制表符

The following is an example of a normalizedString declaration in a schema:
下面的是關于一個規格化的字符串數據類型（normalizedString）在Schema中聲明方法的例子：

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

An element in your document might look like this:
你的文檔中也許有像這樣的元素：

<customer>John Smith</customer>

Or it might look like this:
或者它也許會是這樣：

<customer> John Smith </customer>

Note: In the example above the XML processor will replace the tabs with spaces.
注意：上述例子里XML處理器會用空格符替代制表符

Token Data Type
記號（token）數據類型

The token data type is also derived from the String data type.
記號數據類型也是從字符串數據類型里派生出來的

The token data type also contains characters, but the XML processor will remove line feeds, carriage returns, tabs, leading and trailing spaces, and multiple spaces.
記號數據類型也包括字符，但XML處理器會清除換行符，回車符，制表符，頭尾的空格，以及對于的空格。

The following is an example of a token declaration in a schema:
下面是關于符號（token）在schema中聲明的例子：

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

An element in your document might look like this:
你文檔中的元素也許像這樣：

<customer>John Smith</customer>

Or it might look like this:
或者它也有可能像這樣：

<customer> John Smith </customer>

Note: In the example above the XML processor will remove the tabs.
注意：在上述例子里，XML處理器會清除制表符

String Data Types
字符串數據類型

Note that all of the data types below derive from the String data type (except for string itself)!
要注意下面所有的數據類型都是從字符串數據類型里派生出來的（除了字符串本身）

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 日期數據類型
w3pop.com / 2006-09-21

XSD 字符串數據類型 XSD 小數數據類型

Date and time data types are used for values that contain date and time.
日期和時間數據類型（Date and time data types）用于定義日期和時間數據的。

Date Data Type
日期數據類型

The date data type is used to specify a date.
日期數據類型用于指定一個具體的日期

The date is specified in the following form "YYYY-MM-DD" where:
日期由下面的"YYYY-MM-DD"形式指定。

YYYY indicates the year
?YYYY指示年份
MM indicates the month
MM指示月份
DD indicates the day
DD 指示日期

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

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

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

An element in your document might look like this:
你文檔中的某個元素也許是這樣的：

Time Zones
時間區

To specify a time zone, you can either enter a date in UTC time by adding a "Z" behind the date - like this:
為指定一個時間區，你既可以通過在日期的后面加個"Z"訪問UTC時間格式的日期，就像這樣：

or you can specify an offset from the UTC time by adding a positive or negative time behind the date - like this:
也可以UTC時間后加、減一個時間值，就像這樣：

Time Data Type
時間數據類型

The time data type is used to specify a time.
時間數據類型用于指定一個時間

The time is specified in the following form "hh:mm:ss" where:
時間由下面的"hh:mm:ss"形式指定：

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 time declaration in a schema:
下面是schema（XML公式）里的時間聲明的例子

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

An element in your document might look like this:
你文檔中或許有這樣的元素：

Or it might look like this:
或者是這樣的：

Time Zones
時間區

To specify a time zone, you can either enter a time in UTC time by adding a "Z" behind the time - like this:
為指定一個時間區，你既可以通過在日期的后面加個"Z"訪問UTC時間格式的日期，就像這樣：

or you can specify an offset from the UTC time by adding a positive or negative time behind the time - like this:
也可以UTC時間后加、減一個時間值，就像這樣：

DateTime Data Type
日期時間數據類型（DateTime Data Type）

The dateTime data type is used to specify a date and a time.
日期時間數據類型用于指定一個日期和一個時間

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:
你文檔中或許有這樣的元素：

Or it might look like this:
或者是這樣的：

Time Zones
時間區

To specify a time zone, you can either enter a dateTime in UTC time by adding a "Z" behind the time - like this:
為指定一個時間區，你既可以通過在日期的后面加個"Z"訪問UTC時間格式的日期，就像這樣：

or you can specify an offset from the UTC time by adding a positive or negative time behind the time - like this:
也可以UTC時間后加、減一個時間值，就像這樣：

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指示秒數

The following is an example of a duration declaration in a schema:
下面是schema（XML公式）里的時間段聲明的例子

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

An element in your document might look like this:
你文檔中或許有這樣的元素：

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

Or it might look like this:
或者也可以像這樣：

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

Or it might look like this:
它也可以這樣：

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:
或者它會是可以這樣：

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之前添個負號

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 小數數據類型
w3pop.com / 2006-09-21

XSD 日期數據類型 XSD 邏輯值數據類型

Decimal data types are used for numeric values.
小數數據類型用于定義數值

Decimal Data Type
小數數據類型

The decimal data type is used to specify a numeric value.
小數數據類型用于指定一個數值

The following is an example of a decimal declaration in a schema:
下面是在schema（XML公式）里關于小數聲明的例子

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

An element in your document might look like this:
你文檔中的一個元素也許會像這樣：

Or it might look like this:
或者會像這樣：

Or it might look like this:
又或者像這樣：

Or it might look like this:
也可能這樣：

Or it might look like this:
當然，也會是這樣：

Note: The maximum number of decimal digits you can specify is 18.
注意：可以指定的小數位數最多是18位。

Integer Data Type
整數數據類型

The integer data type is used to specify a numeric value without a fractional component.
整數數據類型用于指定沒有小數部分的數值。

The following is an example of an integer declaration in a schema:
下面是的關于整數在schema里的聲明方法的例子。

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

An element in your document might look like this:
你文檔中也許有這樣的元素：

Or it might look like this:
或許是這樣：

Or it might look like this:
也可能是這樣：

Or it might look like this:
當然也會是這樣：

Numeric Data Types
數字數據類型

Note that all of the data types below derive from the Decimal data type (except for decimal itself)!
要注意的是下面所有的數據類型都是從小數數據類型里派生出來的（除了小數自身）

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 邏輯值數據類型
w3pop.com / 2006-09-21
XSD 小數數據類型 XML Schema總結
Other miscellaneous data types are boolean, base64Binary, hexBinary, float, double, anyURI, QName, and NOTATION.
其他混合的數據類型包括邏輯值（boolean），基本的64個二進制數、十六進位數、浮點精度小數、雙精度型數、anyURI、限定名稱（QName）和符號。

Boolean Data Type
邏輯值數據類型

The boolean data type is used to specify a true or false value.
邏輯型數據類型用于指定值為真或假。

The following is an example of a boolean declaration in a schema:
以下是在schema（XML公式）里有關邏輯聲明的例子

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

An element in your document might look like this:
你文檔里或許有這樣的元素：

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

Note: Legal values for boolean are true, false, 1 (which indicates true), and 0 (which indicates false).
注意：合法的邏輯值是真，假，1（指示真），0（指示假）

Binary Data Types
二進制數據類型

Binary data types are used to express binary-formatted data.
二進制數據用于表示二進制的數據

We have two 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）
The following is an example of a hexBinary declaration in a schema:
以下是關于十六進位數在schema里的聲明方法：

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

AnyURI Data Type
anyURI數據類型

The anyURI data type is used to specify a URI.
anyURI數據類型用于指定一個URI.

The following is an example of an anyURI declaration in a schema:
以下是關于anyURI在schema里的聲明方法：

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

An element in your document might look like this:
你文檔里也許有這個元素：

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

Note: If a URI has spaces, replace them with %20.
注意：如果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總結
w3pop.com / 2006-09-21

XSD 邏輯值數據類型 XML Schema 參考

XML Schema Summary
XML Schema總結

This tutorial has taught you how to describe the structure of an XML document.
這篇教程教你如何描述XML文檔的結構

You have learned how to use an XML Schema is to define the legal elements of an XML document, just like a DTD. We think that very soon XML Schemas will be used in most Web applications as a replacement for DTDs.
你已經學習了怎樣使用XML Schema（XML 公式），就是象DTD一樣給XML文檔定義合法元素。我們認為很快XML Schema（XML 公式）就會取代DTD而被大多數的網絡應用程序所使用。

You have also learned that the XML Schema language is very rich. Unlike DTDs, it supports data types and namespaces.
你已經知道了 XML公式語言是很豐富的。和DTD不同，它支持數據類型和名稱空間。

For more information on XML Schema, please look at our XML Schema reference.
想更多地了解XML Schema 的信息，請看我們的XML Schema 參考。

Now You Know XML Schema, What's Next?
現在你知道了XML Schema，那接著學什么呢？

The next step is to learn about WSDL.
下步是學習有關WSDL.

WSDL is a schema-based language for describing Web services and how to access them.
WSDL 是描述網絡服務以及描述怎樣訪問它們的一種以schema為基礎的語言

WSDL describes a web service, along with the message format and protocol details for the web service.
WSDL描述網絡服務，以及與網絡服務有關的信息格式和協議細節。

If you want to learn more about WSDL, please visit our WSDL tutorial.
想學習更多與WSDL有關的內容，請瀏覽我們的WSDL 教程.

XML Schema 參考
w3pop.com / 2006-09-21

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） (換行符、制表符、空格、回車符）是如何被處理的。

總結

以上是生活随笔為你收集整理的XSD(Schema)教程的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇： maven2——设置镜像篇
下一篇： xmlns:xsi=http://www

anyURI	?
base64Binary	?
boolean	?
double	?
float	?
hexBinary	?
NOTATION	?
QName	?

编程问答

XSD(Schema)教程

XSD(Schema)教程 [轉]

XML Schema 參考資料

Schema 介紹 w3pop.com / 2006-09-19

What You Should Already Know 你應該已經掌握的知識

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

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

XML Schema is a W3C Standard XML Schema是W3C定義的標準

為何使用 XML Schemas? w3pop.com / 2006-09-21

XML Schemas Support Data Types XML Schema支持數據類型

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

XML Schemas Secure Data Communication XML Schema安全數據通訊

XML Schemas are Extensible XML Schema是可擴展的

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

如何制定 XSD w3pop.com / 2006-09-21

A Simple XML Document 一份簡單的XML文檔

A DTD File 一份DTD文件

An XML Schema ?一份XML Schema

A Reference to a DTD 和DTD相關

A Reference to an XML Schema 和XML Schema相關

XSD - <schema> 元素 w3pop.com / 2006-09-21

The <schema> Element <schema>元素

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

XSD Simple 元素 w3pop.com / 2006-09-21

What is a Simple Element? 什么是簡單元素？

Defining a Simple Element 定義一個簡明元素

Example 例子

Default and Fixed Values for Simple Elements 簡單元素的默認值和固定值

XSD 屬性 w3pop.com / 2006-09-21

What is an Attribute? 屬性是什么？

How to Define an Attribute? 怎么樣定義屬性？

Example 例子

Default and Fixed Values for Attributes 屬性的默認值和固定值

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

Restrictions on Content 對內容的約束

XSD Restrictions/Facets w3pop.com / 2006-09-21

Restrictions on Values 對單個值的約束

Restrictions on a Set of Values 對一組值的約束

Restrictions on a Series of Values 對一系列值的約束

Other Restrictions on a Series of Values 對一系列值的其他約束

Restrictions on Whitespace Characters 對空白符的約束

Restrictions on Length 對長度的約束

Restrictions for Datatypes 對數據類型的約束

XSD Complex 元素 w3pop.com / 2006-09-21

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

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

How to Define a Complex Element 怎樣定義一個復合元素（Complex Elements）？

XSD Complex 空元素 w3pop.com / 2006-09-21

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

XSD 復合類型 - 純元素 w3pop.com / 2006-09-21

Complex Types Containing Elements Only 復合類型只含有元素

XSD 復合文字 - 純元素 w3pop.com / 2006-09-21

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

XSD 混合內容的復合類型 w3pop.com / 2006-09-21

Complex Types with Mixed Content 混合內容的復合類型

XSD 指示器復合類型 w3pop.com / 2006-09-21

Indicators 指示器（Indicators）

Order Indicators 順序指示器（Indicators）

Occurrence Indicators 出現次數指示器（Indicators）

Group Indicators 組指示器（Indicators）

XSD <any> 元素 w3pop.com / 2006-09-21

The <any> Element <any>元素

XSD <anyAttribute> 元素 w3pop.com / 2006-09-21

The <anyAttribute> Element <anyAttribute>元素

XSD 元素替代 w3pop.com / 2006-09-21

Element Substitution 元素替代（Element Substitution）

Blocking Element Substitution 關閉元素替代（Element Substitution）

Using substitutionGroup 使用替代組（substitutionGroup）

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

XSD 實例 w3pop.com / 2006-09-21

An XML Document 一份XML文檔

Create an XML Schema 創建一篇XML Schema

Divide the Schema 劃分Schema

Using Named Types 使用有名稱的類型

XSD 字符串數據類型 w3pop.com / 2006-09-21

String Data Type 字符串數據類型

NormalizedString Data Type 規格化的字符串數據類型（NormalizedString Data Type）

Token Data Type 記號（token）數據類型

String Data Types 字符串數據類型

Schema 介紹
w3pop.com / 2006-09-19

What You Should Already Know
你應該已經掌握的知識

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

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

XML Schema is a W3C Standard
XML Schema是W3C定義的標準

為何使用 XML Schemas?
w3pop.com / 2006-09-21

XML Schemas Support Data Types
XML Schema支持數據類型

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

XML Schemas Secure Data Communication
XML Schema安全數據通訊

XML Schemas are Extensible
XML Schema是可擴展的

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

如何制定 XSD
w3pop.com / 2006-09-21

A Simple XML Document
一份簡單的XML文檔

A DTD File
一份DTD文件

An XML Schema
?一份XML Schema

A Reference to a DTD
和DTD相關

A Reference to an XML Schema
和XML Schema相關

XSD - <schema> 元素
w3pop.com / 2006-09-21

The <schema> Element
<schema>元素

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

XSD Simple 元素
w3pop.com / 2006-09-21

What is a Simple Element?
什么是簡單元素？

Defining a Simple Element
定義一個簡明元素

Example
例子

Default and Fixed Values for Simple Elements
簡單元素的默認值和固定值

XSD 屬性
w3pop.com / 2006-09-21

What is an Attribute?
屬性是什么？

How to Define an Attribute?
怎么樣定義屬性？

Example
例子

Default and Fixed Values for Attributes
屬性的默認值和固定值

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

Restrictions on Content
對內容的約束

XSD Restrictions/Facets
w3pop.com / 2006-09-21

Restrictions on Values
對單個值的約束

Restrictions on a Set of Values
對一組值的約束

Restrictions on a Series of Values
對一系列值的約束

Other Restrictions on a Series of Values
對一系列值的其他約束

Restrictions on Whitespace Characters
對空白符的約束

Restrictions on Length
對長度的約束

Restrictions for Datatypes
對數據類型的約束

XSD Complex 元素
w3pop.com / 2006-09-21

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

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

How to Define a Complex Element
怎樣定義一個復合元素（Complex Elements）？

XSD Complex 空元素
w3pop.com / 2006-09-21

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

XSD 復合類型 - 純元素
w3pop.com / 2006-09-21

Complex Types Containing Elements Only
復合類型只含有元素

XSD 復合文字 - 純元素
w3pop.com / 2006-09-21

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

XSD 混合內容的復合類型
w3pop.com / 2006-09-21

Complex Types with Mixed Content
混合內容的復合類型

XSD 指示器復合類型
w3pop.com / 2006-09-21

Indicators
指示器（Indicators）

Order Indicators
順序指示器（Indicators）

Occurrence Indicators
出現次數指示器（Indicators）

Group Indicators
組指示器（Indicators）

XSD <any> 元素
w3pop.com / 2006-09-21

The <any> Element
<any>元素

XSD <anyAttribute> 元素
w3pop.com / 2006-09-21

The <anyAttribute> Element
<anyAttribute>元素

XSD 元素替代
w3pop.com / 2006-09-21

Element Substitution
元素替代（Element Substitution）

Blocking Element Substitution
關閉元素替代（Element Substitution）

Using substitutionGroup
使用替代組（substitutionGroup）

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

XSD 實例
w3pop.com / 2006-09-21

An XML Document
一份XML文檔

Create an XML Schema
創建一篇XML Schema

Divide the Schema
劃分Schema

Using Named Types
使用有名稱的類型

XSD 字符串數據類型
w3pop.com / 2006-09-21

String Data Type
字符串數據類型

NormalizedString Data Type
規格化的字符串數據類型（NormalizedString Data Type）

Token Data Type
記號（token）數據類型

String Data Types
字符串數據類型

Restrictions on String Data Types
對字符串數據類型的約束（Restrictions on String Data Types）

XSD 日期數據類型
w3pop.com / 2006-09-21

Date Data Type
日期數據類型

Time Zones
時間區