DIV CSS 佈局教程網

您现在的位置: DIV+CSS佈局教程網 >> 網頁腳本 >  >> XML學習教程 >> XML詳解
善用 XPath 2.0 與 XSLT 2.0:省下開發時間、精簡程式碼
編輯:XML詳解     

XPath 2.0 與 XSLT 2.0 最核心的新概念之一,就是「一切都是序列(sequence)」。在 XPath 1.0 與 XSLT 1.0 中,你通常得跟節點樹打交道:解析後的 XML 文件是一棵節點樹,包含文件節點及其所有後代;你可以靠它找到根元素及其全部後代元素、屬性與兄弟節點(XML 文件中根元素之外的所有註解或處理指令,都被視為根元素的兄弟節點)。

當你在 XPath 2.0 與 XSLT 2.0 中使用 XML 文件時,序列的用法就像 1.0 中的樹結構一樣。序列包含一個 item(文件節點),使用方式與從前無異;但現在你還能建立「原子值序列」。在稍後的範例應用程式中,你將管理一組錦標賽資料——一場由 16 支隊伍參加的單淘汰賽。清單 1 就是一個原子值序列的範例。

清單 1. 一個原子值序列

<xsl:variable name="seeds" as="xs:integer*">
 <xsl:sequence
 select="(1, 16, 8, 9, 5, 12, 4, 13, 6, 11, 3, 14, 7, 10, 2, 15)"/>
</xsl:variable>

這段程式碼定義了變數 $seeds。如你所料,新的 <xsl:sequence> 元素定義了 item 序列,此時的 item 是 XML Schema 的 xs:integer;而新的 as 屬性定義了變數的資料型別,星號(xs:integer*)表示序列含有零或多個整數。在 1.0 時代,你得建立 16 個不同的文字節點,再把它們聚合進一個變數;而在 2.0 中,序列可以當作一維數值陣列來使用,正好符合這個範例的需求。

序列有一些規則要遵守。首先,序列不能包含其他序列——若你把一個三元素序列與另一個三元素序列拼接,得到的是一個含六個元素的新序列。其次,序列允許節點與 item 混用,你可以打造一個同時含有清單 1 那種原子值、以及清單 2 中所有 <contestant> 元素的序列。

清單 2. 節點與原子值序列

<xsl:variable name="seeds" as="item()*">
 <xsl:for-each select="/bracket/contestants/contestant">
 <xsl:copy-of select="."/>
 </xsl:for-each>
 <xsl:sequence
 select="(1, 16, 8, 9, 5, 12, 4, 13, 6, 11, 3, 14, 7, 10, 2, 15)"/>
</xsl:variable>

$seeds 變數此時包含了所有競爭節點,以及先前使用的 16 個原子值。請注意,變數的型別是 item()*——每個 item 可以是節點或原子值,因此這個變數能容納任何東西。

搞懂了序列與 item 的基礎,接著來看 to 運算子,這也是 2.0 的新特性,讓你能選出一段連續的整數。例如,你可以建立清單 3 這樣的序列:

清單 3. 使用 to 運算子建立的整數序列

<xsl:variable name="range" as="item()*">
 <xsl:sequence select="1 to 16"/>
</xsl:variable>

這段程式碼建立的 $range 變數,含有從 1 到 16 的整數。在同一個應用中,你還可以把 to 當作迴圈機制,如清單 4 所示:

清單 4. 使用 to 運算子實作迴圈

<xsl:for-each select="1 to 32">
 <!-- 在這裡做點有用的事 -->
</xsl:for-each>

理解範例應用程式

在本文的範例應用中,你要為一場 16 支隊伍參加的單淘汰錦標賽管理賽事資料。如你所料,錦標賽資料以 XML 格式表示;你將打造一份 XSLT 2.0 樣式表,把 XML 資料轉換成 HTML 表格來顯示賽果。清單 5 展示了 XML 文件的格式。

清單 5. 含有錦標賽資料的 XML 文件

