更快速网站(影印版) 下载 pdf 百度网盘 epub 免费 2025 电子书 mobi 在线

《更快速网站(影印版)》内容简介：对于任何成功的网站来说，性能是至关重要的。但伴随着不断增长的丰富内容和Ajax的过度使用，如今的Web应用已经将浏览器推至性能极限。在《更快速网站(影印版)》中，Google的Web性能专家和前任雅虎首席网站性能官Steve Souders提供了宝贵的技术，来帮助你优化网站性能。

作者的上一《更快速网站(影印版)》是非常畅销的《High Performance Web Sites》，它透露了80%的网页加载时间是花在客户端，使网络开发世界为之震惊。在《更快速网站(影印版)》中，Souders和8位专家撰稿人提供了*实践和实用建议，用于在三个范畴提高网站的性能：

JavaScript——获取用于了解Ajax性能的建议，编写有效的JavaScript，创建响应程序，加载脚本时不阻止其他组件等等。

Network——学习穿过多个域共享资源，减小图片尺寸而不损失质量，以及使用分块编码（chunked encoding）来更快呈现页面。

Browser——探索内嵌框架（*）的替代方案、如何简化CSS选择器和其他技术。

对于当今的富媒体网站和Web 2.0应用来说，速度是至关重要的。有了这《更快速网站(影印版)》，你将学习到如何减少你的网站的加载时间，让它们响应得更快。

Credits

Preface

1. Understanding Ajax Performance

Trade-offs

Principles of Optimization

Ajax

Browser

Wow!

JavaScript

Summary

2. Creating Responsive Web Applications

What Is Fast Enough?

Measuring Latency

When Latency Goes Bad

Threading

Ensuring Responsiveness

Web Workers

Gears

Timers

Effects of Memory Use on Response Time

Virtual Memory

Troubleshooting Memory Issues

Summary

3. Splitting the Initial Payload

Kitchen Sink

Savings from Splitting

Finding the Split

Undefined Symbols and Race Conditions

Case Study: Google Calendar

4. Loading Scripts Without Blocking

Scripts Block

Making Scripts Play Nice

XHR Eval

XHR Injection

Script in Iframe

Script DOM Element

Script Defer

document.write Script Tag

Browser Busy Indicators

Ensuring (or Avoiding) Ordered Execution

Summarizing the Results

And the Winner Is

5. Coupling Asynchronous Scripts

Code Example: menu.js

Race Conditions

Preserving Order Asynchronously

Technique 1: Hardcoded Callback

Technique 2: Window Onload

Technique 3: Timer

Technique 4: Script Onload

Technique 5: Degrading Script Tags

Multiple External Scripts

Managed XHR

DOM Element and Doc Write

General Solution

Single Script

Multiple Scripts

Asynchronicity in the Real World

Google Analytics and Dojo

YUI Loader Utility

6. Positioning Inline Scripts

Inline Scripts Block

Move Inline Scripts to the Bottom

Initiate Execution Asynchronously

Use Script Defer

Preserving CSS and JavaScript Order

Danger: Stylesheet Followed by Inline Script

Inline Scripts Aren’t Blocked by Most Downloads

Inline Scripts Are Blocked by Stylesheets

This Does Happen

7. Writing Efficient JavaScript

Managing Scope

Use Local Variables

Scope Chain Augmentation

Efficient Data Access

Flow Control

Fast Conditionals

Fast Loops

String Optimization

String Concatenation

Trimming Strings

Avoid Long-Running Scripts

Yielding Using Timers

Timer Patterns for Yielding

Summary

8. Scaling with Comet

How Comet Works

Transport Techniques

Polling

Long Polling

Forever Frame

XHR Streaming

Future Transports

Cross-Domain

Effects of Implementation on Applications

Managing Connections

Measuring Performance

Protocols

Summary

9. Going Beyond Gzipping

Why Does This Matter?

What Causes This?

Quick Review

The Culprit

Examples of Popular Turtle Tappers

How to Help These Users?

Design to Minimize Uncompressed Size

Educate Users

Direct Detection of Gzip Support

10. Optimizing Images

Two Steps to Simplify Image Optimization

Image Formats

Background

Characteristics of the Different Formats

More About PNG

Automated Lossless Image Optimization

Crushing PNGs

Stripping JPEG Metadata

Converting GIF to PNG

Optimizing GIF Animations

Smush.it

Progressive JPEGs for Large Images

Alpha Transparency: Avoid AlphaImageLoader

Effects of Alpha Transparency

AlphaImageLoader

Problems with AlphaImageLoader

Progressively Enhanced PNG8 Alpha Transparency

Optimizing Sprites

?ber-Sprite Versus Modular Sprite

Highly Optimized CSS Sprites

Other Image Optimizations

Avoid Scaling Images

Crush Generated Images

Favicons

Apple Touch Icon

Summary

11. Sharding Dominant Domains

Critical Path

Who’s Sharding?

Downgrading to HTTP/1.0

Rolling Out Sharding

IP Address or Hostname

How Many Domains

How to Split Resources

Newer Browsers

12. Flushing the Document Early

Flush the Head

Output Buffering

Chunked Encoding

Flushing and Gzip

Other Intermediaries

Domain Blocking During Flushing

Browsers: The Last Hurdle

Flushing Beyond PHP

The Flush Checklist

13. Using Iframes Sparingly

The Most Expensive DOM Element

Iframes Block Onload

Parallel Downloads with Iframes

Script Before Iframe

Stylesheet Before Iframe

Stylesheet After Iframe

Connections per Hostname

Connection Sharing in Iframes

Connection Sharing Across Tabs and Windows

Summarizing the Cost of Iframes

14. Simplifying CSS Selectors

Types of Selectors

ID Selectors

Class Selectors

Type Selectors

