在我们写样式的时候，页面的CSS在经历几个版本的修改之后，可能有些样式已经用不到了，或许将某些样式更名了而原来的忘了删除，总之页面中可能存在着一些无用的样式。这些无用的浪费了一些服务器空间和带宽消耗，也会增大我们的维护成本。那么有没有一些办法来清理那些无用的样式呢？今天就让我们来了解一下几个比较有用的工具。

Dust-Me selectors

Dust-Me是一个很有用也很好用的Firefox插件，它可以分析到你的页面中调用的所有CSS文件并分析那些在页面中没有被用到。

支持本地和远程样式文件，包括使用link标签、< ?xml-stylesheet?>处理指令、 at import语句等方式引入的样式文件；(但是不支持页面中的style块和内联样式)
支持IE条件注释中引入的样式文件；
可以检查一个页面，也可以检查整个网站；
支持CSS1选择器、大部分CSS2和CSS3选择器；
理解通用的CSS hack，比如 “* html #fuck-ie”将会被认为是”html #fuck-ie”；
支持Firefox 3 dot 5和Firefox 3.0，事实上得益于FF 3.5的js引擎的改进，FF 3.5中的性能比FF 3.0要高50%。

安装：点击这里。了解更多请访问 Dust-Me selector官方页面。

Page Speed

Page Speed是Google提供的一个前端性能分析工具，有些类似于YSlow，但是提供了一些比较个性且很有用的工具，比如Remove unused CSS.

Page Speed和YSlow一样依赖Firebug，了解详情和安装请访问这里。

CSS Redundancy Checker

CSS Redundancy Checker 是一个免费的在线应用，可以检查所有的使用某个CSS文件的页面中无用的样式。可以同时检查某一个样式在多个页面中的使用情况。该工具的不足是虽然一次能检查多个HTML页面，但每次只能检查一个CSS文件，而且还要手动输入

http://services.immike.net/css-checker/

IntelliJ IDEA

IntelliJ IDEA 这是一个颇强大的IDE，类似于DreamWeaver，不过在国内用的不多。该软件包括一个即时代码分析工具(On-the-fly Code Analysis)，可以分析CSS文件中未用到的class和id。

Expression Web

Expression Web作为微软的新一代网站开发工具，还是有很多人使用的，其CSS Report功能可以检查未用到需要被清除的CSS（我的确没有使用EW开发过网站，希望使用该软件的童鞋可以帮忙确认一下这一点）

　　在Web标准中的页面布局是使用Div配合CSS来实现的。这其中最常用到的就是使整个页面水平居中的效果，这是在页面布局中基本，也是最应该首先掌握的知识。不过，还是经常会有人问到这个问题，在这里我简单总结一下使用Div和CSS实现页面水平居中的方法：

　　一、margin:auto 0 与 text-aligh:center

　　在现代浏览器（如Internet Explorer 7、Firefox、Opera等）现代浏览器实现水平居中的方法很简单，只要设定到左右两侧的空白为自动即可。意即：

#wrap { margin:0 auto; }

　　上面这段代码的意思是说使wrap这个div到左右两侧的距离自动设置，上下为0（可以为任意）。请在现代浏览器（如Internet Explorer 7、Firefox、Opera等）中运行现在的代码：

＜!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtm......1-transitional.dtd&quot;＞
＜html xmlns="http://www.w3.org/1999/xhtml"＞
＜head＞
＜title＞ new document ＜/title＞
＜meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /＞
＜style type="text/css"＞
div#wrap {
width:760px;
margin:0 auto;
border:1px solid #333;
background-color:#ccc;
}
＜/style＞
＜/head＞
＜body＞
＜div id="wrap"＞

　　在Firefox等现代浏览器设定页面元素的水平居中，只要指定margin:0 auto;即可

＜pre＞
div#wrap {
width:760px;
margin:0 auto; /*这里的0可以任意值*/
border:1px solid #ccc;
background-color:#999;
}
＜/pre＞
＜/div＞
＜/body＞
＜/html＞

