方法一：
http://xxx.do?ptname=''我是中国人''
String strPtname = request.getParameter(“ptname”);
strPtname = new String(strPtname.getBytes(“ISO-8859-1”), “UTF-8”);
方法二：
<%@ page contentType=”text/html;charset=gb2312” %>
<a href=”ds.jsp?url=<%=java.net.URLEncoder.encode(“编码的是这里”,”GB2312”)%>”>点击这里</a>
<%
//request.setCharacterEncoding(“GBK”);
if(request.getParameter(“url”)!=null){
str=request.getParameter(“url”);
str=java.net.URLDecoder.decode(str,”GB2312”);
str=new String(str.getBytes(“ISO-8859-1”));
out.print(str);
}

%>

public String chinatoString(String str){
String s=str;
try{
byte tempB[]=s.getBytes(“ISO-8859-1”);
s=new String(tempB);
return s;
}catch(Exception e){
return s;
}

}

function URLencode(sStr){
return escape(sStr).
replace(/+/g, ‘’%2B’’).
replace(/\”/g,’’%22’’).
replace(/\’’/g, ‘’%27’’).
replace(/\//g,’’%2F’’);
}
方法三：
如果用jstl的话，可以自己写一个el的function，调用URLEncoder.encode来编码。

IE缺省对URL后面的参数是不编码发送的，但是tomat缺省是按ISO8859-1来进行URL解码，因此才会出现上述错误。好的做法是：

1、在URL参数中确保用UTF-8编码之，方法可以用js函数encodeURI()，或调用自定义的el function；

2、设置server.xml中的Connector熟悉URIEncoding=”UTF-8”，确保解码格式与编码格式统一；

方法四：
<script>
for(var i=0;i<document.links.length;i++){
document.links[i].href=encodeURI(document.links[i].href);
}
</script>

在action中，String s=request.getParameter(“s”);s=new String(s.getBytes(“iso-8859-1”),”gbk”);

原文 : http://www.cnblogs.com/liupeizhi/articles/1945662.html

编写java web的程序，不可避免都要处理编码问题，最常见的问题就是中文乱码

大概的思路就是重新编码为gbk或者gb2312，分两种情况

一是get和post形式

二是AJax 形式

第一种：GET和POST，取决于你的页面编码，如果你的页面编码为iso8859_1

使用：String str= new String(req.getParameter(“str”).toString().getBytes(“iso8859_1”), “GBK”);

或者 String str= new String(req.getParameter(“str”).toString().getBytes(“iso8859_1”), “GB2312”);

但是，这里要注意，必须保证你的页面编码也是iso8859_1的，因为，上面的代码的意思是先将你的字符串变为iso8859_1字节流，

然后再转化为GBK编码，如果你页面传过来的编码是utf-8，那么按照上面的方法就会出现：???乱码

你页面是utf-8的，就要使用如下编码：

String str= new String(req.getParameter(“str”).toString().getBytes(“utf-8”), “GBK”);

或者 String str= new String(req.getParameter(“str”).toString().getBytes(“utf-8”), “GB2312”);

总之get post 原则很简单，页面什么编码就转化什么字节流转化编码

第二：Ajax传值

这个比较麻烦，据测试，不同的浏览器有不同的对中文编码，怎么办呢？

我们可以采用js的encodeURI()进行统一的编码，然后在后台进行统一的解码

对应的java解码代码：

str= java.net.URLDecoder.decode(str, “UTF-8”);

当 然，因为他是utf-8编码，所以也可以采用第一种get post 介绍的方法解码(据测试， 用 String(req.getParameter(“str”).toString().getBytes(“utf-8”), “GB2312”) 解码js的encodeURI()时，会出现乱码，所以还是老老实实的使用java.net.URLDecoder.decode(str, “UTF- 8”);)

不好意思，刚刚查了资料，上面讲的Get方式有错：

Tomcat对于GET请求并不会考虑使用 request.setCharacterEncoding方法设置的编码，而会永远使用iso-8859-1编码，而这位朋友使用的正好是GET请求， 因此，tomcat将会使用iso-8859-1将提交的字节转换成字符串。

所以，对于使用get方式传值的时候，统一使用String str= new String(req.getParameter(“str”).toString().getBytes(“iso8859_1”), “GBK”);当然，前提是你服务器是tomcat
原文:

http://www.cnblogs.com/dodohua/archive/2011/03/08/1977367.html

简介

许多编程语言中,函数的原型是声明一个子例程或函数。(这个术语是c/c++特定的;其他的术语,对这一概念是签名、类型和接口).在基于原型的编程(面向对象编程的一种形式),新对象克隆现有的对象称为原型.

该模型也可以称为classless,基于原型或基于实例的编程.委派是是支持基于原型的编程语言的特征.

在基于类的语言中,对象(object)结构是由程序员定义的,指定的类型叫做类(class).当类用来定义数据的类型,对象将具有功能,实例是 基于该模型的具体类的“可用”对象.在这个模型中,类充当集合的行为(method)和结构,对所有实例都是相同的,而实例持有对象的数据.因此这个角色 的区别一方面主要是基于结构和行为之间的区别,另一方面是状态(state).

基于原型编程的主张者经常认为,基于类的语言鼓励一种发展模式,第一集中在分类和类之间的关系上.相比之下,基于原型的编程被视为鼓励程序员关注同 一集合的例子行为,只在后期考虑将这些对象分类到原型对象,之后使用和类就非常的相似.因此,许多基于原型系统鼓励在运行时改变原型,而只有很少的基于类 的面向对象的系统让类能够在执行程序期间改变.

几乎所有的基于原型系统都是基于解释和动态类型语言.系统基于静态类型语言是技术上可行.然而,欧米茄语言在基于原型编程的讨论的一个例子就是这样 的一个系统.但据欧米茄的网站介绍欧米茄不仅仅是静态的,而是它的”编译器可以选择使用静态绑定,这是可能的,并且可以提高程序的效率.”

对象构建

在基于类的语言中,一个新的实例是由类的构造函数创建,一个特定的函数,存储对象成员的一块内存(属性和方法)并返回一个引用块.一组可选的构造函 数参数可以传递数据到函数,数据通常都被属性保管.得到的实例将继承所有的方法和定义类的属性,它作为一种模板,可以构造相似类型对象.

在诸如rhino之类的基于原型的语言没有显式类和直接从其他对象继承的对象,他们通过一个属性联系起来,对于Javascript该属性通常被称为原型(prototype).有两种方法构造新的对象:无中生有ex nihilo(“从什么都没有”)创建对象或通过克隆现有对象.前者是通过某种形式的对象字词提供支持,声明对象的地方都能通过特殊语法如{…}在运行时被定义并直接传递给一个变量.大多数系统都支持各种各样的克隆,无中生有(ex nihilo)对象创建并不那么突出.

支持系统无中生有(ex nihilo)对象创建允许新对象从头开始创建,不从现有的原型克隆.这样的系统提供了一个特殊的语法指定属性和行为且新对象不引用已有对象.在许多原型语言存在一个根对象,通常被称为对象(Object),它被设置为其他对象在运行时创建默认的原型并携带通常需要的方法,如toString()函数来返回一个对象的字符串描述.无中生有(ex nihilo)对象创建一个有用的方面是确保新对象的槽名(slot name)没有和与顶级对象的object的命名空间冲突.(在Mozilla的JavaScript实现中,可以通过设置一个新构造的对象的 proto属性为null来处理).

克隆是指一个过程,一个新对象是通过复制现有对象的行为(它的原型).那么这个新对象带有所有原始对象的特性.从这个点来看,这个新对象可以被修改.在一些系统中生成的子对象维护一个显式的关联(通过 delegation or resemblance)到其原型.原型的变化使得相应的克隆对象发生明显的变化.

委派 Delegation

基于原型语言使用委派,语言运行时能够调度正确的方法或找到正确的数据块的简单地遵循一系列的委派指针(从对象到它的原型)直到找到相匹配的对象. 要求对象之间建立这种共享行为的是委派指针.不像基于类的面向对象的语言中类和实例之间的关系,原型和其分支不需要子对象有一个内存或结构相似的原型超出 这个关联.因此,子对象可以继续进行修改和补充,而不必像基于类的系统一样重新整理相关原型的结构.同样重要的是要注意,不仅仅是数据,方法也可以进行添 加或更改.由于此原因,大部分基于原型的语言涉及的数据和方法都是”槽(slot)”.

串联 concatenative

在纯粹的原型中,这也称为关联(concatenative)的原型.一个对象被复制没有可见的指针或联接(link)到原始的原型.原型对象(prototype object)完全拷贝,但给出一个不同的名称(或引用).行为和属性是简单地重复原有(as-is).

这种方法的一个优势在于,对象的作者可以修改这个副本,而不担心对父级的其他孩子产生副作用.另一个优势是这种方式在分派(dispatch)的时 候查找运算成本比委派(delegation)更低.而找到一个方法或确认一个槽(slot)穷举搜索必须(在失败之前)查找整个委派链 (delegation chain).

不足的是关联(concatenative)方式包括组织难以通过系统传播变化,如果一个变化发生在一个原型,它不会立刻或自动地对其克隆对象可 用.另一个缺点是,在最纯粹的这个模型的实现中,在这一部分的每个克隆增加的内存被浪费了(与委派模型相比),该部分内存使得原型和克隆之间保持一致.

javascript prototype示例:

var base = function(){
}
base.prototype.name = “base”;

var a = new base();
var b = new base();
a.name = “a”;
b.age = 11;
console.info(a.name)
console.info(b.name)
console.info(b.age)
var base = function(){ }
base.prototype.name = “base”;
var a = new base();
var b = new base();
a.name = “a”;
b.age = 11;
console.info(a.name);//out a
console.info(b.name);//out base
console.info(b.age);//out 11

而java中实现原型对象创建则主要是使用clone()克隆:

public abstract class Father implements Cloneable {
public Object clone() {
Object object = null;
try {
object = super.clone();
} catch (CloneNotSupportedException exception) {
System.err.println(“Father is not Cloneable”);
}
return object;
}
}

public class Son extends Father {

public Son(){

this.setName(“hello”);

};

public static void main(String args[]){

Father t = new Son();

Father t2 = (Father) t.clone();//克隆对象

System.out.println(t2.getName());//克隆对象具有方法

}

}

反射的介绍

反射是指一种特定类型的计算机程序:能够在运行时，以一种依赖于它的代码的抽象特性，而更改它的运行时(Run time)行为的特性.用比喻来说，那种程式能够“观察”并且修改自己的行为.

最早的计算机在它们的原生汇编语言里编程,它本质上是反射,因为它是由定义编程指令作为数据.反射功能,如修改指令或分析它们是很平常的.编程迁移到更高层次的语言如C,这种实践消失了,直到带有反射特性的编程语言在它们的类型系统中出现.

Brian Cantwell Smith在1982年的博士论文中介绍了编程语言的计算反射的这种概念,并且在meta-circular解释器的概念中用作Lisp的一个组成部分.

反射可以用于观察和/或修改程序在运行时的执行.一个reflection-oriented程序组件可以监测一个范围内的代码执行情况,可以根据期望的目标与此相关的范围修改本身.这通常是通过在运行时动态分配程序代码实现.

在面向对象的编程语言如Java中,反射允许在编译期间不知道接口的名称,字段、方法的情况下在运行时检查类、接口、字段和方法.它还允许的实例化新对象和调用的方法.

反射还可以用来动态地适应给定的程序在不同情况。例如,考虑一个应用程序,它使用两个不同的类X和Y互相交替执行类似的操作.没有 reflection-oriented编程,应用程序可能是硬编码的,以调用方法名称的类X和类Y.然而,使用reflection-oriented 编程范式中,应用程序可以在没有硬编码方法名称情况下利用反射设计和编写调用类中的方法X和Y.Reflection-oriented编程几乎总是需要 更多的知识,框架,关系映射和对象关联,以利用更通用的代码执行.reflection-oriented编程的使用可以在某种程度上避免硬编码.

反射经常作为软件测试的一部分,比如运行时创建/实例化模拟对象.

反射也是元编程的一个关键策略.

一个语言支持反射提供在运行时可用的许多功能,否则其只会在令人费解的较低级别的语言完成.以上的这些特征的能力是:

• 发现并修改源代码的结构(如代码块、类、方法、协议等)作为一个第一型的运行时对象.
• 转换一个字符串来匹配一个class或者function的符号以进入一个引用或者来调用这个类或函数.
• 计算一个字符串,就好像它是一个在运行时源代码语句.
• 创建一个新的语言字节码解释器来给编程构造一个新的意义或用途.
  这些特性可以用不同的方法实现.

编译语言依赖于他们的运行时系统提供有关源代码的信息.一个objective-c编译的可执行文件,例如,记录所有方法的名字在一块可执行文件, 提供一个表来对应这些与底层的方法(或这些方法的选择器)编译进程序.在编译语言,支持运行时创建的功能,例如Common Lisp,运行时环境必须包括一个编译器或解释器.

反射可以为没有内置的反射工具的语言实现,其通过使用一个程序转换系统来定义自动的源代码变更.

反射在语言中的实现

首先在java中,反射是AOP实现的关键,其允许获取并修改类的内部结构和方法:

import java.lang.reflect.InvocationTargetException;

public class ReflectTester {

public static void main(String[] args) throws ClassNotFoundException, IllegalArgumentException, SecurityException,
IllegalAccessException, InvocationTargetException, NoSuchMethodException, InstantiationException {
// Without reflection
new Foo().hello(“Jim”);

// With reflection
Class<?> clazz = null;
clazz = Class.forName(“Foo”);
clazz.getMethod(“hello”,String.class).invoke(clazz.newInstance(),”Lee”);
}
}

class Foo {
private String name;

public Foo() {
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public void hello(String name) {
System.out.println(“Hello “ + name);
}
}

在python中通过globals()方法来实现反射机制,其将字符参数转化为对象实例:

>>> class obj:
def init(self, str):
print str

>>> var = ‘obj’
>>> instance = globals()[var]
>>> instance
<class main.obj at 0x00B1F0A0>

同样在javascript中也提供反射机制:

如在对象中遍历获取一个属性及其值

for (var member in object) {
alert(‘Name: ‘ + member);
alert(‘Value: ‘ + object[member]);
}

evel函数同样可以用来将string以函数方式执行:

// Without reflection
new Foo().hello()

// With reflection
// assuming that Foo resides in this
new this‘Foo’‘hello’

// or without assumption
new (eval(‘Foo’))()‘hello’

// or simply
eval(‘new Foo().hello()’)

资源:

http://en.wikipedia.org/wiki/Reflection_(computer_programming)

4月份的时候去复旦曦园看樱花了,非常漂亮,下面是整理好的樱花图片链接:

复旦樱花 Cherry blossom

复旦樱花2 Cherry blossom

复旦樱花3 Cherry blossom

复旦樱花4 Cherry blossom

在数学和计算机科学中，高阶函数是至少满足下列一个条件的函数:

• 接受一个或多个函数作为输入
• 输出一个函数
  在数学中它们也叫做运算符或泛函。微积分中的导数就是常见的例子，因为它映射一个函数到另一个函数.

例如:函数f(x) = x²;函数f(x)的导数为2x;2x也为一个函数，所以导数是高阶函数.

wiki中关于第一型介绍如下:

a first-class citizen (also object, entity, or value), in the context of a particular programming language, is an entity that can be constructed at run-time, passed as a parameter, returned from a subroutine, or assigned into a variable. In computer science the term reification is used when referring to the process (technique, mechanism) of making something a first-class object.

第一型,在特定编程语言上下文中,是一个在运行时能够构建的实体,作为一个参数传递,返回子程序,或者赋值给一个变量.在计算机科学中,这个词具体指一个过程(技术,机制)使得某事物成为第一类型对象.

同样在Automatic memoization中也有关于第一型对象的介绍:

In programming languages where functions are first-class objects (such as Lua, with its first-class functions, Python, or Perl [1]), automatic memoization can be implemented by replacing (at run-time) a function with its calculated value once a value has been calculated for a given set of parameters. The function that does this value-for-function-object replacement can generically wrap any referentially transparent function.

在函数是第一型的编程语言中(比如lua,和其第一型函数,Python,或者Perl),自动制表能够这样实现:一旦一个函数为给出了一系列的参 数作了计算,用函数的计算值来替换函数本身.函数的 value-for-function-object替换通常能够包装任何涉及的函数.

以一个g(f,7)= (7+3)×(7+3)的函数为例,其中f(x) = x+3 是里面作为参数的函数,同样作为函数返回,f(x)是第一型函数.

函数式语言中的高阶函数实现

该函数的Python的实现为：

def f(x):
return x + 3

def g(function, x):
return function(x) * function(x)

print g(f, 7)

同样具有函数式语言特性的javascript的实现也很简单:

function f(x){
return x + 3;
}
function g(func, x){
return func(x) * func(x);
}
alert(g(f, 7));

而java不具备函数式语言的特性,但是可以用接口和泛型来进行模拟,具体介绍如下:

java中的高阶函数实现

首先新建接口 Func.java

package com.func;
public interface Func<R,P> {
//这里的R和P可以是java中各种主要类型,apply作为要实现的函数.
public R apply(P param);
}

在类PlusThree.java中我们可以实现f(x) = x+3这个函数.

package com.func;

public class PlusThree implements Func<Double, Double> {
public Double apply(Double param) {
return param + 3;
}
}

Test.java中则实现g(x)函数

package com.func;

public class Test {
//静态方法g实现g(x) = f(x)f(x)这个函数
public static Double g(Func<Double, Double> f, double x1) {
return f.apply(x1) f.apply(x1);
}

public static void main(String[] args) {
//调用实现的函数来作为参数进行运算
System.out.println(g(new PlusThree(), 7));
//通过一个匿名类来实现f(x)=x+3这个函数
System.out.println(g(new Func<Double, Double>() {
public Double apply(Double param) {
return param + 3;
}
}, 7));
}
}

专有词汇:

hypothetical box 假设盒
automatic table layout algorithm 自动table布局算法
shrink-to-fit 收缩适应
computed value 计算值
used value 使用值
glyph 字形,图像字符
ascender 字母的上出头部分
descender 字母的下出头部分
Ascent 上升
Descent 下降

10.1 包含块的定义 Definition of “containing block”

一个元素的框的尺寸和位置的计算有时相对于某个特定的长方形，称为该元素的包含块。一个元素的包含块的定义如下:

1. 在根元素存在的包含块是一个矩形称作初始包含块.对于连续媒体,它具有视口的尺寸并且其锚在canvas的原点;它是分页媒体的页面区域.初始包含块的’direction’属性和根元素一样.
2. 对于其它元素,如果元素的位置是’relative’ 或者 ‘static’,包含块由最近的块容器的祖先盒子的内容边界形成.
3. 如果元素设置了’position: fixed’，在连续媒体或者页面区域在分页媒体这两种情况下包含块由视口创建.
4. 如果元素设置了’position: absolute’,包含块由最近’position’是’absolute’, ‘relative’ 或者 ‘fixed’的祖先创建,方式如下:
   1. 在祖先是行内元素的情况下,包含块是绕着第一个和最后一个行内盒子的padding盒子的(为该元素生成的)边界盒.在CSS 2.1中,如果行内元素分跨多行,包含块是未定义的.
   2. 否则, 由祖先的padding边形成.

如果没有该祖先,包含块是初始包含块.

在分页媒体,一个绝对的定位元素的定位相对于它的包含块忽略任何页面中断符(好像文档是连续的).该元素可能随后打断几个页面.

对于绝对定位内容处理一个页面的定位不同与页面进行布局(当前页面),或者处理一个当前页面的位置其已经为打印渲染完成,打印机可能放置该内容

• 在当前页面的另一个位置
• 在随后的页面,或者
• 可能忽略它.
  注意一个块级元素分跨多页可能在每个页面有一个不同的宽度,且它们可以受特定设备限制.
  不考虑定位，下面文档的包含块(C.B.):

<HTML>
<HEAD>
<TITLE>Illustration of containing blocks</TITLE>
</HEAD>
<BODY id=”body”>
<DIV id=”div1”>
<P id=”p1”>This is text in the first paragraph…</P>
<P id=”p2”>This is text <EM id=”em1”> in the
<STRONG id=”strong1”>second</STRONG> paragraph.</EM></P>
</DIV>
</BODY>
</HTML>

是这样创建的:

For box generated by

C.B. is established by

html

initial C.B. (UA-dependent)

body

html

div1

body

p1

div1

p2

div1

em1

p2

strong1

p2



如果我们定位”div1”：

#div1 { position: absolute; left: 50px; top: 50px }

它的包含块不再是”body”；而是初始包含块(因为没有其它定位的父级盒).

如果我们再定位”em1”:

#div1 { position: absolute; left: 50px; top: 50px }

#em1 { position: absolute; left: 100px; top: 100px }

包含块的表格成为:

For box generated by

C.B. is established by

html

initial C.B. (UA-dependent)

body

html

div1

initial C.B.

p1

div1

p2

div1

em1

div1

strong1

em1



“em1”定位后，它的包含块成为最靠近的前辈定位盒(即，由”div1”创建的那一个).

10.2 内容的宽度：‘widht’属性

‘width’
值: <length> | <percentage> | auto | inherit
初始值: auto
适用于: 所有元素,除了行内非替换元素,表格行和行组(row groups).
可否继承: 否
百分比: 基于包含块的宽度
媒介: 图形
计算值: 百分比或者指定为”auto”或者绝对绝对长度

该属性指定盒子的内容宽度。

该元素并不适用于非替换的行内元素.非替换行内元素盒的宽度是它们中内容渲染后（在任何子元素相对偏移之前）的宽度.我们应该记得行内盒排列在行盒内.而行盒的宽度由它们的包含块给出，但是可能由于出现浮动而被缩短.

属性值的含义如下:

<length>
使用一个长度单元指定一个固定宽度.
<percentage>
指定一个百分比宽度.百分比的计算基于生成盒的包含块的宽度. 如果包含块的宽度依据该元素的宽度,那么布局结果在css 2.1中未定义.注意:对绝对定位元素包含块基于一个块容器元素,百分比根据该元素的padding盒的宽度进行计算.这个和css1不同,其百分比宽度总是根据内容盒子的父级元素进行计算.
auto
宽度取决于其它属性的值。参加以后的节.
负的‘widht’值是非法的.

例子:

例如,下面的规则将段落的内容宽度固定为100点:

P { width: 100px }

10.3 宽度和边距的计算

一个元素的‘widht’，‘margin-left’，‘margin-right’，‘left’和‘right’属性的计算值取决于产生的盒的类型，并互相影响(用于布局的值称作使用值)。一般而言，计算值和指定值相同，’auto’被某个合适的值取代,并且百分比根据包含块来进行计算。不过还是有例外。下面这些情况需要加以考虑:

1. 行内的非替换元素
2. 行内的替换元素
3. 常规流向中的块级、非替换元素
4. 常规流向中的块级、替换元素
5. 浮动的非替换元素
6. 浮动的替换元素
7. 绝对定位的非替换元素
8. 绝对定位的替换元素
9. 常规流向中的’inline-block’、非替换元素
10. 常规流向中的’inline-block’、替换元素
    1-6和9-10,相对定位元素的案例中的’left’和’right’值由9.4.3章节的规则决定.

注意:’width’在下文使用的值是个假设性的值,并且它可能会根据‘min-width’和‘max-width’计算多次,见下文Minimum and maximum widths章节.

10.3.1 行内的非替换元素

‘width’属性不适用。‘margin-left’或‘margin-right’ ‘auto’ 的计算值的实际使用值是’0’.

10.3.2 行内的替换元素

‘margin-left’或‘margin-right’ ‘auto’的计算值的实际使用值是’0’.

如果‘height’和‘widht’的计算值都是’auto’并且元素有固定的宽度,那么固定宽度使用值为‘width’的值.

如果‘height’和‘widht’的计算值都是’auto’并且元素没有固定的宽度,但其有一个固定高度和固定比例;或者如果‘width’的计算值是’auto’,‘height’有其他的计算值,并且元素没有固定比例;那么‘width’使用值是:

(使用高度)*(固定比例)

如果‘height’和‘widht’的计算值都是’auto’并且元素有固定的比例,但没有固定的高度和宽度,那么‘widht’的使用值在css 2.1中未定义.然而,建议如果包含块的宽度不是根据替换元素的宽度,那么‘widht’的使用值由块级的约束等式计算而来,不可替换元素在普通流中.

否则,如果‘width’有一个计算值’auto’,并且元素有一个固定宽度,那么固定宽度使用值为‘width’的值.

否则,如果‘width’有一个计算值’auto’,但上面的条件都不符合,那么‘width’的使用值设为300px.如果300px对设备来说太宽,客户端应该使用宽度适合设备的比例为2:1的最大矩形来代替.

10.3.3 常规流中的块类、非替换元素

以下的约束必须保持其他属性的使用值:
‘margin-left’ + ‘border-left-width’ + ‘padding-left’ + ‘width’ + ‘padding-right’ + ‘border-right-width’ + ‘margin-right’ = 包含块的宽

如果‘width’不 是’auto’并且’border-left-width’ + ‘padding-left’ + ‘width’ + ‘padding-right’ + ‘border-right-width’ (加上任意的 ‘margin-left’ or ‘margin-right’ 而值不是 ‘auto’) 大于包含块的宽度,那么’margin-left’ 或者 ‘margin-right’的值是’auto’,依照下面的规则,设置为0.

如果上述所有的属性指定了非’auto’的值，这些值被称为是”过度约束”，其中之一的计算值将不得不和它的指定值不同.如果‘direction’属性为’ltr’，‘margin-right’的指定值被忽略,并重新计算以满足上面的等式。如果‘direction’为’rtl’,对‘margin-left’采取上述的方法.

如果只有一个值指定为’auto’，它的计算值从等式中得出。

如果‘width’设置为’auto’，则其它的’auto’值成为’0’而‘width’从等式的剩余部分得到。

如果‘margin-left’和‘margin-right’为’auto’，它们的使用值相同.相对于包含块的边缘水平地居中该元素.

10.3.4 常规流向中的块类、替换元素

‘width’的使用值取决于行内替换元素.然后非替换块级元素的规则被应用来决定margin.

10.3.5 浮动的非替换元素

如果‘margin-left’或‘margin-right’指定为’auto’，它们的使用值为’0’.

如果‘width’计算为’auto’,使用值是”shrink-to-fit”宽度.

shrink-to-fit宽度的计算类似计算table cell的宽度使用自动table布局算法.概略地:通过格式化除换行符外的内容而不是明确的换行符发生的位置来计算优先的宽度,同样计算优先的最小宽度 等等.CSS 2.1没有定义明确的算法.第三,找到有效的宽度:在这个例子中,这个是包含块的宽度减去’margin-left’, ‘border-left-width’, ‘padding-left’, ‘padding-right’, ‘border-right-width’, ‘margin-right’, 和任意相关滚动条的使用值.

那么shrink-to-fit 宽度是: min(max(优先的最小宽度, 有效的宽度), 优先宽度).

10.3.6 浮动的替换元素

如果‘margin-left’或‘margin-right’指定为’auto’，它们的使用值为’0’。’width’的使用值取决于行内替换元素.

10.3.7 绝对定位的非替换元素

对于该章节和下一章节,”static position”(对于一个元素)条款,大概地,对于该定位一个元素将在普通流.更准确地:

• static-position包含块是一个假设的盒的包含块,如果指定‘position’值为’static’并且’float’设定为’none’其将是元素的第一个盒(注意对于9.7章节的规则计算同样需要给’display’赋一个计算过的值.)
• 如果‘position’属性是’static’且‘float’是’none’,静态定位对于’left’是从包含块的左边界到一个假设盒的左margin的距离其将是元素的第一个盒子.如果假设盒相对于包含块的左边的值是负的.
• 静态定位对于’right’是从包含块的右边界到和上面一样的假设盒的右margin边界.如果假设盒是相对于包含块的左边该值是负的.
  但如果不是实际地计算假设盒的尺寸,客户端可以自由地设定一个可能的定位.

对于计算静态定位的目的,固定定位元素的包含块是初始包含块而不是视口.并且所有可滚动盒应该假定滚动到其原点.

约束决定这些元素的使用值为:

‘left’ + ‘margin-left’ + ‘border-left-width’ + ‘padding-left’ + ‘width’ + ‘padding-right’ + ‘border-right-width’ + ‘margin-right’ + ‘right’ = 包含块的宽度

如果’left’, ‘width’, 和 ‘right’ 三个属性的值都是 ‘auto’:首先将’margin-left’ 和 ‘margin-right’的任何’auto’值设置为0.然后,如果元素的’direction’属性建立static-position包含块是 ‘ltr’设置’left’给静态定位并且应用下面的3号规则;否则,设置’right’给静态定位并且应用下面的1号规则.

==============================================

如果三个值都不是’auto’:如果’margin-left’ 和 ‘margin-right’都是’auto’,在额外的约束下解决这个方程式,这两个margin的值相等,除非这将使它们为负,在这个案例中当包含块 的direction是’ltr’(‘rtl’),设置’margin-left’ (‘margin-right’)为0并且求出’margin-right’ (‘margin-left’).如果’margin-left’ 或 ‘margin-right’ 中有一个值是 ‘auto’,求出该值的方程式.如果值是过度约束的,忽略’left’(在例子中包含块的’direction’属性是’rtl’)或 ‘right’(在例子中’direction’是’ltr’)的值并求出该值.

否则,将’margin-left’ 和 ‘margin-right’的’auto’值设置为0,并在下面6个规则中采用一个:

1. ‘left’和’width’都是’auto’且’right’不是’auto’, 那么width是shrink-to-fit. 然后求出’left’
2. ‘left’和’right’值是’auto’并且’width’不是’auto’,那么如果元素的’direction’属性建立static-position的包含块是’ltr’设置’left’给静态定位,否则设置’right’给静态定位.然后求出’left’(如果’direction’值是’rtl’)或’right’(如果’direction’值是’ltr’)
3. ‘width’和’right’都是’auto’但’left’不是’auto’, 那么宽度是shrink-to-fit.然后求出’right’
4. ‘left’值是’auto’, ‘width’和’right’值不是’auto’, 那么求出’left’
5. ‘width’值是’auto’, ‘left’和’right’都不是’auto’,那么求出’width’
6. ‘right’值是’auto’, ‘left’和’width’都不是’auto’,那么求出’right’
   shrink-to-fit width的计算类似计算一个table cell的width使用自动table布局算法.大概地:概略地:通过格式化除换行符外的内容而不是明确的换行符发生的位置来计算优先的宽度,同样计算 优先的最小宽度等等.CSS 2.1没有定义明确的算法.第三,计算有效宽度:这建立在设置’left’(在例1)或’right’(在例3)为0之后求出’width’.

那么shrink-to-fit宽度是: min(max(优先的最小width, 有效width), 优先的width).

10.3.8 绝对定位的替换元素

在这种情况下,通过章节10.3.7适用,包括约束方程,但10.3.7章节其余的部分被以下规则取代:

1. ‘width’的使用值由行内替换元素决定.如果’margin-left’或’margin-right’设定为’auto’使用值由下面的规则决定.
2. 如果’left’和’right’值为’auto’,那么如果元素的’direction’属性建立static-position包含块是’ltr’,设置静态定位为’left’;否则如果’direction’是’rtl’,设置静态定位为’right’.
3. 如果’left’或者’right’为’auto’, 将’margin-left’或’margin-right’的with的’auto’值用’0’替换.
4. 如果这时候’margin-left’和’margin-right’仍然都是’auto’在两个margin必须等值这个额外的约束下 求出等式,除非这个使得它们为负,在这个例子中当包含块的direction是’ltr’(rtl),设置’margin-left’ (‘margin-right’)为0并求出’margin-right’(‘margin-left’).
5. 如果这个时候有一个’auto’剩下,求出该值的等式.
6. 如果这个时候值是过度约束的,忽略’left’(在例子中包含块的’direction’属性是’rtl’)或者’right’(在例子中’direction’是’ltr’)的值求出该值.

10.3.9 普通流中的’Inline-block’, 不可替换元素

如果’width’值是’auto’, 浮动元素的使用值是shrink-to-fit宽度.

‘margin-left’或者’margin-right’的一个计算值’auto’设置为使用值’0’.

10.3.10 普通流中的’Inline-block’, 替换元素

和行内替换元素一致

10.4 最小和最大宽度:’min-width’及’max-width’

‘min-width’

值: <length> | <percentage> | inherit
初始值: 取决于用户端
使用于: 所有元素,除了非替换行内元素,表格行元素和行元素组
可否继承: 否
百分比: 基于包含块的宽度
媒介: 图形
计算值: 设定的百分比或者绝对长度

‘max-width’

值: <length> | <percentage> | none | inherit
初始值: none
适用于: 所有元素,除了非替换行内元素,表格行元素和行元素组
可否继承: 否
百分比: 基于包含块的宽度
媒介: 图形
计算值: 设定的百分比或者绝对长度或者’none’

这两个属性允许作者将内容的宽度限制在一个确定的范围内.取值的含义如下:
<length>
指定一个固定的最小和最大的使用的宽度.

<percentage>
指定确定使用值的百分比.百分比的计算基于生成盒的包含块的宽度.如果包含块的宽度是负的,那么使用值是0.如果包含块的宽度根据元素的宽度,那么生成布局在CSS 2.1中未定义.

none
（仅用于’max-width’）对盒的宽度没有限制.

负的’min-width’和’max-width’是非法的.

在CSS2.1,tables, inline tables, table cells, table columns, 和column groups的’min-width’ 和 ‘max-width’效果未定义.

下面的算法描述了这两个属性如何影响’width’属性的使用值:

1.试验性的使用宽根据上文中的”Calculating widths and margins”规则来计算(除了’min-width’和’max-width’).
2.如果试验性的使用宽大于’max-width’,上面的规则再次被应用,但是’max-width’使用的计算值和’width’使用的计算值一样.
3.如果结果宽度小于’min-width’,上面的规则又被应用,但是’min-width’使用的计算值和’width’使用的计算值一样.

这些步骤不会影响以上属性真实的计算值.

然而,对于固定比例的’width’和’height’指定为’auto’的可替换元素,算法如下:

选择table为适当的约束违例求出高度和宽度值.把max-width和max-height当作max(min, max)那么min ≤ max为真.在这个table w和h代表width和height的计算结果忽略’min-width’, ‘min-height’, ‘max-width’ and ‘max-height’ 属性.通常这些事固定的宽度和高度,但是他们可能不在固定比例的替换元素的例子中.

注意:在例子中当一个明确的宽度或者高度设定了,并且其他尺寸是auto,应用一个最小或者最大约束在auto的边会导致过度约束的发生.规范在行为上是清楚的但是它可能不是作者期望的.CSS3 object-fit属性能够用来在这个情形下获取不同的结果.

Constraint Violation约束违例

Resolved Width求宽

Resolved Height求高

none

w

h

w > max-width

max-width

max(max-width * h/w, min-height)

w < min-width

min-width

min(min-width * h/w, max-height)

h > max-height

max(max-height * w/h, min-width)

max-height

h < min-height

min(min-height * w/h, max-width)

min-height

(w > max-width) and (h > max-height), where (max-width/w ≤ max-height/h)

max-width

max(min-height, max-width * h/w)

(w > max-width) and (h > max-height), where (max-width/w > max-height/h)

max(min-width, max-height * w/h)

max-height

(w < min-width) and (h < min-height), where (min-width/w ≤ min-height/h)

min(max-width, min-height * w/h)

min-height

(w < min-width) and (h < min-height), where (min-width/w > min-height/h)

min-width

min(max-height, min-width * h/w)

(w < min-width) and (h > max-height)

min-width

max-height

(w > max-width) and (h < min-height)

max-width

min-height



然后应用上文”Calculating widths and margins”的规则,好像’width’和这个值一样被计算.

10.5 内容的高度:’height’属性

‘height’
值: <length> | <percentage> | auto | inherit
初始值: auto
适用于: 所有元素，除了非替换行内元素，表格列和列组
可否继承: 否
百分比: 见描述
媒介: 图形
计算值: 百分比或’auto’(见<percentage>下的描述)或绝对长度

该属性指定了盒的内容高度.

本属性不适用于非替换行内元素.见章节computing heights and margins for non-replaced inline elements使用的规则替换.

取值的含义如下:

<length>
使用长度值指定内容区域的高度.
<percentage>
指定一个百分比高度.百分比的计算基于生成盒的包含块的高度。如果包含块的高度没有显式给出(即，它取决于内容的高度),并且该元素不是绝对定位,该值等同于’auto’.在根元素上的百分比高度相对于初始包含块.
注意:对于绝对定位元素其包含块基于一个块级元素,百分比的计算依据该元素的padding盒的高度.这是一个从CSS1的变化,在CSS1中百分比总是依据父元素的内容盒进行计算.

auto
高度取决于其它属性.见下面的描述.

注意一个绝对定位元素的包含块的高度独立于元素本身的尺寸,因此在这样一个元素上的百分比高度总能被求出.然而,可能高度并不知道直到元素进入到文档中已经处理完成.

‘height’的负值是非法的.

例如,下面的规则将段落的高度固定为100点:

P { height: 100px }

高度超过100点的段落将根据’overflow’属性而产生溢出.

10.6 高度和边距的计算

在计算’top’,’margin-top’,’height’,’margin-bottom’和’bottom’的值时,必须对不同种类的框加以区别:

行内的非替换元素
行内的替换元素
常规流向中的块类、非替换元素
常规流向中的块类、替换元素
浮动的非替换元素
浮动的替换元素
绝对定位的非替换元素
绝对定位的替换元素
‘inline-block’,普通流中的不可替换元素
‘inline-block’,普通流中的替换元素

1-6和9-10,’top’ 和 ‘bottom’ 的使用值由9.4.3章节的规则决定.

注意:这些规则应用给根元素就像其他的元素一样.

注意.下面计算的’height’的使用值是一个假设值,并且可能需要多次计算,依据’min-height’ 和 ‘max-height’, 见下面的Minimum and maximum heights章节.

10.6.1 行内的非替换元素

‘height’属性并不适用,内容区域的高度应该基于font,但是这个规范并没有指定.一个客户端可能,举例来说,使用em-box或者字体的 最大的字母的上出头部分和字母的下出头部分.(后者将保证部分靠上或者部分靠下的字形em-box仍然落到内容区域,但是导致不同的字体有不同的尺寸盒 子;样板会允许作者依据’line-height’控制背景样式,但导致字形绘制超出内容区域.)

注意:CSS3将可能包含一个属性来选择font的哪个尺寸用作内容高.

垂直的padding,border和一个行内的margin,不可替换元素盒从内容区域的顶部和底部开始,并且对’line-height’没有影响.但是当计算行盒的高度时仅仅只有’line-height’被使用.

如果多于一个字体被用到(当字形建立在不同的字体内这个将会发生),内容区域的高度在该规范里面没有定义.然而,我们建议高度选择内容区域对em- box或者元素中所有字体的最大的字母上出头部分和字母下出头部分.注意这可能会比涉及的任何字体尺寸都大,根据字体的基线对齐来决定.

10.6.2 行内的替换元素,常规流向中的块类替换元素,常规流向中的’inline-block’替换元素,浮动的替换元素

如果’margin-top’或’margin-bottom’为’auto’,它们的使用值为0.

如果’height’和’width’计算值为’auto’并且元素有一个固定高度,那么固定高度是’height’的使用值.

否则,如果’高度’有一个计算值为’auto’且元素有一个固定比例,那么height的使用值是:

(使用宽)/(固定比例)

否则,如果’height’有一个计算值为’auto’,且元素有一个固定高,那么固定高是’height’的使用值.

否则,如果’height’有一个计算值为’auto’,但都不和上面的情况相符,那么’height’的使用值必须设置为最大矩形的高度其有2:1的比例,高度不大于150px,且宽度不大于设备宽度.

10.6.3 常规流向中的块级非替换元素当’overflow’计算为’visible’

该章节同样应用给常规流向中的块级非替换元素当’overflow’不计算为’visible’但传播到视口.

如果’margin-top’, 或’margin-bottom’为’auto’,它们的使用值是0.如果’height’是’auto’,高度根据是否该元素有任意的块级子元素且是否其具有padding或borders:

元素的高度是从顶部内容边缘到第一个以下可用的情形的距离:

1. 最新的行盒的底边,如果盒子和一至多个行建立一个行内格式化上下文
2. 最新的in-flow子元素的底部(可能收缩的)margin的底边,如果子元素的底部margin没有和元素的底部margin折叠.
3. 最新的in-flow子元素的底部border边其顶margin和元素的底部margin没有重叠.
4. 否则,为0
   只有在普通流中的子元素参与计算(例如,浮动盒子和绝对定位盒子被忽略,且相对定位盒不考虑它们的偏移).注意子盒子可能是个匿名块盒.

10.6.4 绝对定位的非替换元素

对于该章节和下一章节的目标,(一个元素)”static position”引用的条款,概略地,对于定位一个元素将必须在普通流中.更准确地,’top’的静态定位是从包含块的顶边倒假想盒的顶margin边 的距离其将成为元素的第一个盒子如果它指定’position’值为’static’,且指定’float’值为’none’且指定’clear’为 ‘none’.(注意对于 9.7章节的规则这可能需要指定’display’一个不同的计算值.)该值为负如果假想盒在包含块之上.

但是不是实际地计算假设盒的尺寸,用户端可以自由地猜测它的可能位置.

对于计算静态位置,固定定位元素的包含块以初始包含块替代视口.

对于绝对定位的元素，垂直方向的尺寸必须满足如下约束:

‘top’ + ‘margin-top’ + ‘border-top-width’ + ‘padding-top’ + ‘height’ + ‘padding-bottom’ + ‘border-bottom-width’ + ‘margin-bottom’ + ‘bottom’ = 包含块的高度

如果’top’, ‘height’, 和 ‘bottom’三个值都为auto,设置’top’为静态定位应用下面的3号规则.

如果三个值都不是’auto’:如果’margin-top’和’margin-bottom’为’auto’,求出在额外约束下的等式其两个 margin值相等.如果’margin-top’或’margin-bottom’其中一个值为’auto’,求出那个值的等式.如果值超出约束,忽略 ‘bottom’的值并求出该值.

否则,选择下面的六个规则中的一个来应用:

1. ‘top’和’height’为’auto’,’bottom’不是’auto’, 那么高度依据per 10.6.7内容的高度, 设置’margin-top’和’margin-bottom’的’auto’值为0, 并求出’top’.
2. ‘top’和’bottom’都是’auto’,’height’不是’auto’,那么设置’top’到静态定位, 设置’margin-top’和’margin-bottom’的’auto’值为0,并求出’bottom’.
3. ‘height’和’bottom’是’auto’,’top’不是’auto’, 那么高度依据per 10.6.7内容的高度, 设置’margin-top’和’margin-bottom’的’auto’值为0, 并求出’bottom’.
4. ‘top’为’auto’, ‘height’和’bottom’不是’auto’, 那么设置’margin-top’和’margin-bottom’的’auto’值为0, 并求出’top’.
5. ‘height’是’auto’, ‘top’和’bottom’不是’auto’,那么设置’margin-top’和’margin-bottom’的’auto’值为0, 并求出’height’
6. ‘bottom’是’auto’, ‘top’和’height’不是’auto’, 那么设置’margin-top’和’margin-bottom’的’auto’值为0, 并求出’bottom’

10.6.5 绝对定位的替换元素

这一情形和前述类似，只是元素有一个内在高度。替换的顺序变为:

如果’height’为’auto’，将其替换为元素的内在高度。
如果’top’为’auto’，将它替换为：包含块的顶边到假定它的’position’属性设置为’static’，而生成元素的第一个框的那个假想框 的顶边距边的距离。（但是为了不去实际计算那个框，用户端可以自由地猜想它可能在的位置。）如果假想框在包含块上面，该值为负数。
如果’bottom’为’auto’，将’margin-top’或’margin-bottom’的’auto’替换为’0’。
如果在这一步’margin-top’和’margin-bottom’还是’auto’，根据附加的约束，即两个边距必须相等来解出等式。
如果在这一步只有一个’auto’，根据等式解出该值。
如果在这一步各值间过度约束，忽略’bottom’值，然后根据等式解出那个值。

10.6.6 复杂的情况 Complicated cases

这个章节应用给:

• 块级,常规流向中的块级非替换元素当’overflow’不计算为’visible’(除’overflow’属性值被传播到视口).
• ‘Inline-block’, 不可替换元素.
• 浮动, 不可替换元素.
  如果’margin-top’, 或’margin-bottom’为’auto’, 它们的使用值是0. 如果’height’是’auto’, 高度按照10.6.7依照元素的子元素.

对于’inline-block’元素, 当计算行盒的高度时margin盒被使用.

10.6.7 块格式化上下文根的’Auto’高度 ‘Auto’ heights for block formatting context roots

在某些情形(见上面10.6.4和10.6.6章节),一个元素建立块格式化上下文的高度按以下方式计算:

如果只有行内级别子元素,高度是最顶端行盒的顶部到最下面行盒底部的距离.

如果有块级子元素,高度是从最顶端块级子盒的顶部margin-edge到最底部块级子盒的底部margin-edge的距离.

绝对定位子元素被忽略,且相对定位盒子不考虑偏移.注意子盒可能是匿名块盒.

附加的,如果元素有任何浮动后代它的底部margin边在元素底部内容边下面,那么高度增长到去包含它们的边界.只有参与该块格式化上下文的浮动被考虑,等等,在绝对定位里面子元素的浮动或其他浮动不被考虑.

10.7 最小和最大高度:’min-height’和’max-height’

有时将元素的高度控制在一个特定的范围内很有用.有两个属性提供了这样的功能:

‘min-height’
值: <length> | <percentage> | inherit
初始值: 0
适用于: 所有元素，除了非替换行内元素和表格元素
可否继承: 否
百分比: 见正文
媒介: 图形
计算值: 指定的百分比或者绝对长度

‘max-height’
值: <length> | <percentage> | none | inherit
初始值: none
适用于: 所有元素，除了非替换行内元素和表格元素
可否继承: 否
百分比: 见正文
媒介: 图形
计算值: 指定的百分比或者绝对长度

这两个属性允许作者将盒的高度限制在一定的范围内.取值含义如下:

<length>
指定一个固定的最小或最大高度.
<percentage>
指定一个百分比来确定计算值.百分比的计算基于生成盒的包含块的高度.如果包含块的高度没有显式指定(即,它取决于内容的高度),且该元素没有绝对地定位,该百分比值等同于’0’(对于’min-height’)或’none’(对于’max-height’).
none
(仅对’max-height’适用)对盒的高度没有限制.

在CSS2.1,’min-height’和’max-height’在tables, inline tables, table cells, table rows, 和 row groups 上的效果没有定义.

下面的算法描述了这两个属性怎么影响’height’属性的使用值:

1. 假设的使用高度按照上面”Calculating heights and margins”的规则来计算(除’min-height’和’max-height’).
2. 如果假设高度大于’max-height’上面的规则被再次使用,但是这次使用’max-height’的值作为’height’的使用值.
3. 如果假设高度小于’min-height’上面的规则被再次使用,但是这次使用’min-height’的值作为’height’的使用值.
   这些步骤不影响上面属性的真正计算值.使用的’height’的变化对margin的折叠没有影响除”Collapsing margins” (8.3.1)中对’min-height’或’max-height’的规则又特别地要求.

然而,对’width’和’height’计算为’auto’的替换元素,使用上文的Minimum and maximum widths的算法来找到使用的宽度和高度.然后应用上文”Computing heights and margins”的规则,使用width和height的结果就好像它们是计算值.

10.8 行高的计算: ‘line-height’及’vertical-align’属性

就像在行内格式化上下文的章节中描述的,用户端将行内级的盒排列到垂直方向的行盒的堆叠.行盒高度是这样决定的:

1. 在行盒里的每个行内级别盒的高度被计算.对替换元素,inline-block元素,和inline-table元素,该高度是它们 margin盒的高度;对行内盒,该高度是它们的’line-height’.(见”Calculating heights and margins”和 the height of inline boxes 在”Leading and half-leading”.)
2. 行内级盒根据其’vertical-align’属性而在垂直方向对齐,在实例中它们对齐’top’或’bottom’,它们必须 aligned so as to minimize the line box height.如果该盒足够高,有多重方案CSS2.1总没有定义行盒基线的位置(即,srut见下文 的位置).
3. 行盒的高度是最上面的盒的顶边到最下面的盒的底边的距离.(这包含strut,就像下面’line-height’解释的.)
   空的行内元素产生空的行内盒,但是这些盒也包括边距，边白，边框和行高, 因此和那些有内容的元素一样,影响上述的计算.

10.8.1 差异和半差异

CSS假定每个字体有字体矩阵其指定一个字符高度在基线的上面且一个深度在它下面.在这个章节我们使用A代表高度(对一个给出的字体的给定 size)且D是深度.我们同样定义AD=A+D,为从顶部到底部的距离.(见how to find A and D for TrueType and OpenType fonts 的记录),注意这些字体的矩阵作为一个整体且不需要和任何单独字符的上升和下行字母保持一致.

客户端必须在一个不可替换行内盒中通过它们相关的基线对齐每个字符.那么对每个字符,确定A和D.注意字符在单个元素可能来自不同的字体且这样不需要所有 的具有同样的A和D.如果行内盒不包含字符,它被考虑包含一个strut(一个独立的宽度为0的字符)带有元素的首个可用字体的A和D.

仍然对于每个字符,决定添加差异L,当L=’line-height’ - AD. 一半的差异加在A的上面和D下面的一半,giving the glyph and its leading a total height above the baseline of A’ = A + L/2 and a total depth of D’ = D + L/2.

注意.L可能为负.

行内盒的高度在其两边装入所有字符和它们半差异且这是准确地’line-height’.子元素的盒子没有影响该高度.

尽管不可替换元素的margins, borders, and padding不计入行盒的计算,它们仍然在行内盒周围进行渲染.这意味着如果高度同感’line-height’来指定小于包含块的内容高 度,padding和border的backgrounds和colors可能会流入到相邻的行盒.客户端应该在文档顺序中渲染盒子.这将导致随后的行的 border绘制超出之前行的border和文本.

注意.CSS 2.1不定义行内盒子的内容区域(见上文10.6.1),因此不同的客户端可以在不同的地方绘出不同backgrouds和borders.

注意.建议实现上使用OpenType或TrueType字体使用度量标准”sTypoAscender”和”sTypoDescender”从字体的OS/2表和D(在扩展到当前元素的字体大小).在缺乏这些度量标准,”上升”和”下降”指标从HHEA表应该被使用.

‘line-height’
值： normal | <number> | <length> | <percentage> | inherit
初始值： normal
适用于： 所有元素
可否继承： 可
百分比： 基于元素自身的字体尺寸
媒介： 图形
计算值: 对于 <length> 和 <percentage> 绝对值; 否则指定

在一个块容器元素的内容是由inline-level元素,’line-height’在元素中指定行盒的最小高度.最小身高由最小高度在基线和和在其下 面最小深度构成,就好像每个线框始于一个0宽行内盒元素的字体和行高属性。我们称这个假想盒子之为”strut”(这个名字的灵感来源于Tex.).

字体上方的高度和基线下的深度,假定包含在字体的度量中.(有关更多细节,请参阅CSS level 3).

在一个不可替换行内元素,’line-height’指定的高度适用于计算行盒的高度.

该属性取值的含义如下:

normal
指示用户端基于元素的字体尺寸将计算值设置为一个“合理”的值。该值的含义和<number>相同。我们推荐’normal’的计算值在1.0到1.2之间。
<length>
框的高度设置到该数值。负数是非法的。
<number>
该属性的计算值是该数字乘以元素的字体尺寸。负数是非法的。不过，该数字而不是计算值将被继承。
<percentage>
该属性的计算值是百分比乘以元素的计算的字体尺寸。负数是非法的。
例子：

下例的三条规则设置了相同的行高:

DIV { line-height: 1.2; font-size: 10pt } / number /
DIV { line-height: 1.2em; font-size: 10pt } / length /
DIV { line-height: 120%; font-size: 10pt } / percentage /

如果一个元素包含不止一个字体渲染的文本，用户端应该根据最大的字体尺寸来确定’line-height’的值.

注意.当在一个块容器所有的行内盒只有一个’line-height’值,它们都是使用相同的字体(且没有替换元素,inline-block元 素,等等),上面将确保后续行的基线’line-height’是完全分开的.这是重要的,当文本列有不同的字体需要对齐,例如在一个table.

‘vertical-align’
值: baseline | sub | super | top | text-top | middle | bottom | text-bottom | <percentage> | <length> | inherit
初始值: baseline
适用于: 行内元素和表格单元元素
可否继承: 否
百分比: 基于元素自身的’line-height’
媒介: 图形
计算值:<percentage>和<length>绝对的长度,否则和指定的一样

该属性决定一个行内级元素产生的盒在一个行盒内垂直方向的位置.

注意.这些属性的值在表格内容中含义略微有所不同容.请参见表格高度算法以了解更多细节.

以下值只有意义对于父级行内元素,或一个父块容器元素的strut.

在下面的定义,因为行内不可替换元素,用于对齐的盒子是高度是’line-height’的盒子(包含盒子的字形,每一侧的half-leading,见上).对于所有其他元素,盒子用于对齐是margin盒子.

baseline
将盒的基线对齐父框的基线.如果该盒没有基线,将盒的底线对齐父的基线.
middle
将盒的垂直中间点对齐父盒的基线,加上父的x高度的一半.
sub
将盒的基线降低到父框的下标的恰当位置.(该值对元素文本的字体尺寸没有影响.)
super
将盒的基线升高到父框的上标的恰当位置.(该值对元素文本的字体尺寸没有影响.)
text-top
盒的顶对齐父元素字体的顶.
text-bottom
盒的底对齐父元素字体的底.
<percentage>
将盒升高(正值)或降低(负值)这一距离(‘line-height’值的百分比).’0%’等同于’baseline’.
<length>
将盒升高(正值)或降低(负值)这一距离.’0cm’等同于’baseline’.

以下值排列元素相对于行盒.既然元素可能有孩子相对于它对齐(这反过来又可能他们后代相对它们对齐),这些值使用对齐的子树的边界范围.对齐的子树中行内 元素包含该元素和所有子行内元素的对齐子树,这些行内元素计算”vertical-align”值不是”top”或”bottom”.子树的顶端对齐是在 子树内盒子中最高的盒的顶部,底部是类似的.

top
盒的顶对齐线框的顶.
bottom
盒的底对齐线框的底.

一个”inline-table”的基线table的第一行的基线.

一个”inline-block”的基线是在普通流中最后一个行盒的基线,除非它没有in-flow行盒或如果它的”溢出”属性有一个计算值且不是”visible”,在这种情况下,基线是底部margin边缘.

这里是dojo的一个下拉日期控件weiget，input框和下拉框里面的内容是分开的两个组件,然后再input的weiget中通过祖先类dijit._HasDropDown中的dropDown属性值来进行进行设置.

示例代码如下:——————————————————————————————-

define(“temp/对象名称A”, [
引用的对象
],function(declare, _Widget, _Templated, 父级对象(继承自_hasDropdown对象)…) {
var _A = declare(“temp.A”, 父级对象 , {
popupClass:”temp.内部类B”,
xxxClass:”temp.其他的对象”,
openDropDown: function(/Function/callback) {
this.inherited(arguments);
dojo.mixin(this.dropdown,{
onXXX : dojo.hitch(this , “onAxxx”)
})
},
onAxxx: function(){
//方法在_A里面执行,就可以使用A里面的变量,方法等,从而控制页面上A的表现
}
}),
declare(“temp.内部类B”, 父级对象 , {
//可以外部引用或者直接写html的string
templateString:

,
//onXXX方法可以在引用类里面进行调用
onXXX:function(){}
})
return _A;

);

另外继承自_Weight的组件可以重写_setValueAttr 方法来让value属性接受不同的类型数据参数:
_setValueAttr: function(value){
//对value参数的处理
this.inherited(arguments);
}

《程序语言设计》书中关于作用域有如下介绍:如果标识符x出现在函数体,而x又不是在函数内部定义的,那么x的值必然依赖于函数外部的某个变量.这 种情况下x的存储位置不在函数的活动记录中.因为x在其他某个块中定义,所以为了函数中能访问x,需要在栈里的其他活动记录中找到x.

有两个主要规则用于寻找全局标志符的声明:
1.静态作用域 一个全局标志符表示距离当前作用域最近的外层作用域中声明的同名变量.
2.动态作用域 一个全局标志符表示最近的活动记录中的同名变量.

静态作用域规则寻找一个变量声明时依赖的是源程序中块之间的静态关系(不变的);而动态作用域规则依赖程序执行时(动态的)的函数调用顺序.

访问链被用于维护静态作用域

一个活动记录的访问链(access link)指向源程序中最近的外层块对应的活动记录.内嵌块不需要访问链,因为最近的外层块就是最近进入的块-其活动记录由控制链(control link )指向着.然而对于函数而言,最近的外层块是源程序中函数定义的地方.因为通常函数的控制链和访问链指向不同的活动记录.一些作者将访问链称为静态链 (static link),因为访问链反映的是源程序中块的静态嵌套结构.

另外静态作用域又被称为语句作用域(Lexical scoping),作用域基本的作用是在不同的块间保持变量的独立.

在静态作用域,一个名称总是指向它的本地语句环境.这是程序文本的一个属性其由语言实现来创建且独立于运行时调用栈(call stack),因为它的匹配仅需要分析静态程序文本,所以又称为静态作用域.

动态作用域 Daynamic scoping

在动态作用域,每个标识符有个全局栈的绑定.引入一个名为x的本地变量将一个绑定推入这个全局的x栈(它可能是空的),当控制流(control flow)离开作用域,本地变量被释放(poped off).在任何上下文中演算x总是取决于顶部的绑定.换句话说,全局标识符引用和最近的环境关联的标识符.注意这个不能在编译器执行因为绑定栈只存在于 运行期,这也是这种类型的作用域被称为动态作用域的原因.

通常,一些块被定义用来创建绑定其声明周期是块的执行期;这增加了一些静态作用域特征到动态作用域过程.然而,由于一段代码能被许多不同位置和情景 调用.很难确定当一个变量被使用(或者存在)一开始什么绑定会被应用.这可能是有益的;应用(application)的最少知识原则 (principle of least knowledge)建议代码避免依赖变量值而定.但使用这个值取决于变量的定义.这个共享数据(shared data)的牵强解释能够提供一个非常灵活的系统以适应一个函数行为到系统的当前状态(或策略).然而,这个益处依赖于所以变量都使用这种方式的细致文 档，同时依赖于避免关于变量行为的设想.且不提供任何检测程序不同部分冲突的机制.

动态作用域比较容易实现.找到一个标识符的值,程序能够穿过运行时栈,为标识符检查每个活动的记录(每个函数的栈帧)的值,实际上,通过使用一个关 联列表(association list)会使它更有效率,而列表是一个栈的 名/值 对.无论什么时候声明被创建 名/值 对被推入这个栈,并且无论何时变量离开作用域其被弹出.一个更快一点的替换策略是使用一个中间参考表,其每个名字和它的当前含义关联.这避免了一个在运行 期去查找一个特定名字的线性搜索,但维护这个表更复杂了.注意这两个策略都使用后进先出的顺序来绑定任意的变量;

参考资料:

http://en.wikipedia.org/wiki/Scope_(computer_science)

2011年真的是不平凡的一年,个人不只是有收获了一些知识,还有就是个人的成长吧.

比较重要的一个决定的是2011年11月我离开了工作了2年半的上海,毕业之后一直在上海这边,所以其他城市也没有去走过,决定离开也是心里的感觉,因为现在自己还是一个人，没有什么牵挂，所以应该乘着年轻到处走走看看.

简单的说是行者无疆,英语说法是:life is a journey.不管是怎么说,以后如果有了朋友，有了要照顾的人,更多的忙于工作和生活琐事.所以决定离职马上就离开上海了,不管当初的决定好坏,现在已经在北京工作了,日常有空到处看看各种风景，心里还是很开心.

除了这些，还有一些成长的话，学会了在旅行中发现生活的各种惊喜。其实我们身边真的有很多好看的风景或者事物.真的需要去享受这些。还有到然也学会了随遇而安.

在知识的学习上,2011年,开始计算机科学相关的知识了.开始了解了一些算法上的问题.也能够把数学上的理论转化为程序上的算法和方案.比较大的收获是开始对生活中发现的一些事物进行数学建模,并推理出一些数学逻辑和理论.

在web开发方面,自己已经把webandroid的理论完善了,也把rain css的实现搭起来了,整个css实现可以用这个作基础,当然也在做js框架上面的学习,因为一个应用有了完善的CSS框架和JS框架来保证简单和优异的 用户体验,并且保证开发的简单和高效率,对应用本身有一个很好的事情.所以这也是一个很好的过程.

总的说来，2011年收获和成长,2012年继续旅行,享受生活的各种乐趣,享受web的各种乐趣.