Adjacent Sibling Selectors

Child Selectors

Descendant Selectors

Universal Selectors

Attribute Selectors

Pseudo-Classes and Pseudo-Elements

The Key to Efficient CSS Selectors

Rightmost First

Writing Efficient CSS Selectors

CSS Selector Performance

Complex Selectors Impact Performance (Sometimes)

CSS Selectors to Avoid

Reflow Time

Measuring CSS Selectors in the Real World

Appendix: Performance Tools

Index

Steve Souders，在Google从事网络性能和开放源码计划方面的工作。他是YSlow（Firebug性能分析扩展）的创造者，并且担任Velocity（0’Reilly的网络性能和业务运营会议）的联合主席。Steve经常在会议上或者高级别公司中发言，包括微软、亚马逊、MySpace、Linkedln、Facebook。

暂无出版社相关信息，正在全力查找中！

Refactoring the code can reduce its apparent complexity, making optimization andother transformations more likely to yield benefits. For example, adopting the YSlowrules can have a huge impact on the delivery time of web pages （see http://developer. yahoo.com/yslow/）.

Even so, it is difficult for web applications to get under the Inefficiency line because ofthe size and complexity of web pages. Web pages are big, heavy, multipart things. Pagereplacement comes with a significant cost. For applications where the differencebetween successive pages is relatively small, use of Ajax techniques can produce a significant improvement.

Instead of requesting a replacement page as a result of a user action, a packet of datais sent to the server （usually encoded asJSON text） and the server responds with anotherpacket （also typically JSON-encoded） containing data. A JavaScript program uses thatdata to update the browser's display. The amount of data transferred is significantly.reduced, and the time between the user action and the visible feedback isalso significantly reduced. The amount of work that the server must do is reduced.The amount of work that the browser must do is reduced. The amount of work thatthe Ajax programmer must do, unfortunately, is likely to increase. That is one of thetrade-offs.

The architecture of an Ajax application is significantly different from most other sortsof applications because it is divided between two systems. Getting the division of laborright is essential if the Ajax approach is to have a positive impact on performance. Thepackets should be as small as possible. The application should be constructed as aconversation between the browser and the server, in which the two halves communicatein a concise, expressive, shared language. Just-in-time data delivery allows the browserside of the application to keep n small, which tends to keep the loops fast.

A common mistake in Ajax applications is to send all of the application's data to thebrowser. This reintroduces the latency problems that Ajax is supposed to avoid. It alsoenlarges the volume of data that must be handled in the browser, increasing n and againcompromising performance.

在线阅读地址：更快速网站(影印版)在线阅读

在线听书地址：更快速网站(影印版)在线收听

在线购买地址：更快速网站(影印版)在线购买

* The architecture of HDFS is described in “The Hadoop Distributed File System” by Konstantin Shvachko,

Hairong Kuang, Sanjay Radia, and Robert Chansler (Proceedings of MSST2010, May 2010, http://

storageconference.org/2010/Papers/MSST/Shvachko.pdf).

† “Scaling Hadoop to 4000 nodes at Yahoo!,” http://developer.yahoo.net/blogs/hadoop/2008/09/scaling_hadoop

_to_4000_nodes_a.html.

在许多情况下，可以视Mapreduce为关系型数据库管理系统的补充。MapReduce比较适合以批处理的方式处理需要分析整个数据集的问题，尤其是即席分析。RDBMS适用于点查询和更新，数据集被索引后，数据库系统能够提供低延迟的数据检索和快速的少量数据更新。MapReduce适合数据一次写入、多次读取的应用，而关系型数据库更适合持续更新数据集.

MapReduce is a programming model for data processing. MapReduce works by breaking the processing into two phases: the map phase and the reduce phase. Each phase has key-value pairs as input and output, the types of which may be chosen by the programmer. The programmer also specifies two functions: the map function and the reduce function.

Hadoop divides the input to a MapReduce job into fixed-size pieces called input splits, or just splits. Hadoop creates one map task for each split, which runs the userdefined map function for each record in the split. Hadoop does its best to run the map task on a node where the input data resides in HDFS. This is called the data locality optimization.

When there are multiple reducers, the map tasks partition their output, each creating one partition for each reduce task. There can be many keys (and their associated values) in each partition, but the records for every key are all in a single partition. The partitioning can be controlled by a user-defined partitioning function, but normally the default partitioner—which buckets keys using a hash function—works very well.

HDFS is a filesystem designed for storing very large files with streaming data access patterns(write-once, read-many-times pattern), running on clusters of commodity hardware.

HDFS blocks(>64M) are large compared to disk blocks, and the reason is to minimize the cost of seeks. Map tasks in MapReduce normally operate on one block at a time, so if you have too few tasks (fewer than nodes in the cluster), your jobs will run slower than they could otherwise.

An HDFS cluster has two types of node operating in a master-worker pattern: a namenode (the master) and a number of datanodes (workers). The namenode manages the filesystem namespace. It maintains the filesystem tree and the metadata for all the files and directories in the tree. Datanodes are the workhorses of the filesystem. They store a...

One important aspect of this design is that the client contacts datanodes directly to retrieve data and is guided by the namenode to the best datanode for each block. This design allows HDFS to scale to a large number of concurrent clients, since the data traffic is spread across all the datanodes in the cluster.

Hadoop takes a simple approach in which the network is represented as a tree and the distance between two nodes is the sum of their distances to their closest common ancestor.

编辑推荐

《更快速网站(影印版)》是由东南大学出版社出版的。

媒体评论

“本书拥有近*的专业知识，能使你的网站飞速运行。我喜欢这本书的编排，有许多主题，每一个都被该领域受人尊敬的权威人士所探究。我的团队中的每个人都将拥有一本。”

　　——Bill Scott，Netflix公司UI上程总监