　　上面的效果很好。但是这在Internet Explorer 6及改正的版本中是不起作用的，不过幸好它有自己的解决办法。在Internet Explorer中text-align属性是可继承的，即在父元素中设置后在子元素中就默认具有了该属性。因此我们可以在body标签中设置text-align属性值为center，这样页面内所有的元素都会自动居中，同时我们还要加一个hook把页面中的文字变成我们习惯的阅读方式——居左对齐。因此我们要如此来写代码：

body { text-align:center; }
#wrap { text-align:left; }

　　这样在Internet Explorer中我们就轻松实现了Div的居中对齐。因此要在所有的浏览器中显示居中的效果，我们就可以这样写我们的代码：

body { text-align:center; }
#wrap { text-align:left;
margin:0 auto;
}
＜!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtm......1-transitional.dtd&quot;＞
＜html xmlns="http://www.w3.org/1999/xhtml"＞
＜head＞
＜title＞ CSS+Div实现水平居中对齐的页面布局 ＜/title＞
＜meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /＞
＜style type="text/css"＞
body { text-align:center; }
div#wrap {
text-align:left;
width:760px;
margin:0 auto;
border:1px solid #333;
background-color:#ccc;
}
＜/style＞
＜/head＞
＜body＞
＜div id="wrap"＞

　　在Firefox等现代浏览器设定页面元素的水平居中，只要指定margin:0 auto;即可

＜pre＞
div#wrap {
width:760px;
margin:0 auto; /*这里的0可以任意值*/
border:1px solid #ccc;
background-color:#999;
}

　　在Internet Explorer 6 及以下的版本中我们还要做以下的设置：

body { text-align:center; }
div#wrap {
text-align:left;
}
＜/pre＞
＜/div＞
＜/body＞
＜/html＞

　　不过这里有一个前提，就是设置居中的元素要有固定的宽度，比如这里我们设定了为760像素。

　　二、相对定位与负的边距

　　对于wrap进行相对定位，然后使用负的边距抵消偏移量。这种方法比较简单还很容易实现：

#wrap {
position:relative;
width:760px;
left:50%;
margin-left:-380px
}

　　这段代码的意思是，设置wrap的定位是相对于其父元素body标签的，然后将其左边框移动到页面的正中间（也就是left:50%含意）；最后我们再从中间位置向左偏移回一半的距离来，这样就实现了水平居中了。

＜!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtm......1-transitional.dtd&quot;＞
＜html xmlns="http://www.w3.org/1999/xhtml"＞
＜head＞
＜title＞ CSS+Div实现水平居中对齐的页面布局 ＜/title＞
＜meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /＞
＜style type="text/css"＞
div#wrap {
position:relative;
width:760px;
left:50%;
margin-left:-380px;
border:1px solid #333;
background-color:#ccc;
}
＜/style＞
＜/head＞

＜body＞
＜div id="wrap"＞

　　在所有浏览器中都有效的方法：

＜pre＞
div#wrap {
position:relative;
width:760px;
left:50%;
margin-left:-380px;
border:1px solid #333;
background-color:#ccc;
}
＜/pre＞
＜/div＞
＜/body＞
＜/html＞

　　同样，在设定水平居中前你需要设定一个固定的宽度。

　　P.S.究竟选择哪个方法？

　　上面两个方法究竟选择哪种方法好呢？在第一种方法中貌似使用了Hack技术，其实并没有，它是中规中矩的Web标准写法，完全符合规范，因此，两个种方法中完全可以随便的选取其中的任一种进行使用，他们不存在CSS hack的问题。

　　三、其它的居中方式

　　上面所说的都是设定了具体宽度的情况下水平居中的实现。有时候我们想做一个弹性布局，或者当一个元素处于一个容器中时我们只想让它居中并不想设定一个具体的宽度。其实这并不是真正的居中布局，就像对一个100%长度的元素来说，你说它是居中对齐还是居左对齐呢？所以所有不高宽度的居中都不是真正的居中。这样的设计我们是使用的像元素的padding来设置的，实际中我们是改变了父元素的容器大小：