<?XML version="1.0" encoding="UTF-8"?>
<!-- tourney.XML -->
<bracket>
 <title>RSDC SMackdown</title>
 <contestants>
 <contestant seed="1" image="images/homerSimpson.png">Donuts</contestant>
 <contestant seed="2" image="images/caffeine.png">Caffeine</contestant>
 <contestant seed="3" image="images/fearlessFreep.png">Fearless Freep</contestant>
 <contestant seed="4" image="images/wmd.jpg">Weapons of Mass Destruction</contestant>
 <contestant seed="5" image="images/haroldPie.jpg">PIE</contestant>
 <contestant seed="6" image="images/adamAnt.png">Adam Ant</contestant>
 <contestant seed="7" image="images/georgeWBush.jpg">Misunderestimated</contestant>
 <contestant seed="8" image="images/sillyPutty.jpg">Silly Putty</contestant>
 <contestant seed="9" image="images/krazyGlue.jpg">Krazy Glue</contestant>
 <contestant seed="10" image="images/snoopDogg.png">Biz-Implification</contestant>
 <contestant seed="11" image="images/atomAnt.png">Atom Ant</contestant>
 <contestant seed="12" image="images/ajaxcan.png">AJax</contestant>
 <contestant seed="13" image="images/darthVader.jpg">Darth Vader</contestant>
 <contestant seed="14" image="images/nastyCanasta.png">Nasty Canasta</contestant>
 <contestant seed="15" image="images/jcp.png">Java Community Process</contestant>
 <contestant seed="16" image="images/andre.png">Andre the Giant</contestant>
 </contestants>
 <results>
 <result round="1" firstSeed="1" secondSeed="16" winnerSeed="1"/>
 <result round="1" firstSeed="8" secondSeed="9" winnerSeed="9"/>
 <result round="1" firstSeed="5" secondSeed="12" winnerSeed="5"/>
 <result round="1" firstSeed="4" secondSeed="13" winnerSeed="4"/>
 <result round="1" firstSeed="6" secondSeed="11" winnerSeed="11"/>
 <result round="1" firstSeed="3" secondSeed="14" winnerSeed="3"/>
 <result round="1" firstSeed="7" secondSeed="10" winnerSeed="10"/>
 <result round="1" firstSeed="2" secondSeed="15" winnerSeed="2"/>
 <result round="2" firstSeed="1" secondSeed="9" winnerSeed="1"/>
 <result round="2" firstSeed="5" secondSeed="4" winnerSeed="5"/>
 <result round="2" firstSeed="11" secondSeed="3" winnerSeed="3"/>
 <result round="2" firstSeed="10" secondSeed="2" winnerSeed="2"/>
 <result round="3" firstSeed="1" secondSeed="5" winnerSeed="1"/>
 <result round="3" firstSeed="3" secondSeed="2" winnerSeed="2"/>
 <result round="4" firstSeed="1" secondSeed="2" winnerSeed="2"/>
 </results>
</bracket>

在 <title> 元素中,你會看到錦標賽的名稱 RSDC SMackdown,它其實反映了 IBM Rational Software Developer Conference 某場會議的真實賽果。這份文件包含 16 個 <contestant> 元素,每個元素擁有名稱(文字內容)、一個 seed 與一張圖片。16 隊的錦標賽共有 15 場比賽,每場由一個 <result> 元素表示,各帶四組關聯資料:比賽發生的回合(round 屬性)、兩支隊伍的 seed(firstSeed 與 secondSeed),以及勝方的 seed(winnerSeed)。你的任務,就是把這份 XML 轉換成一個顯示賽果的 HTML 表格,如圖 1 所示。

圖 1. HTML 表格中的錦標賽結果

這個表格是 32 列 5 欄。你可以沿用 XSLT 1.0 的直覺做法,一次一列慢慢搭,如清單 6 所示。

清單 6. 一次一列地建構 HTML 表格

