XSLT 2.0 and XPath 2.0 Programmer's Reference und über 1,5 Millionen weitere Bücher verfügbar für Amazon Kindle. Erfahren Sie mehr
EUR 48,00
  • Alle Preisangaben inkl. MwSt.
Nur noch 5 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon.
Geschenkverpackung verfügbar.
Menge:1
Ihren Artikel jetzt
eintauschen und
EUR 10,70 Gutschein erhalten.
Möchten Sie verkaufen?
Zur Rückseite klappen Zur Vorderseite klappen
Anhören Wird wiedergegeben... Angehalten   Sie hören eine Probe der Audible-Audioausgabe.
Weitere Informationen
Alle 2 Bilder anzeigen

XSLT 2.0 and XPath 2.0 Programmer's Reference (Programmer to Programmer) (Englisch) Gebundene Ausgabe – 3. Juni 2008


Alle 2 Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Amazon-Preis Neu ab Gebraucht ab
Kindle Edition
"Bitte wiederholen"
Gebundene Ausgabe
"Bitte wiederholen"
EUR 48,00
EUR 33,28 EUR 16,71
34 neu ab EUR 33,28 6 gebraucht ab EUR 16,71

Hinweise und Aktionen

  • Studienbücher: Ob neu oder gebraucht, alle wichtigen Bücher für Ihr Studium finden Sie im großen Studium Special. Natürlich portofrei.


Wird oft zusammen gekauft

XSLT 2.0 and XPath 2.0 Programmer's Reference (Programmer to Programmer) + XSLT Cookbook (Cookbooks (O'Reilly)) + XSLT
Preis für alle drei: EUR 116,52

Die ausgewählten Artikel zusammen kaufen
Jeder kann Kindle Bücher lesen — selbst ohne ein Kindle-Gerät — mit der KOSTENFREIEN Kindle App für Smartphones, Tablets und Computer.


Produktinformation

  • Gebundene Ausgabe: 1376 Seiten
  • Verlag: John Wiley & Sons; Auflage: 4. Auflage (3. Juni 2008)
  • Sprache: Englisch
  • ISBN-10: 0470192747
  • ISBN-13: 978-0470192740
  • Größe und/oder Gewicht: 19,3 x 5,1 x 24,1 cm
  • Durchschnittliche Kundenbewertung: 5.0 von 5 Sternen  Alle Rezensionen anzeigen (1 Kundenrezension)
  • Amazon Bestseller-Rang: Nr. 32.558 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)
  • Komplettes Inhaltsverzeichnis ansehen

Mehr über den Autor

Entdecken Sie Bücher, lesen Sie über Autoren und mehr

Produktbeschreibungen

Synopsis

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

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

Buchrückseite

Combining coverage of XSLT 2.0 and XPath 2.0 into one book, this authoritative reference provides equal weight to the powerful new features of XSLT 2.0 and XPath 2.0 and the established capabilities of the 1.0 versions. Author Michael Kay has created his own implementation of XSLT 2.0 (Saxon), and he puts his unique knowledge to work in this detailed reference to the elements of the XSLT 2.0 language and the fundamentals of XPath, complete with syntax, practical usage advice, and examples.
 
The book begins by teaching the essential concepts behind the language, knowledge you need if you are going to write good code rather than just working code. You will discover how XSLT and XPath differ from other languages, and how you use them to create effective web-based applications. The central chapters provide meticulous coverage of the language features of XSLT 2.0 and XPath 2.0. You will return to this reference whenever you encounter new programming challenges. You finish with detailed case studies highlighting real applications to give you insights you would otherwise gain only from months of practical experience.
 
What you will learn from this book
*
 
All the XSLT elements you can use in a stylesheet and the detailed rules for the syntax and semantics of each
*
 
How Path expressions enable you to navigate around the structure of an XML document
*
 
How you can improve your stylesheets by taking advantage of the XML Schema definitions of input and output documents
*
 
How to take advantage of vendor extensions without losing portability
*
 
Techniques for taking advantage of XSLT to write real applications
 
Who this book is for
This book is for experienced programmers who are looking to become proficient with XSLT 2.0. Previous experience with XSLT or XPath is not necessary. However, a working knowledge of XML, HTML, and web architecture is beneficial.
 
Wrox Programmer's References are designed to give the experienced developer straight facts on a new technology, without hype or unnecessary explanations. They deliver hard information with plenty of practical examples to help you apply new tools to your development projects today.

Welche anderen Artikel kaufen Kunden, nachdem sie diesen Artikel angesehen haben?


In diesem Buch (Mehr dazu)
Ausgewählte Seiten ansehen
Buchdeckel | Copyright | Inhaltsverzeichnis | Auszug | Stichwortverzeichnis | Rückseite
Hier reinlesen und suchen:

