This book is primarily a practical reference book for professional
XSLT developers. It assumes no previous knowledge of the language,
and many developers have used it as their first introduction to
XSLT; however, it is not structured as a tutorial, and there are
other books on XSLT that provide a gentler approach for beginners.
The book does assume a basic knowledge of XML, HTML, and the
architecture of the Web, and it is written for experienced
programmers. There's no assumption that you know any particular
language such as Java or Visual Basic, just that you recognize the
concepts that all programming languages have in common. The book is
suitable both for XSLT 1.0 users upgrading to XSLT 2.0, and for
newcomers to XSLT. The book is also equally suitable whether you
work in the Java or .NET world. As befits a reference book, a key
aim is that the coverage should be comprehensive and authoritative.
It is designed to give you all the details, not just an overview of
the 20 percent of the language that most people use 80 percent of
the time. It's designed so that you will keep coming back to the
book whenever you encounter new and challenging programming tasks,
not as a book that you skim quickly and then leave on the shelf. If
you like detail, you will enjoy this book; if not, you probably
won't. But as well as giving the detail, this book aims to explain
the concepts, in some depth. It's therefore a book for people who
not only want to use the language but who also want to understand
it at a deep level. The book aims to tell you everything you need
to know about the XSLT 2.0 language. It gives equal weight to the
things that are new in XSLT 2.0 and the things that were already
present in version 1.0. The book is about the language, not about
specific products. However, there are appendices about Saxon (the
author's own implementation of XSLT 2.0), about the Altova XSLT 2.0
implementation, and about the Java and Microsoft APIs for
controlling XSLT transformations, which will no doubt be upgraded
to handle XSLT 2.0 as well as 1.0. A third XSLT 2.0 processor,
Gestalt, was released shortly before the book went to press, too
late to describe it in any detail. But the experience of XSLT 1.0
is that there has been a very high level of interoperability
between different XSLT processors, and if you can use one of them,
then you can use them all. In the previous edition we split XSLT
2.0 and XPath 2.0 into separate volumes. The idea was that some
readers might be interested in XPath alone. However, many bought
the XSLT 2.0 book without its XPath companion and were left
confused as a result; so this time, the material is back together.
The XPath reference information is in self-contained chapters, so
it should still be accessible when you use XPath in contexts other
than XSLT. The book does not cover XSL Formatting Objects, a big
subject in its own right. Nor does it cover XML Schemas in any
detail. If you want to use these important technologies in
conjunction with XSLT, there are other books that do them justice.
This book contains twenty chapters and eight appendixes (the last
of which is a glossary) organized into four parts. The following
section outlines what you can find in each part, chapter, and
appendix. Part I: Foundations: The first part of the book covers
essential concepts. You should read these before you start coding.
If you ignore this advice, as most people do, then you read them
when you get to that trough of despair when you find it impossible
to make the language do anything but the most trivial tasks. XSLT
is different from other languages, and to make it work for you, you
need to understand how it was designed to be used. Chapter 1: XSLT
in Context: This chapter explains how XSLT fits into the big
picture: how the language came into being and how it sits alongside
other technologies. It also has a few simple coding examples to
keep you alert. Chapter 2: The XSLT Processing Model: This is about
the architecture of an XSLT processor: the inputs, the outputs, and
the data model. Understanding the data model is perhaps the most
important thing that distinguishes an XSLT expert from an amateur;
it may seem like information that you can't use immediately, but
it's knowledge that will stop you making a lot of stupid mistakes.
Chapter 3: Stylesheet Structure: XSLT development is about writing
stylesheets, and this chapter takes a bird's eye view of what
stylesheets look like. It explains the key concepts of rule-based
programming using templates, and explains how to undertake
programming-in-the-large by structuring your application using
modules and pipelines. Chapter 4: Stylesheets and Schemas: A key
innovation in XSLT 2.0 is that stylesheets can take advantage of
knowledge about the structure of your input and output documents,
provided in the form of an XML Schema. This chapter provides a
quick overview of XML Schema to describe its impact on XSLT
development. Not everyone uses schemas, and you can skip this
chapter if you fall into that category. Chapter 5: The Type System:
XPath 2.0 and XSLT 2.0 offer strong typing as an alternative to the
weak typing approach of the 1.0 languages. This means that you can
declare the types of your variables, functions, and parameters, and
use this information to get early warning of programming errors.
This chapter explains the data types available and the mechanisms
for creating user-defined types. Part II: XSLT and XPath Reference:
This section of the book contains reference material, organized in
the hope that you can easily find what you need when you need it.
It's not designed for sequential reading, though you might well
want to leaf through the pages to discover what's there. Chapter 6:
XSLT Elements: This monster chapter lists all the XSLT elements you
can use in a stylesheet, in alphabetical order, giving detailed
rules for the syntax and semantics of each element, advice on
usage, and examples. This is probably the part of the book you will
use most frequently as you become an expert XSLT user. It's a "no
stone unturned" approach, based on the belief that as a
professional developer you need to know what happens when the going
gets tough, not just when the wind is in your direction. Chapter 7:
XPath Fundamentals: This chapter explains the basics of XPath: the
low-level constructs such as literals, variables, and function
calls. It also explains the context rules, which describe how the
evaluation of XPath expressions depends on the XSLT processing
context in which they appear. Chapter 8: XPath: Operators on Items:
XPath offers the usual range of operators for performing
arithmetic, boolean comparison, and the like. However, these don't
always behave exactly as you would expect, so it's worth reading
this chapter to see what's available and how it differs from the
last language that you used. Chapter 9: XPath: Path Expressions:
Path expressions are what make XPath special; they enable you to
navigate around the structure of an XML document. This chapter
explains the syntax of path expressions, the 13 axes that you can
use to locate the nodes that you need, and associated operators
such as union, intersection, and difference. Chapter 10: XPath:
Sequence Expressions: Unlike XPath 1.0, in version 2.0 all values
are sequences (singletons are just a special case). Some of the
most important operators in XPath 2.0 are those that manipulate
sequences, notably the "for" expression, which translates one
sequence into another by applying a mapping. Chapter 11: XPath:
Type Expressions: The type system was explained in Chapter 5; this
chapter explains the operations that you can use to take advantage
of types. This includes the "cast" operation which is used to
convert values from one type to another.A big part of this chapter
is devoted to the detailed rules for how these conversions are
done. Chapter 12: XSLT Patterns: This chapter returns from XPath to
a subject that's specific to XSLT. Patterns are used to define
template rules, the essence of XSLT's rule-based programming
approach. The reason for explaining them now is that the syntax and
semantics of patterns depends strongly on the corresponding rules
for XPath expressions. Chapter 13: The Function Library: XPath 2.0
includes a library of functions that can be called from any XPath
expression; XSLT 2.0 extends this with some additional functions
that are available only when XPath is used within XSLT. The library
has grown immensely since XPath 1.0. This chapter provides a single
alphabetical reference for all these functions. Chapter 14: Regular
Expressions: Processing of text is an area where XSLT 2.0 and XPath
2.0 are much more powerful than version 1.0, and this is largely
through the use of constructs that exploit regular expressions. If
you're familiar with regexes from languages such as Perl, this
chapter tells you how XPath regular expressions differ. If you're
new to the subject, it explains it from first principles. Chapter
15: Serialization: Serialization in XSLT means the ability to
generate a textual XML document from the tree structure that's
manipulated by a stylesheet. This isn't part of XSLT processing
proper, so (following W3C's lead) it's separated it into its own
chapter. You can control serialization from the stylesheet using an
declaration, but many products also allow you to control it
directly via an API. Part III: Exploitation: The final section of
the book is advice and guidance on how to take advantage of XSLT to
write real applications. It's intended to make you not just a
competent XSLT coder, but a competent designer too. The best way of
learning is by studying the work of others, so the emphasis here is
on practical case studies. Chapter 16: Extensibility: This chapter
describes the "hooks" provided in the XSLT specification to allow
vendors and users to plug in extra functionality. The way this
works will vary from one implementation to another, so we can't
cover all possibilities, but one important aspect that the chapter
does cover is how to use such extensions and still keep your code
portable. Chapter 17: Stylesheet Design Patterns: This chapter
explores a number of design and coding patterns for XSLT
programming, starting with the simplest "fill-in-the-blanks"
stylesheet, and extending to the full use of recursive programming
in the functional programming style, which is needed to tackle
problems of any computational complexity. This provides an
opportunity to explain the thinking behind functional programming
and the change in mindset needed to take full advantage of this
style of development. Chapter 18: Case Study: XMLSpec: XSLT is
often used for rendering documents, so where better to look for a
case study than the stylesheets used by the W3C to render the XML
and XSLT specifications, and others in the same family, for display
on the web? The resulting stylesheets are typical of those you will
find in any publishing organization that uses XML to develop a
series of documents with a compatible look-and-feel. Chapter 19:
Case Study: A Family Tree: Displaying a family tree is another
typical XSLT application. This example with semi-structured data-a
mixture of fairly complex data and narrative text-that can be
presented in many different ways for different audiences. It also
shows how to tackle another typical XSLT problem, conversion of the
data into XML from a legacy text-based format. As it happens, this
uses nearly all the important new XSLT 2.0 features in one short
stylesheet. But another aim of this chapter is to show a collection
of stylesheets doing different jobs as part of a complete
application. Chapter 20: Case Study: Knight's Tour: Finding a route
around a chessboard where a knight visits every square without ever
retracing its steps might sound a fairly esoteric application for
XSLT, but it's a good way of showing how even the most complex of
algorithms are within the capabilities of the language. You may not
need to tackle this particular problem, but if you want to
construct an SVG diagram showing progress against your project
plan, then the problems won't be that dissimilar. Part IV:
Appendices: A ppendix A: XPath 2.0 Syntax Summary: Collects the
XPath grammar rules and operator precedences into one place for
ease of reference. Appendix B: Error Codes: A list of all the error
codes defined in the XSLT and XPath language specifications, with
brief explanations to help you understand what's gone wrong.
Appendix C: Backward Compatibility: The list of things you need to
look out for when converting applications from XSLT 1.0. Appendix
D: Microsoft XSLT Processors: Although the two Microsoft XSLT
processors don't yet support XSLT 2.0, we thought many readers
would find it useful to have a quick summary here of the main
objects and methods used in their APIs. Appendix E: JAXP: the Java
API for XML Processing: JAXP is an interface rather than a product.
Again, it doesn't have explicit support yet for XSLT 2.0, but Java
programmers will often be using it in XSLT 2.0 projects, so the
book includes an overview of the classes and methods available.
Appendix F: Saxon: At the time of writing Saxon (developed by the
author of this book) provides the most comprehensive implementation
of XSLT 2.0 and XPath 2.0, so its interfaces and extensions are
covered in some detail. Appendix G: Altova: Altova, the developers
of XML Spy, have an XSLT 2.0 processor that can be used either as
part of the development environment or as a freestanding component.
This appendix gives details of its interfaces. Appendix H: Glossary
Note: CD-ROM/DVD and other supplementary materials are not included
as part of eBook file.
General
Imprint: |
John Wiley & Sons
|
Country of origin: |
United States |
Release date: |
June 2008 |
First published: |
April 2008 |
Authors: |
M. Kay
|
Dimensions: |
251 x 195 x 61mm (L x W x T) |
Format: |
Hardcover
|
Pages: |
1368 |
Edition: |
4th Edition |
ISBN-13: |
978-0-470-19274-0 |
Categories: |
Books >
Computing & IT >
Computer programming >
General
|
LSN: |
0-470-19274-7 |
Barcode: |
9780470192740 |
Is the information for this product incomplete, wrong or inappropriate?
Let us know about it.
Does this product have an incorrect or missing image?
Send us a new image.
Is this product missing categories?
Add more categories.
Review This Product
No reviews yet - be the first to create one!