<!-- Row 1 -->
<tr>
 <td style="border: none; border-top: solid; border-right: solid;">
 <xsl:text>[1] </xsl:text>
 <xsl:value-of select="$contestants[@seed='1']/>
 </td>
 <td style="border: none;>
 &nbsp;
 </td>
 <td style="border: none;>
 &nbsp;
 </td>
 <td style="border: none;>
 &nbsp;
 </td>
 <td style="border: none;>
 &nbsp;
 </td>
</tr>
<!-- Row 2 -->
. . .

這種做法行得通,但樣式表會變得難以維護——每一列、每一欄都塞滿了重複的程式碼。主要的麻煩在於:輸出表格需要 32 列,每列的元素資料(<contestant> 或 <result>)來自 XML 文件,偏偏你並沒有 32 個元素可以迭代。你固然能寫 <xsl:for-each select="contestants/contestant|results/result">,但這些元素在表格中的顯示順序並不符合要求,而 XSLT 1.0 並未提供合適的工具來解決這個難題。

好在你可以重構程式碼來簡化樣式表。在樣式與儲存格內容之中藏著規律,而 XPath 2.0 與 XSLT 2.0 的新特性正好能讓你在這些規律上迭代。最終的樣式表,比(公認笨拙的)原始版本精簡了約 70%。動手之前,先來看看該怎麼重構。

重構(一):計算儲存格的樣式

重構的第一步,是把樣式資訊移到 CSS 樣式表中。如圖 2 所示,這個 HTML 表格有 5 種不同的儲存格樣式:None、MatchupStart、MatchupMiddle、MatchupEnd 與 Solid。

圖 2. HTML 表格中的儲存格邊界樣式

清單 7 展示了 CSS 程式碼的樣子。

清單 7. CSS 樣式表

.None { width: 20%; }
.MatchupStart { width: 20%;
 border: none; border-top: solid;
 border-right: solid; }
.MatchupMiddle { width: 20%;
 border: none; border-right: solid; }
.MatchupEnd { width: 20%;
 border: none; border-bottom: solid;
 border-right: solid; }
.Solid { width: 20%;
 border: solid; }

邊界樣式的運用,讓賽果一目了然:連接兩個儲存格的水平線,代表這兩位競爭者將彼此對決;用實線邊界標示的儲存格,則是該場比賽的勝方。仔細觀察,樣式表裡藏著明確的規律:對每一對競爭者而言,第一位之前的儲存格沒有邊界(None),兩位競爭者的儲存格帶有實線邊界(Solid),兩者之間的儲存格右側有邊界(MatchupMiddle),最後一位之後的儲存格同樣沒有邊界(None)。第一欄略有不同——因為第一欄的對戰組合彼此太靠近,所以第一位競爭者的儲存格帶上、右邊界(MatchupStart),第二位則帶下、右邊界(MatchupEnd)。

值得注意的是,每一欄中對戰組合的間距相當規律:第一欄的對手相距一個儲存格,第二欄相距三個,第三欄相距七個,第四欄相距十五個。每個間距都是「2 的某次方減一」,規律井然。

表格還有個通用規律:每一欄都由一組重複的儲存格構成。我把這五欄各自的「重複單元」大小稱為該欄的 period,分別為 4、8、16、32 與 64,每個重複單元都包含一對競爭者,以及它們之前、之間與之後的儲存格。

在每一欄中,計算時會用到兩個值:$period 代表重複單元的大小,$oneQuarter 則代表 period 的四分之一(把 $period div 4 存進變數,可讓程式碼更清爽)。表 1 整理了儲存格邊界樣式的通用規則。

表 1. HTML 表格中的儲存格邊界樣式

當 $row < $oneQuarter 或 $row > $period - $oneQuarter 時,對應樣式為 None(各欄的首尾空白儲存格);當 $row = $oneQuarter 時,第一欄為 MatchupStart、其餘欄為 Solid;當 $row > $oneQuarter 且 $row < $period - $oneQuarter 時,樣式為 MatchupMiddle;當 $row = $period - $oneQuarter 時,第一欄為 MatchupEnd、其餘欄為 Solid。

現在,你有了一種優雅的方式,能指出表格中任一個儲存格的樣式。只要給定列號與行號,這些公式就會發揮作用。