Kundenrezensionen

5.0 von 5 Sternen
5 Sterne
1
4 Sterne
0
3 Sterne
0
2 Sterne
0
1 Sterne
0
Siehe die Kundenrezension
Sagen Sie Ihre Meinung zu diesem Artikel

Die hilfreichsten Kundenrezensionen

3 von 3 Kunden fanden die folgende Rezension hilfreich Von M. Huber am 12. Mai 2012
Format: Gebundene Ausgabe Verifizierter Kauf
Das Buch hat sich bei mir zu DEM Nachschlagewerk für XSLT gemausert. Dort, wo noch kein XSLT 2.0 einsetzbar ist, hilft das Buch auch weiter, weil die Versionsunterschiede zu XSLT 1 dokumentiert werden.
Kommentar War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback. Wenn diese Rezension unangemessen ist, informieren Sie uns bitte darüber.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen

Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)

Amazon.com: 22 Rezensionen
19 von 19 Kunden fanden die folgende Rezension hilfreich
Definitive reference 8. Mai 2008
Von J. Bogaarts - Veröffentlicht auf Amazon.com
Format: Gebundene Ausgabe Verifizierter Kauf
You won't easily find a better book on XSLT 2.0 and XPath 2.0. The reason is very simple: Michael Kay is THE expert on the subject, he has been publishing xslt references for almost a decade now. Currently he is the editor of the XSLT 2.0 specification at W3C. He is also involved the XQuery and the XML Schema Working Groups, also at W3C. He has developed the Saxon XSLT processor. This book (like its predecessors were and its future versions will be) is the definitive reference on XSLT.

The third edition was in two separate books, one on XSLT 2.0 (XSLT 2.0 Programmer's Reference (Programmer to Programmer)) and one on XPath 2.0 (XPath 2.0 Programmer's Reference (Programmer to Programmer)). If you are serious about XSLT 2.0, you also need the information on XPath 2.0, as it is a sub language of XSLT 2.0. So you would need both books at hand. The current book contains all of the material available in the two predecessors, and more.

I could have survived on the two books, but tired of taking them from my office to my home and vice versa, I ordered the new edition and I am enjoying it very much. After using the new edition for a week or so I have come upon quite a few improvements, for instance the chapter on regular expressions contains more information and is better structured. Examples have been updated and as have been the appendices covering the processors. There is a new appendix on the Altova processor.

I should also mention the quality of the paper, the binding and the price, they are much better than the two previous books together.

As a reference, the book is complete. It contains a clear description of all the elements of the standards and lots of (tested) examples. There is also much material about the design backgrounds of both standards (and of others like XML Schema and XQuery).

The book is extremely well written and a joy to read.

The book is aimed at developers and should not be used as a first introduction to XML transformation technology (unless you are an experienced programmer). If you need an introduction to XSLT (in its context) check out one of the other Wrox books like Beginning XML, 4th Edition (Programmer to Programmer) or Professional XML (Programmer to Programmer). One could also try Beginning XSLT 2.0: From Novice to Professional (Beginning: from Novice to Professional), it has good reviews. In any case if you are seriously interested (even as a newbie) don't buy anything from before 2004, it will not include the 2.0 functionalities. If you buy something published after 2004 check that they really updated the book and not only the title.

Recently O'Reilly has issued an update of tidwell's XSLT, 2nd Edition. I could be worthwhile to consider this book also.
21 von 22 Kunden fanden die folgende Rezension hilfreich
Not Usable as a Kindle Book 10. Oktober 2011
Von P. Broyles - Veröffentlicht auf Amazon.com
Format: Kindle Edition Verifizierter Kauf
This is a review specifically of the Kindle edition. I have used the print version of this book, and it's a great reference. It's a bulky, heavy book, so I decided to purchase a Kindle copy that would be more portable. Unfortunately, the Kindle version is a disaster, and I recommend it to no one.

After the Table of Contents, the book uses hyperlinks rarely if at all. Cross-references from one section of the book to another are not hyperlinked; they still list the original page number, with no way to jump to the appropriate section. Likewise, the index features no links (and no page numbers) at all. The index to the Kindle edition is basically a list of all the topics covered in the book with no way to access any of those topics.

This makes the book hard to use as a reference. For instance, it's really hard to look up an XPath function. One long chapter contains an entry for each XPath function. The Table of Contents does not list the individual functions. The list that's found at the start of the chapter shows page numbers rather than hyperlinks. The index entry for the function doesn't have a link. That leaves you with two ways to look up the function you want. One is to use the search feature. That's great if the function has an unusual name, but a search for a function name like "document" returns far too many hits to be helpful. Or, you can flip through the pages in the chapter one by one until you find the page you're looking for--which takes longer than just leafing through the print book.