如我们希望wrap元素长度随窗口而改变，同时又维持居中，我们就可以这样写：

body {
padding:10px 150px;
}

　　这里，我们只需要保持父元素左右两侧的填充是相等的就可以了。

＜!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtm......1-transitional.dtd&quot;＞
＜html xmlns="http://www.w3.org/1999/xhtml"＞
＜head＞
＜title＞ 随浏览器窗口大小而改变的具有弹性的居中布局 ＜/title＞
＜meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /＞
＜style type="text/css"＞
body {
padding:10px 150px;
}
div#wrap {
border:1px solid #333;
background-color:#ccc;
}
＜/style＞
＜/head＞
＜body＞
＜div id="wrap"＞

　　一种随浏览器窗口大小而改变的具有弹性的居中布局：

＜pre＞
body {
padding:10px 150px;
}

　　这里，我们只需要保持父元素左右两侧的填充是相等的就可以了。

＜/pre＞
＜/div＞
＜/body＞
＜/html＞

　　当然这只是“貌似居中”，不过却常常很有用处。

UseEncoding UTF-8 GBK

但是启动的时候出现错误，不认UseEncoding 选项，于是重新编译：

./configure --prefix=/usr/local/proftpd --with-modules=mod_sql:mod_sql_mysql:mod_quotatab:mod_quotatab_sql --with-includes=/usr/local/mysql/include/mysql --with-libraries=/usr/local/mysql/lib/mysql --enable-ctrls --enable-nls --enable-shadow --enable-dso --enable-autoshadow --enable-auth-pam
make
make install

完成后重启proftpd，问题解决

尽管有许多宣传关于 XML
如何拥有跨平台，跨语言的优势，然而，除非应用于 Web Services，否则，在普通的 Web 应用中，开发者经常为 XML
的解析伤透了脑筋，无论是服务器端生成或处理 XML，还是客户端用 JavaScript 解析
XML，都常常导致复杂的代码，极低的开发效率。实际上，对于大多数 Web 应用来说，他们根本不需要复杂的 XML 来传输数据，XML
的扩展性很少具有优势，许多 AJAX 应用甚至直接返回 HTML 片段来构建动态 Web 页面。和返回 XML 并解析它相比，返回 HTML
片段大大降低了系统的复杂性，但同时缺少了一定的灵活性。

现在， JSON 为 Web 应用开发者提供了另一种数据交换格式。让我们来看看 JSON 到底是什么，同 XML 或 HTML 片段相比，JSON 提供了更好的简单性和灵活性。

JSON 数据格式解析

和 XML 一样，JSON 也是基于纯文本的数据格式。由于 JSON 天生是为 JavaScript 准备的，因此，JSON
的数据格式非常简单，您可以用 JSON 传输一个简单的 String，Number，Boolean，也可以传输一个数组，或者一个复杂的
Object 对象。

String，Number 和 Boolean 用 JSON 表示非常简单。例如，用 JSON 表示一个简单的 String “ abc ”，其格式为：

"abc"

除了字符 "，\，/ 和一些控制符（\b，\f，\n，\r，\t）需要编码外，其他 Unicode 字符可以直接输出。下图是一个 String 的完整表示结构：

一个 Number 可以根据整型或浮点数表示如下：

这与绝大多数编程语言的表示方法一致，例如：

12345（整数）
 -3.9e10（浮点数）

Boolean 类型表示为 true 或 false 。此外，JavaScript 中的 null 被表示为 null，注意，true、false 和 null 都没有双引号，否则将被视为一个 String 。

JSON 还可以表示一个数组对象，使用 [] 包含所有元素，每个元素用逗号分隔，元素可以是任意的 Value，例如，以下数组包含了一个 String，Number，Boolean 和一个 null：

["abc",12345,false,null]