重構(二):計算儲存格的內容

當然,建立儲存格時也得放入合適的內容,而這同樣有規律可循。樣式為 None 或 MatchupMiddle 的儲存格沒有任何內容,也就是說,你只需為另外三種樣式找出對應的內容。

如表 1 所示,帶有內容的儲存格,其 $row 會等於 $oneQuarter 或 $period - $oneQuarter。對第一欄而言,你只要寫入 seed 與對應競爭者的名稱。比賽是依 seed 排名配對的,形成表 2 的對戰組合。

表 2. 比賽依 seed 排名配對

[1] 對 [16]、[8] 對 [9]、[5] 對 [12]、[4] 對 [13]、[6] 對 [11]、[3] 對 [14]、[7] 對 [10]、[2] 對 [15]。

這個配對結果意味著:若高 seed 的隊伍一路獲勝,那麼最高 seed 會一直對上最低 seed,次高 seed 對上次低 seed,依此類推。檢視 seed 的順序(1、16、8、9、5、12、4、13、6、11、3、14、7、10、2、15),你會發現它們正好與 $seeds 序列中的值一致。競爭者在第一欄中就是按這個順序顯示。

每隔一列顯示一位競爭者——第 1 列放序列中的第一個 seed,第 3 列放第二個,第 5 列放第三個,依此類推。規律是 ($row + 1) div 2 = $index:取行號、加 1、再除以 2,就得到該 seed 在 $seeds 序列中的索引。儲存格的內容,就是 seed 編號,後接具有該 seed 的競爭者名稱。

第一欄的內容到此搞定。如你所料,第 2 到第 5 欄要複雜一些——你不再查 <contestant> 元素,而是查 15 個 <result> 元素中的賽果。

第 2 欄包含第 1 回合的勝方,也就是要查 round="1" 的 <result> 元素。為簡化起見,第一場比賽(seed 1 對 seed 16)的勝方存在第一個 <result> 裡,第二場(seed 8 對 seed 9)存在第二個裡,依此類推。第二欄的勝方出現在第 2、6、10、14、18、22、26、30 列;規律是:第 2 列用第一個 <result>、第 6 列用第二個、第 10 列用第三個。因此,對這一欄而言,把行號加 2、再除以 4,就能得到正確的 <result round="1"> 位置。

第 3、4 欄以類似方式處理:第 3 欄的勝方出現在第 4、12、20、28 列(規律為加 4 再除以 8),第 4 欄的勝方出現在第 8、24 列(加 8 再除以 16)。第 5 欄只顯示一位競爭者——整場錦標賽的冠軍;當你位於第 16 列時,就從唯一的 <result round="4"> 元素中取出勝方。

歸納一下,找出所要值的位置,可以用 ($row + $oneQuarter) div ($oneQuarter * 2) 這個公式。透過重複模式遞增的大小,程式碼得以大幅簡化:對第一欄,算出來的位置是 seed 序列的索引;對其他欄,則是對應 <result> 元素的位置。

現在,你有了一種優雅的方式,能決定表格中每個儲存格的內容與樣式。只要給定行號與列號,你需要的資訊都能算出來。

發揮 XPath 2.0 與 XSLT 2.0 的威力

現在,你能用 2.0 的新技術簡化樣式表設計了。先從 to 運算子說起。若用程序式語言建表,你可能會寫出類似清單 8 的程式碼:

清單 8. 以程序式方法處理樣式表

for (int row=1; row<=32; row++)
 for (int column=1; column<=5; column++)
 // 在這裡建構表格中的每個儲存格

而在 XPath 2.0 與 XSLT 2.0 中,你用 <xsl:for-each> 取代程序式語言的 for 迴圈,如清單 9:

清單 9. 使用 to 運算子實作 for 迴圈

<xsl:for-each select="1 to 32">
 <xsl:variable name="outerIndex" select="."/>
 <tr>
 <xsl:for-each select="1 to 5">