As reviews of the print edition will tell you, this isn't a book you're likely to sit down and read from beginning to end. You'll want to use the book to look up the details on specific functions, elements, or techniques. But because this book hasn't been optimized for the Kindle, it will be almost impossible to find what you want efficiently. Avoid the Kindle edition at all costs; stick to the print version for your XSLT/XPath reference.
8 von 8 Kunden fanden die folgende Rezension hilfreich
The authoritative reference updated and improved 5. Juni 2008
Von Wendell Piez - Veröffentlicht auf Amazon.com
Format: Gebundene Ausgabe
Everyone working seriously with XSLT will want this book. The fourth edition is newly updated and improved. Not only has it been corrected to reflect the design of the current XSLT and XPath specifications (which were not final when the 3rd edition went to press), but also it has been redesigned for usability, with much better indexes and navigation apparatus. No more casting about to find things (although you may still not resist a few post-it notes here and there). XSLT and XPath are now in one volume (a big plus); the lighter pages and hard cover make the book serviceable as a reference text in regular use. It sits open and will wear well (provided you use it for its intended purpose and not as a coaster for your drink, which will be tempting since the book will be there open on your desk).

But the book's strengths are unchanged. Complete and comprehensive, coherent, realistic, clear, with worked examples. No one knows this technology better than the author, who has served on the XSL Working Group and edited the XSLT 2.0 Recommendation. Long-time observers will also confirm that he is also one of the best in the business at explaining things.

The only thing less than positive to say about this book is that beginners may find it intimidating. Don't. Just supplement it with a treatment aimed at you such as XSLT 1.0 Pocket Reference (Pocket Reference (O'Reilly)) or anything by Jeni Tennison, and keep the Programmer's Reference ready for the summary comprehensive view, or when you need to go deep.

I have seen many decrepit copies of earlier editions of this book used by industry professionals. This one looks to be good for a long time to come.
6 von 6 Kunden fanden die folgende Rezension hilfreich
The Annotated Reference Manual for XSLT and XPath 8. Juli 2011
Von Ben Hekster - Veröffentlicht auf Amazon.com
Format: Gebundene Ausgabe Verifizierter Kauf
It's tricky to judge the quality of a book in a field with which you're unfamiliar. One technique I've used is using common sense to find various kinds of errors-- and a good sign of this book is that each time I thought I'd caught the author in a mistake, further study always proved me wrong. I eventually ended up reading this book practically cover to cover and soaking up as much as I could.

This book has no fluff or cutesy humor. The writing is precise, to the point, and anticipated my questions. There is some repetition (for example, on the topic of namespaces), making the book in my mind very useful as a reference. The author's obvious familiarity with the standard itself and its various implementations reveals itself in the many clarifying annotations.

Some of the examples are very elaborate and thorough and serve to clarify the complexities of the technology where needed-- for example, regarding the subtleties of the 'for' and 'number' family of instructions.

If there are any deficiencies in the book at all, they are minor. One irritation is the author's prejudice towards Java (granted that XSLT and XPath themselves seem more comfortable in that domain); for example, calling C++ "procedural" or claiming that Java popularized IEEE 754 (neglecting phenomenal implementations such as SANE that predated Java by a decade). This didn't really distract from the value of the book, other than that an entire appendix is devoted to JAXP while there is not a single mention of libxslt2-- making me wonder for a while whether the technologies described in this book were applicable to the problem I was trying to solve (they were).

There are mentions of efficiencies that can be obtained with "a good optimizer," but with only my personal suspicion that only the author's own implementation supports them I'd still have some work to do if I wanted to evaluate the differences between them.

In using the book I did often find myself confused over which parts applied to the 2.0 versions of XSLT/XPath-- and while the book does define that specifically, a clearer typographical separation would have been helpful. This problem obviously will become less relevant as the later versions become more widely supported.

On the topic of the technologies themselves, I've become even more convinced of the absurdity of any kind of executable XML. Also, the melding together of two intentionally separate languages (XSLT vs XPath) with different type systems and other complex relationships appears to have no obvious practical advantage. Finally, if the object of one-based counting was to make the technology more accessible, the actual effect to me was to make it that much less so.

In a nutshell, I have no qualms whatsoever recommending this book to a wide audience. It's extremely thorough, well-written and organized, and authoritative.
6 von 7 Kunden fanden die folgende Rezension hilfreich
Definately a Reference Book 20. Oktober 2008
Von E. B. Phillips - Veröffentlicht auf Amazon.com
Format: Gebundene Ausgabe
It is considerably useful, but please bear in mind that it is organized as a reference book. It doesn't slowly build up your understanding like a textbook approach, but rather lays it on thickly like molasses.
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.