Object 对象在 JSON 中是用 { } 包含一系列无序的 Key-Value 键值对表示的，实际上此处的 Object 相当于 Java 中的 Map<String, Object>，而不是 Java 的 Class 。注意 Key 只能用 String 表示。

例如，一个 Address 对象包含如下 Key-Value：

city:Beijing 
 street:Chaoyang Road 
 postcode:100025（整数）

用 JSON 表示如下：

{ "city":"Beijing","street":" Chaoyang Road ","postcode":100025 }

其中 Value 也可以是另一个 Object 或者数组，因此，复杂的 Object 可以嵌套表示，例如，一个 Person 对象包含 name 和 address 对象，可以表示如下：

{ "name":"Michael","address":
    { "city":"Beijing","street":" Chaoyang Road ","postcode":100025 }
 }

JavaScript 处理 JSON 数据

上面介绍了如何用 JSON 表示数据，接下来，我们还要解决如何在服务器端生成 JSON 格式的数据以便发送到客户端，以及客户端如何使用 JavaScript 处理 JSON 格式的数据。

我们先讨论如何在 Web 页面中用 JavaScript 处理 JSON 数据。我们通过一个简单的 JavaScript 方法就能看到客户端如何将 JSON 数据表示给用户：

function handleJson() {  
  var j={ "name":"Michael","address":
      { "city":"Beijing","street":" Chaoyang Road ","postcode":100025 }
   }; 
  document.write(j.name); 
  document.write(j.address.city); 
  }

假定服务器返回的 JSON 数据是上文的：

{ "name":"Michael","address":
    { "city":"Beijing","street":" Chaoyang Road ","postcode":100025 }
 }

只需将其赋值给一个 JavaScript 变量，就可以立刻使用该变量并更新页面中的信息了，相比 XML 需要从 DOM
中读取各种节点而言，JSON 的使用非常容易。我们需要做的仅仅是发送一个 Ajax 请求，然后将服务器返回的 JSON
数据赋值给一个变量即可。有许多 Ajax 框架早已包含了处理 JSON 数据的能力，例如 Prototype（一个流行的 JavaScript
库：http://prototypejs.org）提供了 evalJSON() 方法，能直接将服务器返回的 JSON 文本变成一个 JavaScript 变量：

new Ajax.Request("http://url", {  
  method: "get", 
  onSuccess: function(transport) {  
    var json = transport.responseText.evalJSON(); 
    // TODO: document.write(json.xxx); 
   } 
  });

服务器端输出 JSON 格式数据

下面我们讨论如何在服务器端输出 JSON 格式的数据。以 Java 为例，我们将演示将一个 Java 对象编码为 JSON 格式的文本。