這裡有個略顯棘手的地方要處理。在 1.0 中,<xsl:for-each> 會在每次迭代時更新「上下文」。例如當你寫 <xsl:for-each select="contestants/contestant">,上下文節點在每次迭代中都是最新的那個 <contestant>。但當你用 to 運算子迭代整數時,上下文 item(2.0 的用語)是未定義的。如清單 9 所示,你得先把外層 <xsl:for-each> 的目前值存起來,因為它在內層迴圈中取不到。

更麻煩的是,一旦上下文 item 未定義,你就無法從文件中選取節點。就算你知道自己在第 1 列第 1 欄,能從全域變數 $seeds 序列取出第一個 item,進而得知要去找 <contestant seed="1"> 元素,你也還是「無從找起」——即使寫下 /bracket/contestants/contestant[@seed='1'] 這樣的絕對 XPath 也沒用。因此,你得把需要用到的節點存成全域變數。清單 10 示範如何在需要時存取這些全域變數。

清單 10. 存放所需節點的全域變數

<xsl:variable name="results" select="/bracket/results"/>
<xsl:variable name="contestants" select="/bracket/contestants"/>

若要取得第 16 號 seed 競爭者的名稱,XPath 運算式為 $contestants/contestant[@seed="16"];存取 <result> 元素也類似,若要取第 2 回合第二場比賽的勝方,運算式為 $results/result[@round="2"][2]/@winnerSeed。清單 11 另外給出兩個有助於生成 HTML 表格的全域變數。

清單 11. 其他實用的全域變數

<xsl:variable name="periods" as="xs:integer*">
 <xsl:sequence select="(4, 8, 16, 32, 64)"/>
</xsl:variable>
<xsl:variable name="backgroundColors" as="xs:string*">
 <xsl:sequence
 select="('background: #CCCCCC;', 'background: #9999CC;',
 'background: #99CCCC;', 'background: #CC99CC;',
 'background: #CCCC99;')"/>
</xsl:variable>

這些變數分別存放每一欄的 period 值與背景顏色。要用時,只要把列號當作索引即可。

2.0 中另一項實用的增強,是 <xsl:function> 元素。我們在樣式表中建立兩個函式:cellStyle 與 getResults。前者回傳每個儲存格的邊界樣式,後者回傳一場比賽結果(若存在);兩者的參數都是儲存格的列號與行號。清單 12 是 cellStyle 函式。

清單 12. cellStyle 函式

<xsl:function name="bracket:cellStyle" as="xs:string">
 <xsl:param name="row" as="xs:integer"/>
 <xsl:param name="column" as="xs:integer"/>

 <xsl:variable name="period" as="xs:integer"
 select="subsequence($periods, $column, 1)"/>
 <xsl:variable name="oneQuarter" as="xs:integer"
 select="$period div 4"/>
 <xsl:variable name="lastColumn" as="xs:boolean"
 select="$oneQuarter = count($contestants/contestant)"/>
 <xsl:variable name="position" select="$row mod $period"/>

 <xsl:value-of
 select="if ($position = $oneQuarter) then
 (if ($column = 1) then 'MatchupStart'
 else 'Solid')
 else if ($position = $period - $oneQuarter) then
 (if ($column = 1) then 'MatchupEnd'
 else 'Solid')
 else if ($lastColumn) then 'None'
 else if ($position &lt; $oneQuarter or
 $position &gt; $period - $oneQuarter) then 'None'
 else 'MatchupMiddle'"/>
</xsl:function>

在決定儲存格樣式前,得先算出四個變數:從全域變數 $periods 取出 $period;$oneQuarter 就是 $period div 4;布林值 $lastColumn 直接把 $oneQuarter 與參賽者數量相比,若相等就代表正在處理最後一欄;最後,$position 表示目前列在這個模式中(重複單元內)的位置。也就是說,對第 1、2 欄而言,表格第 9 列是重複單元的第一列。用「列在模式中的位置」來判斷樣式即可。

XPath 2.0 與 XSLT 2.0 提供了 if 運算子,形式為「一個運算式(放在括號中),後接 then 與 else」,而這一切都寫在 <xsl:value-of> 的 select 屬性裡。本例中,你用這個運算式取代冗長的 <xsl:choose>;因為邏輯單純,這樣寫很乾脆,但若邏輯更複雜,改用 <xsl:choose> 反而更好維護——代價是得寫更多程式碼。

關於 <xsl:function> 的語法,有兩點提醒:其一,你得為函式宣告新的命名空間,如此一來,當你在 XPath 運算式中呼叫 bracket:cellStyle() 時,命名空間才會告訴 XSLT 2.0 處理器如何找到它;其二,用 as="xs:string" 屬性表明這個函式回傳一個字串——也就是 <xsl:value-of> 輸出的五個樣式名稱之一。

getResults 函式稍微複雜些,但也沒複雜到哪去,如清單 13 所示。

清單 13. getResults 函式

<xsl:function name="bracket:getResults" as="xs:string">
 <xsl:param name="row" as="xs:integer"/>
 <xsl:param name="column" as="xs:integer"/>

 <xsl:variable name="period" as="xs:integer"
 select="subsequence($periods, $column, 1)"/>
 <xsl:variable name="oneQuarter" as="xs:integer"
 select="$period div 4"/>
 <xsl:variable name="position" select="$row mod $period"/>

 <xsl:choose>
 <xsl:when test="$position = $oneQuarter
 or
 $position = $period - $oneQuarter">
 <xsl:variable name="round" select="$column - 1"/>
 <xsl:variable name="index"
 select="($row + $oneQuarter) div ($oneQuarter * 2)"/>
 <xsl:variable name="currentSeed"
 select="if ($column = 1) then
 subsequence($seeds, $index, 1)
 else
 $results/result[@round=$round][$index]/@winnerSeed"/>
 <xsl:choose>
 <xsl:when test="string-length(string($currentSeed))">
 <xsl:value-of
 select="concat('[', $currentSeed, '] ',
 $contestants/contestant[@seed=$currentSeed])"/>
 </xsl:when>
 <xsl:otherwise>
 <xsl:text>&#160;</xsl:text>
 </xsl:otherwise>
 </xsl:choose>
 </xsl:when>
 <xsl:otherwise>
 <xsl:text>&#160;</xsl:text>
 </xsl:otherwise>
 </xsl:choose>
</xsl:function>

使用的參數與先前相同。這裡要對第一欄做點特殊處理——該欄資料來自 <contestant> 元素,其他欄則來自 <result> 元素。與 cellStyle 一樣,你會算出 $period 與 $position,並用 $oneQuarter 變數簡化公式。

如果儲存格裡是競爭者,還得再算三個變數:$round 比列號少一(第 2 欄放的是第 1 回合的結果),$index 則依先前討論的公式算出。