将 String 对象编码为 JSON 格式时，只需处理好特殊字符即可。另外，必须用 (") 而非 (') 表示字符串：

 
 static String string2Json(String s) {  
    StringBuilder sb = new StringBuilder(s.length()+20); 
    sb.append('\"'); 
    for (int i=0; i<s.length(); i++) {  
        char c = s.charAt(i); 
        switch (c) {  
        case '\"': 
            sb.append("\\\""); 
            break; 
        case '\\': 
            sb.append("\\\\"); 
            break; 
        case '/': 
            sb.append("\\/"); 
            break; 
        case '\b': 
            sb.append("\\b"); 
            break; 
        case '\f': 
            sb.append("\\f"); 
            break; 
        case '\n': 
            sb.append("\\n"); 
            break; 
        case '\r': 
            sb.append("\\r"); 
            break; 
        case '\t': 
            sb.append("\\t"); 
            break; 
        default: 
            sb.append(c); 
         } 
     } 
    sb.append('\"'); 
    return sb.toString(); 
  } 
 

将 Number 表示为 JSON 就容易得多，利用 Java 的多态，我们可以处理 Integer，Long，Float 等多种 Number 格式：

 
 static String number2Json(Number number) {  
    return number.toString(); 
  } 
 

Boolean 类型也可以直接通过 toString() 方法得到 JSON 的表示：

 
 static String boolean2Json(Boolean bool) {  
    return bool.toString(); 
  } 
 

要将数组编码为 JSON 格式，可以通过循环将每一个元素编码出来：

 
 static String array2Json(Object[] array) {  
    if (array.length==0) 
        return "[]"; 
    StringBuilder sb = new StringBuilder(array.length << 4); 
    sb.append('['); 
    for (Object o : array) {  
        sb.append(toJson(o)); 
        sb.append(','); 
     } 
    // 将最后添加的 ',' 变为 ']': 
    sb.setCharAt(sb.length()-1, ']'); 
    return sb.toString(); 
  } 
 

最后，我们需要将 Map<String, Object> 编码为 JSON 格式，因为 JavaScript 的 Object 实际上对应的是 Java 的 Map<String, Object> 。该方法如下：

 
 static String map2Json(Map<String, Object> map) {  
    if (map.isEmpty()) 
        return "{  }"; 
    StringBuilder sb = new StringBuilder(map.size() << 4); 
    sb.append('{ '); 
    Set<String> keys = map.keySet(); 
    for (String key : keys) {  
        Object value = map.get(key); 
        sb.append('\"'); 
        sb.append(key); 
        sb.append('\"'); 
        sb.append(':'); 
        sb.append(toJson(value)); 
        sb.append(','); 
     } 
    // 将最后的 ',' 变为 ' }': 
    sb.setCharAt(sb.length()-1, ' }'); 
    return sb.toString(); 
  } 
 

为了统一处理任意的 Java 对象，我们编写一个入口方法 toJson(Object)，能够将任意的 Java 对象编码为 JSON 格式：

 
 public static String toJson(Object o) {  
    if (o==null) 
        return "null"; 
    if (o instanceof String) 
        return string2Json((String)o); 
    if (o instanceof Boolean) 
        return boolean2Json((Boolean)o); 
    if (o instanceof Number) 
        return number2Json((Number)o); 
    if (o instanceof Map) 
        return map2Json((Map<String, Object>)o); 
    if (o instanceof Object[]) 
        return array2Json((Object[])o); 
    throw new RuntimeException("Unsupported type: " + o.getClass().getName()); 
  } 
 

我们并未对 Java 对象作严格的检查。不被支持的对象（例如 List）将直接抛出 RuntimeException 。此外，为了保证输出的 JSON 是有效的，Map<String, Object> 对象的 Key 也不能包含特殊字符。细心的读者可能还会发现循环引用的对象会引发无限递归，例如，精心构造一个循环引用的 Map，就可以检测到 StackOverflowException：

 
  at Test(expected=StackOverflowError dot class) 
 public void testRecurrsiveMap2Json() {  
    Map<String, Object> map = new HashMap<String, Object>(); 
    map.put("key", map); 
    JsonUtil.map2Json(map); 
  } 
 

好在服务器处理的 JSON 数据最终都应该转化为简单的 JavaScript 对象，因此，递归引用的可能性很小。

最后，通过 Servlet 或 MVC 框架输出 JSON 时，需要设置正确的 MIME 类型（application/json）和字符编码。假定服务器使用 UTF-8 编码，则可以使用以下代码输出编码后的 JSON 文本：

 
 response.setContentType("application/json;charset=UTF-8"); 
 response.setCharacterEncoding("UTF-8"); 
 PrintWriter pw = response.getWriter(); 
 pw.write(JsonUtil.toJson(obj)); 
 pw.flush(); 
 

小结

JSON 已经是 JavaScript 标准的一部分。目前，主流的浏览器对 JSON 支持都非常完善。应用 JSON，我们可以从 XML 的解析中摆脱出来，对那些应用 Ajax 的 Web 2.0 网站来说，JSON 确实是目前最灵活的轻量级方案。

我比Arnold Daniels更懒，根本就不想用变量。下面有一些技巧让你的代码更少。

1. 使用 || (or) 和 && (and) 操作代替 if.

// 标准写法
$status = fwrite($h, 'some text');
if (!$status) { 
    log('Writing failed');
 }

// 较少的代码
${ 0 } = fwrite($h, 'some text');
if (!${ 0 }) log('Writing failed');

// 更少的代码
fwrite($h, 'some text') or log('Writing failed');

2. 使用三元运算符.

// 标准写法
if ($age < 16) { 
    $message = 'Welcome!';
 } else { 
  $message = 'You are too old!';
 }

// 较少的代码
$message = 'You are too old!';
if ($age < 16) { 
    $message = 'Welcome!';
 }

// 更少的代码
$message = ($age < 16) ? 'Welcome!' : 'You are too old!';

3. 使用for替换掉while.

// 标准写法
$i = 0;
while ($i < 100) { 
  $source[] = $target[$i];
  $i += 2;
 }

// 较少的代码
for ($i = 0; $i < 100; $source[] = $target[$i+=2]);

4. 很多地方是必须写变量。例如： PHP fluent API tips 。 例如：一个函数调用得到一个数组，然后直接使用数组元素。

//下面这个例子会发生错误，因为函数调用，返回的数组没有先赋值给一个变量，而直接使用['extension']。

$ext = pathinfo('file.png')['extension'];
// result: Parse error: syntax error, unexpected '[' in ... on line ...

你可以建立一个函数来解决这个问题，如下：(相当不错的方法，看着有点别扭...)

// returns reference to the created object
function &r($v) {  return $v;  }
// returns array offset
function &a(&$a, $i) {  return $a[$i];  }

5. 多花时间去研究php自带的函数方法，PHP有很多很有趣的方法能使你的代码更短。

6. 当写更多的代码可以使程序更清晰的时候，不要懒惰。 多花时间写注释，尽量写易读的代码。这才是真正节约时间的技巧。(多写注释和易读的代码，在以后修改调试的时候会节约时间)

JsCron的使用方法如下:

35 17 * * * hola()

按顺序从左到右分别是：

分钟[ 0-59 ]
小时 [0-23]
日[ 0-31 ]
月[ 0-12 ]
星期Ｎ[ 0-7 ]
执行的函数

JAVASCRIPT: 
 
var jsCron = { 
　　items:[],
　　interval: null,
　　parse: function(strUnix) { 
　　　　return strUnix.match(/^(\d+|\*) (\d+|\*) (\d+|\*) (\d+|\*) (\d|\*) +(\w+)/);
　　 },
　　check: function() { 
　　　　var hoy = new Date();
　　　　var test = [new Date(),
　　　　　　　　　　hoy.getMinutes(),
　　　　　　　　　　hoy.getHours(),
　　　　　　　　　　hoy.getDate(),
　　　　　　　　　　hoy.getMonth(),
　　　　　　　　　　hoy.getDay()];
 
　　　　for (var i in this.items) { 
　　　　　　var exec = 0;
　　　　　　var t = this.parse(this.items[i][1]);
　　　　　　for (var x in t)
　　　　　　if (t[x] && (t[x] == test[x] || t[x] == "*"))exec++;
　　　　　　if (exec == 5 && this.items[i][0] == 0) { 
　　　　　　　　eval(t[6]).call();
　　　　　　　　this.items[i][0] = 1;
　　　　　　 } else if (exec <5 && this.items[i][0] == 1) { 
　　　　　　　　this.items[i][0] = 0;
　　　　　　 }
　　　　 }
　　 },
　　set: function(strUnix) { 
　　　　if (!/^(\d+|\*) (\d+|\*) (\d+|\*) (\d+|\*) (\d|\*) +(\w+)/.test(strUnix))
　　　　　　return new Error("Formato invalido");
　　　　this.items.push([0, strUnix]);
　　 },
　　init: function(seg) { 
　　　　var seg = seg || 1000;
　　　　this.interval = setInterval("jsCron.check()", seg);
　　 }
 };
jsCron.init();