要找到正確的資料,需分兩步。首先,設定 $currentSeed 變數:若是第一欄,就用新的 subsequence 函式從 $seeds 取出一個值;其他欄則從對應的 <result> 元素取出 winnerSeed 屬性。其次,除了第一欄寫法不同外,還得考慮 <result> 沒有勝方的情況(winnerSeed="")——此時回傳一個不中斷空格(&#160;)。XSLT 2.0 處理資料型別的方式,要求你先把 $currentSeed 轉成字串再測長度:長度為零就回傳不中斷空格,否則回傳 seed 與競爭者名稱。

最後要留意的是,這裡用了 <xsl:choose>。雖然任何邏輯都能用 XPath 的 if 表達,但硬寫會顯得笨拙;<xsl:choose> 雖略顯冗長,程式碼卻更清爽、更易讀。

設好所需的全域變數與函式後,樣式表的核心就顯得簡單而優雅,如清單 14 所示。

清單 14. 樣式表的核心

<xsl:for-each select="1 to 32">
 <xsl:variable name="outerIndex" select="."/>
 <tr>
 <xsl:for-each select="1 to 5">
 <td style="{subsequence($backgroundColors, ., 1)}"
 class="{bracket:cellStyle($outerIndex, .)}">
 <xsl:value-of
 select="bracket:getResults($outerIndex, .)"/>
 </td>
 </xsl:for-each>
 </tr>
</xsl:for-each>

你用兩個迴圈搭出 32 列 5 欄的表格。對每個儲存格而言,背景色依目前的列號決定,cellStyle 函式決定邊界樣式(class="x"),getResults 函式決定儲存格的值。

使用樣式表

如你所料,你需要一個 XSLT 2.0 處理器來跑這份樣式表。這裡我不重印整份樣式表,但你務必用 <xsl:stylesheet version="2.0"> 讓處理器以 2.0 模式執行。我強烈推薦 Michael Kay 的 Saxon 處理器——Kay 博士正是 XSLT 2.0 規範的編輯,而 Saxon 在制定規範的過程中某種程度上就是個測試案例。若你使用 Saxon,可用下列指令,透過樣式表 results-html.xsl 轉換 XML 檔 tourney.XML,並把輸出寫進 results.html:

Java net.sf.saxon.Transform -o results.html tourney.XML results-Html.xsl

為了展示樣式表的靈活性,試著取用只含部分賽果的 XML,再跑一次轉換。清單 15 展示了 <result> 元素的樣子。

清單 15. 帶有不完整錦標賽資料的 XML 文件

<?XML version="1.0" encoding="UTF-8"?>
<!-- incomplete-tourney.XML -->
<bracket>
. . .
 <results>
 <result round="1" firstSeed="1" secondSeed="16" winnerSeed="1"/>
 <result round="1" firstSeed="8" secondSeed="9" winnerSeed="9"/>
 <result round="1" firstSeed="5" secondSeed="12" winnerSeed="5"/>
 <result round="1" firstSeed="4" secondSeed="13" winnerSeed="4"/>
 <result round="1" firstSeed="6" secondSeed="11" winnerSeed="11"/>
 <result round="1" firstSeed="3" secondSeed="14" winnerSeed="3"/>
 <result round="1" firstSeed="7" secondSeed="10" winnerSeed="10"/>
 <result round="1" firstSeed="2" secondSeed="15" winnerSeed="2"/>
 <result round="2" firstSeed="" secondSeed="" winnerSeed=""/>
 <result round="2" firstSeed="" secondSeed="" winnerSeed=""/>
 <result round="2" firstSeed="" secondSeed="" winnerSeed=""/>
 <result round="2" firstSeed="" secondSeed="" winnerSeed=""/>
 <result round="3" firstSeed="" secondSeed="" winnerSeed=""/>
 <result round="3" firstSeed="" secondSeed="" winnerSeed=""/>
 <result round="4" firstSeed="" secondSeed="" winnerSeed=""/>
 </results>
</bracket>

清單 15 代表第一回合結束後的錦標賽狀態:第 2、3、4 回合所有 <result> 的 winnerSeed 都是空的。儘管如此,樣式表仍生成了正確的對戰樹,如圖 3 所示。

圖 3. 不完整錦標賽的對戰樹

結語

本文展示了 XPath 2.0 與 XSLT 2.0 的許多新特性。在範例應用中,你把一份笨拙的樣式表重構為更精簡、更易維護的程式碼。過程中有部分工作在於分析程式碼、找出規律,但若少了 to 運算子、<xsl:function> 與 item 序列,要簡化樣式表將會非常困難。

最重要的是,你打造了一些通用函式,能處理任意數量的參賽者。舉例來說,要把樣式表改成能處理 32 隊的錦標賽,你只要改動 $seeds 與 $periods 序列,並用 select="1 to $rounds" 取代 select="1 to 5"(其中 $rounds 代表回合數)即可。當然,最理想的方案,是寫出能計算任意規模對戰樹的 XSLT 2.0 函式,自動處理回合數、seed 序列(32 隊時的配對為 1 對 32、2 對 31……)與各欄的 period——這個練習就留給讀者自行挑戰了。

問題的核心在於:你需要迭代表格的 32 列,而 XSLT 1.0 並未提供實際可行的做法;正是 XPath 2.0 與 XSLT 2.0 的新特性,讓這個難題得以迎刃而解。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved