Giter Club home page Giter Club logo

blog's Introduction

#使用Jekyll在Github上面搭建blog 这个blog只是自己在的一个尝试,个人主页github主页请移步 runke github

创建项目 1.在本地创建blog 2.本地初始化 git init 3.创建设置文件。 新建_config.yml 内容为:  baseurl: /jekyll_demo 4.新建布局文件夹 _layouts 在_layouts下面创建文件 default.html default.html的内容如下:

<!DOCTYPE html>
  <html>
  <head>
    <meta http-equiv="content-type" content="text/html; charset=utf-8" />
    <title>{{ page.title }}</title>
  </head>
  <body>

    {{ content }}

  </body>
  </html>

5.新建提交文件 创建文件夹:_posts 新建文件:2012-08-25-hello-world.html 内容如下:

---
  layout: default
  title: 你好,世界
---
  <h2>{{ page.title }}</h2>
  <p>我的第一篇文章</p>
  <p>{{ page.date | date_to_string }}</p>

6.创建首页 在根目录下面创建index.html 代码内容如下:

---
  layout: default
  title: 我的Blog
---
  <h2>{{ page.title }}</h2>
  <p>最新文章</p>
  <ul>
    {% for post in site.posts %}
      <li>{{ post.date | date_to_string }} <a href="{{ site.baseurl }}{{ post.url }}">{{ post.title }}</a></li>
    {% endfor %}
  </ul>

7.发布内容 在github上面新建rep叫做blog

git add .
git commit -m "first post"
git remote add blog https://github.com/username/jekyll_demo.git
git push blog gh-pages

8.访问 http://runkingzhang.github.com/blog 就可以看到对应blog内容。

9.现在还用的比较常见的方式就是在github上面使用issues来建立对应的blog,这样这边不但 支持markdown,还可以让别的用户来留言,不需要上传文件,也方便修改。相对来说这种方式是最好的。 github issues

blog's People

Contributors

runkingzhang avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar

blog's Issues

reborn

这几天在回顾自己以前学的技术,发现自己以前写的文章太少了。
很多自己学的东西都已经慢慢忘了,还有就是很多内容自己都是没有真正的深入的了解。自己缺少一个自我归纳和总结地方。
我一直在找一个可以当做博客使用的地方,用来存放的我的文字,我也有自己的域名和blog,但是总是感觉用起来和维护起来不是那么方便。
既然github上面存放了我的代码,那么为什么不把自己的文字和一些相关内容也存放在这里那。
我用过其他方式在github上面搭建过blog,但是我觉的最简单的,也是最方便的方式就是用这种方式。
直接在issue中写文章,然后发布,这比其他的两种方式来的简单实用,也是便于维护的。
我希望我以后可以尝尝通过这种方式来写一些文章。

{重构}Fires-原稿

这篇文章是自己2013年03月写的一个文档。现在来看,还是有很多地方不足的。
在这个基础上有有了不同的想法。
其实那时候先表达的是一个CSS模块的东西。基于MVC的模块化,在原来的基础上进行细分。

Fires

Fires(火焰):这个名字是来源于多火。我那时的想法是这个框架应该是多火网站开发的一部分。
想法:fires 火焰,是很小的东西,但是火焰可以越燃越大。
就像当时的lmc一样,可能一开始写的时候感觉很麻烦,很困难。但是我相信只要页面写多了,
这个**的东西就会出来的。还有一点是多火在千校团体后一直没有自己的东西,做外包。
做一个扔一个,没有代码的迭代和跟进,所以代码不会好看。
很可惜,自己当初没有好好的试一下这个方法和**是不是到底可行。

** 

我先开始写我的**,至于在实际开发中自己可不可以做到那是后话。
我实习的一个月里面学到的真正有用的东西也就是怎么写一个开发文档了的。

MVC**

MVC 是一种将应用程序的逻辑层和表现层进行分离的方法。

MVC全名是Model View Controller,是模型(model)-视图(view)-控制器(controller)的缩写,
一种软件设计典范,用于组织代码用一种业务逻辑和数据显示分离的方法,
这个方法的假设前提是如果业务逻辑被聚集到一个部件里面,
而且界面和用户围绕数据的交互能被改进和个性化定制而不需要重新编写业务逻辑MVC被独特的发展
起来用于映射传统的输入、处理和输出功能在一个逻辑的图形化用户界面的结构中。

MVC也是一种**或者是文件分类模式。为的是敏捷开发模式。

从一整个网站的结构来分,后台是Model,前端是View。
做过网站的人都知道,不同我网站的前台展现是不同的,但是后台系统是可以通配的。
一个后台可以做很多个功能相同的网站。在PHP的开发中smarty就是连接前台和后台的控制器。

前端内容用MVC**细分就是内容(HTML),样式(CSS),行为(JS)的分法。
也就是前端工程师常说的结构(html),表现(css),行为分离(js)。
当HTML结构语义化越明显,有一定的规范后这种细分才会更加的明显。

前端部分应该是MVC中的V的内容,为的是更好的开发和维护。
在这里面应该有一个OOP**model里面,不要去重复的写相同或者相同类型的代码,
不断利用以前自己的代码来做相似或不同的东西。这就是为什么网站啊的后台可以使通配的,
但是网站的前端要不一样的代码来展现,但是前端代码也是可以用MVC和面向对象的**来细分,
这也就是现在说的页面前端架构。
我个人对前面架构的概念很是模糊,但是我更愿意将前端架构称为是前端规范。
因为在前端开发商很少有设计架构这么大概念的内容,更多的是为了方便而制定的规范。
只有好的规范在可以更快速的开发网站。

其实我感觉样式(CSS)还可以用MVC的是想来细分。因为CSS属性的类型本身就有MVC的内容,
如display,float就是Model,
padding,margin这类就是view,
font,color就是controller(在页面上更多时候叫做content)的内容。

自己曾经将css的根据原有的属性分类为依据将css细分为LMC,
L--layout,这里面都是一些页面的布局的css文件,只要就是display,float,这些属性,
M就是Model,里面是相互布局间的一些变现间距,如padding和margin内容以及一写样式表现,
C是Content,是里面的图片,链接,文字的样式内容和表现模式。

完整网站的MVC**
模型(model)-----后台
-视图(view) ---- 前端----- 前端MVC----
内容(HTML)
行为(JS)
样式(CSS),
L--layout,
M就是Model,
C是Content

控制器(controller)----后台action和于数据库之间的交互。
这个是我对网站的一个MVC的分法。重要的是自己大脑里面永远有一个版本控制器,
要在在自己原来的基础上不断迭代。写出更好更好更有些的代码。
要利用MVC创造世界,要用MVC毁灭世界,在利用MVC再创造新的世界。
MVC和LMC都要大量的代码积累个整理,要在原来的代码基础上不断的迭代,
更加合理的html,更少的css,更加OOP的js。
最终的效果是网站前端开发的可模块化,只要拖来脱去就可以实现页面展现了的。

LMC**

在运用网站一次MVC,一次结构、样式、行为分离的基础上再将样式分离。
这边的一个依据是css属性分类和html标签分类。

LMC将拆,再装起来,再拆下来用到别的页面上去。
这点我会做一定的尝试,看看可不可以用。

L—layout 主管页面布局 主要是css中的展现属性 ,float,postion,top,display,,,,,都用id作为接口,
命名规范为 l_XXXX
M-model 主管页面展现、位置。主要是css中的自身属性,width,padding,margin、、、用id或者class作为接口,
命名规范为m_XXXXX
C-content 主管页面内容,用class作为接口,主要是css中的内部属性,text,font,color
。这边要特别注意可继承性,优先级。用width:100%,width:auto来做到对外部的拉伸和对内部的自适应,
命名规范为c_XXXXXX。

规范:
1.命名都是用 _ 出来分割
2.开始写的时候不细分lmc内容,为了方便书写,将代码按照原来的页面顺序书写。
3.所有的标签都要抓到,css一开始都要写完整的,方便以后的修改和优先级的调用。
4.在html中调用多个class,顺序依次是lmc。
5.开发完成后用css工具压缩代码,实现文件最小,再上传。

OOP**

OOP**也该是是编程中间最著名的也是最好用的**了。Js有面向对象的**,但是在js中实现着的很蛋痛。

OOP的四个特点:
抽象性 - 程序有能力忽略正在处理中信息的某些方面,即对信息主要方面关注的能力。
封装 - 也叫做信息封装:确保组件不会以不可预期的方式改变其它组件的内部状态;
只有在那些提供了内部状态改变方法的组件中,才可以访问其内部状态。
每类组件都提供了一个与其它组件联系的接口,并规定了其它组件进行调用的方法。
多态性 - 组件的引用和类集会涉及到其它许多不同类型的组件,
而且引用组件所产生的结果得依据实际调用的类型。
继承性 - 允许在现存的组件基础上创建子类组件,这统一并增强了多态性和封装性。
典型地来说就是用类来对组件进行分组,而且还可以定义新类为现存的类的扩展,这样就可以将类组织成树形或网状结构,这体现了动作的通用性。

其实我认为这种特点同样在css和html中间,css全名是Cascading Style Sheet,Cascading本意应该是重叠,
这里就很清楚的说明了css中的继承和优先级的特点和模式内容。
Css中的Class和java中的class同样也是,同样的名字必然是共同点的。

在我大体了解了less后,那是就认为可疑利用less将css也写出oop的**来。
这个也应该是less这个基础出现的原因吧。因为我在做网页的时候最困扰我的是color ,width,height。
其实我感觉是有世界上所有页面的html组合不会超过100种。是的,组合。
Html和css,都不是什么语言,一个是文本,标签,只是一种简单的标记。网页是文本的一种,
DOM中的D,js中的Document对象都说明了这一点。
Word简单吗,简单,谁都会用。Word简单吗?不简单,很少有人可以将word用的很好
。标题像标题,段落像段落,超链接想超链接,图片像图片。我一直认为写html就像写word一样。
其实本来也就是这样,word无非就是图形化的操作,html是文字化的操作。
Css是属性,也没有什么了不起的,css加起来都不会到100个,
但是有多少个组合哪,不知道。所以css的问题就在这里,组合在一起可能就会出现问题。

正如我上面说的一样,世界上所有网站的html组合不会草果100种,我敢说几乎所有网站的nav都是ul 和li。
所有的列表也是ul和p。也就是说html可以规范的。余下的就是css。
其实css也是大同小异,特定的展现就那么几个css属性,已经定死了,余下的就是要根据不同的页面展现。
所以我感觉这边可以将一些相同的css提出来,用less也好原生的css也好,在原来的代码基础上做简单修改就可以了。
以便做到敏捷开发的过程。
把类(class)中属性写好,不要有过多的干预,不要对子元素形成继承上的污染,在高度和宽度上做到拉伸。
这样就很方面用于构造对象。
在以上的**基础上,所以我认为在lmc中c中还可以细分,用OOP的**来写,
将页面中相似或者相同模块的content css提取出来,至于布局呀,模块中的margin padding
那就是LMC中的L 和M来实现了。

以上也就只是一种假设,猜想,但是这种都不是没有根据的,这种乱七八糟的**可能是对的,
也可能是错的,但是至少是我有一种**,这点比这种**是对的还是错的更加重要。这是我自己对于前端的理解和思考。

实践

原来的group页面我已经写到了lmc,我利用oop将里面共性的东西给提出出来。
试一下fires。
写了一点后感觉有点写不下去了,感觉有点为技术而技术的感觉了,还是努力写完吧。
最后还是放弃了,这个页面用less来写感觉有点勉强了的。
自己在努力用这个想法来改移到两个完整的页面内容。

2013-03-24

{fires}fires书写规则

Fires

1.css书写规范

css书写顺序学习bootstrap的声明顺序。
相关的属性声明应当归为一组,并按照下面的顺序排列:

  • Positioning
  • Box model
  • Typographic
  • Visual
.declaration-order {
  /* Positioning */
  position: absolute;
  top: 0;
  right: 0;
  bottom: 0;
  left: 0;
  z-index: 100;

  /* Box-model */
  display: block;
  float: right;
  width: 100px;
  height: 100px;

  /* Typography */
  font: normal 13px "Helvetica Neue", sans-serif;
  line-height: 1.5;
  color: #333;
  text-align: center;

  /* Visual */
  background-color: #f5f5f5;
  border: 1px solid #e5e5e5;
  border-radius: 3px;

  /* Misc */
  opacity: 1;
}

Typography的属性是子元素可以继承的。

2.注释规范

注释旨在指明团队协作中的创作、个性者和代码作用。
在 CSS 中,无论块组还是单行注释,均使用 '/* '注释 '/'。
由于中文注释可能导致代码失效,但中文作为团队最有效的沟通文字,最好的使用方法是,
保证在'/
'和'*/'之间的中文前后都有空格,以保证 CSS 不会失效。

/* mod-box model层的box模块                                                         --- 简单描述
 * author: [email protected]                                                   --- 作者
 * require: button                                                                                --- 依赖(可选)
 * father:                                                                                              --- 基类(可选)
 */

.mod-box{
font-family:serif\0/; /* solution:win7 ie8 line-height bug */      --- 行内注释
}

/* new-mod-box-favar  model层的box模块的实例                                              --- 简单描述
 * author: [email protected]                                                                     --- 作者
 * require:                                                                                                               --- 依赖(可选)
 * father:   mod-box                                                                                              --- 基类(可选)
 */

3.模块命名规范

页面分层,依据一页面结构和面向效果编程原理。把页面的模块分类三层。

  • *layout 层 *: 主要控制页面大区块的布局,典型模块是header
    • lay-+ {位置}-+ [名称(可选)]

      .lay-header{}
      .lay-container{}
      .lay-content{}
      .lay-footer{}
  • *model层 *: 主要页面可以前台的模块,box,tab
    • mod-+ [名称]-+ [名称(可选)]

      .mod-box{border: 1px solid #F5F5F5; width:100%;box-shadow: 0 1px 2px rgba(0, 0, 0, 0.3);}
      .mod-box-head{}
      .mod-box-head-title{ float: left;display: inline; font-weight:normal; }
      .mod-box-head-text{ float: left;; display: inline; margin: 0 0 0 10px;}
      .mod-box-head-more{ float: right; color:#999;}
      .mod-box-container{ min-height:10px;}
      .mod-box-content{}

      model层今年每个子模块都有对应的名称,直接使用class选择区而不使用之类选择器,之类选择器在子类中使用。
      每个model模块应该是一个真理,所以建议将一些方法出行(如浮动的清楚)内置在模块中间。

  • *content层 *: 组要控制页面的内容展现样式,典型是内容的左右布局和list
    • con-+ [名称]-+ [名称(可选)]

       .con-shop-box{}
       .con-shop-left{ }
       .con-shop-right{}

      content层今年每个子模块都有对应的名称,直接使用class选择区而不使用之类选择器,之类选择器在实例中使用。

这三层应该是相互分离的,相互嵌套的。理论上来说不应该有属性跨层次继承和相互影响。
单独模块的html+css组合应该可以应用到其他的环境中,层次之间不应该纯在相互依赖的关系。

模块原型

把layout,model,content层中的模块难做是原型模块。

<div class="mod-box new-mod-box">
      <div class="mod-box-head"></div>
      <div class="mod-box-content"></div>
</div>

想上面的这种方式来对模块在页面的中使用,用new来创建原型实例。

在页面开发中用mod-box来提取出页面中模块的共有样式,组建相关模块,用new-mod-box来实现模块的在页面的应用。

  • new-+[lay/mod/content模块名]-+[实例名称]`

利用css的引入方法的优先级,css的权重计算和css的书写顺序来对原来模块中的css属性值进行重叠。

.new-mod-box-promoted{ margin:15px 0 0 0;}
.new-mod-box-promoted  .mod-box-head{ height:40px;}

实例原型的css应该写在原型属性的下方,会对css进行重叠。这是通过css书写顺序实现的。
对模块的子模块的属性重写和设置都通过在原有子模块的前面+实例模块名称的方式来实现。
在css中实例和模型应该写在一起。

4.关于模块化

有三点需要注意的,一是,注意代码重用的模块化,其余可以重用的部分,组件原型;
二是,注意 HTML 结构的模块化,而不是分块,使用原型,替换和修改小面积的HTML内容。
三是,模块的实例化,在html使用class组件关键字的接口,用用上面的规则来实现页面中的效果,但是不应该对模块做修改。

我们是这样重用的:

<div class="lay-container">
        <!-- 下面是mod-box的原型 -->
        <div class="mod-box">
            <div class="mod-box-head">
                 <h3 class="mod-box-head-title">区块标题</h3>
                 <span class="mod-box-head-text">其他文字</span>
                 <a href="#" class="mod-box-head-more">更多</a>
             </div>
            <div class="mod-box-container">
                <div class="mod-box-content">mod-box-content 有默认内边距</div>
            </div>
        </div>
       <!--  下面是mod-box的实例 -->

        <div class="mod-box new-mod-box-hidden">
            <div class="mod-box-head">
                <h3 class="mod-box-head-title">没有内容</h3>
                <span class="mod-box-head-text">其他文字</span>
                <a href="#" class="mod-box-head-more">更多</a>
            </div>
            <div class="mod-box-container" >
                <div class="mod-box-content">mod-box-content 有默认内边距</div>
            </div>
        </div>

        <!--  下面是mod-box的实例 -->
        <div class="mod-box new-mod-box-margin">
            <div class="mod-box-head">
                <h3 class="mod-box-head-title">区块标题</h3>
                <span class="mod-box-head-text">其他文字</span>
                <a href="#" class="mod-box-head-more">更多</a>
            </div>
            <div class="mod-box-container">
                <div class="mod-box-content">mod-box-content 有默认内边距</div>
            </div>
        </div>
        <!--  下面是mod-box的实例 -->
        <div class="mod-box new-mod-box-follow">
            <div class="mod-box-head">
                <h3 class="mod-box-head-title">连着上面的box</h3>
                <span class="mod-box-head-text">其他文字</span>
                <a href="#" class="mod-box-head-more">更多</a>
            </div>
            <div class="mod-box-container">
                <div class="mod-box-content">mod-box-content 有默认内边距</div>
            </div>
        </div>
    </div>
    .lay-container{width:500px;margin:20px auto ;}

/* mod-box model层的box模块                                                     
 * author: [email protected]                                                                                                                                        
 */
.mod-box{border:1px solid #ccc;zoom:1;font-size:12px;margin:0;padding:0;border-bottom:0;}
.mod-box-head{border-bottom:1px solid #ccc;position:relative;
padding:10px;line-height:16px;
background:-webkit-gradient(linear,left top,left bottom,from(#fcfcfc),to(#f9f9f9));
background:-moz-linear-gradient(top,#fcfcfc,#f9f9f9);
filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#fcfcfc', endColorstr='#f9f9f9');
background:-o-linear-gradient(top,#fcfcfc,#f9f9f9);
background:linear-gradient(top,#fcfcfc,#f9f9f9);
zoom:1;}
.mod-box-head:after{content:"."; display:block; height:0; visibility:hidden; clear:both; }
.mod-box-head-title{color:#656565;font-size:14px;font-weight:700;float:left;display:inline;margin:0;padding:0}
.mod-box-head-more{float:right}
.mod-box-head-text{margin-left:10px;color:gray;float:left}
.mod-box-container{background:#fff;border-bottom:1px solid #ccc}
.mod-box-content{padding:10px}

/* mod-box model层的box的实例                                                    
 * author: [email protected]   
 * father:   mod-box                                                                                                                                   
 */
.new-mod-box-hidden{margin: 15px 0 0 0;}
.new-mod-box-hidden .mod-box-container{display: none;}
.new-mod-box-margin{margin: 30px 0 0 0;}
.new-mod-box-follow{border-top:0}

4.HTML书写规范

学习bootstrap的属性属性顺序。
HTML 属性应当按照以下给出的顺序依次排列,确保代码的易读性。

  • class
  • id, name
  • data-*
  • src, for, type, href
  • title, alt
  • aria-*
  • role*

使用 <div class="mod-box new-mod-box-margin">的来原型的实例。在页面中更好的使用。

4.JavaScript规则

模块和JavaScript组合变成页面交互组件。这边一直使用id作为和js交互的接口。

参考

Puerh
Alice
bootstrap规范

{转载}那些年一起清楚过的浮动

一丝的文章,可以看见兼容性引起的原因。
浮动(float),一个我们即爱又恨的属性。爱,因为通过浮动,我们能很方便地布局; 恨,浮动之后遗留下来太多的问题需要解决,特别是IE6-7(以下无特殊说明均指 windows 平台的 IE浏览器)。也许很多人都有这样的疑问,浮动从何而来?我们为何要清除浮动?清除浮动的原理是什么?本文将一步一步地深入剖析其中的奥秘,让浮动使用起来更加得心应手。

一、清除浮动 还是 闭合浮动 (Enclosing float or Clearing float)?
很多人都已经习惯称之为清除浮动,以前我也一直这么叫着,但是确切地来说是不准确的。我们应该用严谨的态度来对待代码,也能更好地帮助我们理解开头的三个问题。

1)清除浮动:清除对应的单词是 clear,对应CSS中的属性是 clear:left | right | both | none;

2)闭合浮动:更确切的含义是使浮动元素闭合,从而减少浮动带来的影响。

两者的区别 请看优雅的 Demo

通过以上实例发现,其实我们想要达到的效果更确切地说是闭合浮动,而不是单纯的清除浮动,在footer上设置clear:both清除浮动并不能解决warp高度塌陷的问题。

结论:用闭合浮动比清除浮动更加严谨,所以后文中统一称之为:闭合浮动。

二、为何要清除浮动?
要解答这个问题,我们得先说说CSS中的定位机制:普通流,浮动,绝对定位 (其中"position:fixed" 是 "position:absolute" 的一个子类)。

1)普通流:很多人或者文章称之为文档流或者普通文档流,其实标准里根本就没有这个词。如果把文档流直译为英文就是 document flow ,但标准里只有另一个词,叫做 普通流 (normal flow),或者称之为常规流。但似乎大家更习惯文档流的称呼,因为很多中文翻译的书就是这么来的。比如《CSS Mastery》,英文原书中至始至终都只有普通流 normal flow(普通流) 这一词,从来没出现过document flow (文档流)

2)浮动:浮动的框可以左右移动,直至它的外边缘遇到包含框或者另一个浮动框的边缘。浮动框不属于文档中的普通流,当一个元素浮动之后,不会影响到 块级框的布局而只会影响内联框(通常是文本)的排列,文档中的普通流就会表现得和浮动框不存在一样,当浮动框高度超出包含框的时候,也就会出现包含框不会 自动伸高来闭合浮动元素(“高度塌陷”现象)。顾名思义,就是漂浮于普通流之上,像浮云一样,但是只能左右浮动。

正是因为浮动的这种特性,导致本属于普通流中的元素浮动之后,包含框内部由于不存在其他普通流元素了,也就表现出高度为0(高度塌陷)。在实际布局中,往往这并不是我们所希望的,所以需要闭合浮动元素,使其包含框表现出正常的高度。

绝对定位就不多说了,不在本文讨论范围之内,下回分解。

三、清除浮动的原理——了解 hasLayout 和 Block formatting contexts
先看一下清理浮动的各种方法:

1)添加额外标签

这是在学校老师就告诉我们的 一种方法,通过在浮动元素末尾添加一个空的标签例如

,其他标签br等亦可。

1)添加额外标签

.main{float:left;}
.side{float:right;}
.footer

优雅的 Demo

优点:通俗易懂,容易掌握

缺点:可以想象通过此方法,会添加多少无意义的空标签,有违结构与表现的分离,在后期维护中将是噩梦,这是坚决不能忍受的,所以你看了这篇文章之后还是建议不要用了吧。

2)使用 br标签和其自身的 html属性

这个方法有些小众,br 有 clear=“all | left | right | none” 属性

2)使用 br标签和其自身的 html属性

.main{float:left;}
.side{float:right;}

.footer

优雅的 Demo

优点:比空标签方式语义稍强,代码量较少

缺点:同样有违结构与表现的分离,不推荐使用

3)父元素设置 overflow:hidden

通过设置父元素overflow值设置为hidden;在IE6中还需要触发 hasLayout ,例如 zoom:1;

3)父元素设置 overflow

.main{float:left;}
.side{float:right;}
.footer

优雅的 Demo

优点:不存在结构和语义化问题,代码量极少

缺点:内容增多时候容易造成不会自动换行导致内容被隐藏掉,无法显示需要溢出的元素;04年POPO就发现overflow:hidden会导致中键失效,这是我作为一个多标签浏览控所不能接受的。所以还是不要使用了

4)父元素设置 overflow:auto 属性

同样IE6需要触发hasLayout,演示和3差不多

优点:不存在结构和语义化问题,代码量极少

缺点:多个嵌套后,firefox某些情况会造成内容全选;IE中 mouseover 造成宽度改变时会出现最外层模块有滚动条等,firefox早期版本会无故产生focus等, 请看 嗷嗷的 Demo ,不要使用

5)父元素也设置浮动

优点:不存在结构和语义化问题,代码量极少

缺点:使得与父元素相邻的元素的布局会受到影响,不可能一直浮动到body,不推荐使用

6)父元素设置display:table

优雅的 Demo

优点:结构语义化完全正确,代码量极少

缺点:盒模型属性已经改变,由此造成的一系列问题,得不偿失,不推荐使用

7)使用:after 伪元素

需要注意的是 :after是伪元素(Pseudo-Element),不是伪类(某些CSS手册里面称之为“伪对象”),很多清除浮动大全之类的文章都称之为伪类,不过csser要严谨一点,这是一种态度。

由于IE6-7不支持:after,使用 zoom:1触发 hasLayout。

该方法源自于: How To Clear Floats Without Structural Markup

原文全部代码如下:

<style type="text/css"> .clearfix:after { content: "."; display: block; height: 0; clear: both; visibility: hidden; } .clearfix {display: inline-block;} /* for IE/Mac */ </style>

鉴于 IE/Mac的市场占有率极低,我们直接忽略掉,最后精简的代码如下:
.clearfix:after {content:"."; display:block; height:0; visibility:hidden; clear:both; }

.clearfix { *zoom:1; }

优雅的 Demo

优点:结构和语义化完全正确,代码量居中

缺点:复用方式不当会造成代码量增加

小结

通过对比,我们不难发现,其实以上列举的方法,无非有两类:

其一,通过在浮动元素的末尾添加一个空元素,设置 clear:both属性,after伪元素其实也是通过 content 在元素的后面生成了内容为一个点的块级元素;

其二,通过设置父元素 overflow 或者display:table 属性来闭合浮动,我们来探讨一下这里面的原理。

在CSS2.1里面有一个很重要的概念,但是国内的技术博客介绍到的比较少,那就是 Block formatting contexts (块级格式化上下文),以下简称 BFC。

CSS3里面对这个规范做了改动,称之为:flow root,并且对触发条件进行了进一步说明。

那么如何触发BFC呢?

float 除了none以外的值

overflow 除了visible 以外的值(hidden,auto,scroll )

display (table-cell,table-caption,inline-block)

position(absolute,fixed)

fieldset元素
需要注意的是,display:table 本身并不会创建BFC,但是它会产生匿名框(anonymous boxes),而匿名框中的display:table-cell可以创建新的BFC,换句话说,触发块级格式化上下文的是匿名框,而不是 display:table。所以通过display:table和display:table-cell创建的BFC效果是不一样的。

fieldset 元素在www.w3.org里目前没有任何有关这个触发行为的信息,直到HTML5标准里才出现。有些浏览器bugs(Webkit,Mozilla)提到过这个触发行为,但是没有任何官方声明。实际上,即使fieldset在大多数的浏览器上都能创建新的块级格式化上下文,开发者也不应该把这当做是理所当然的。CSS 2.1没有定义哪种属性适用于表单控件,也没有定义如何使用CSS来给它们添加样式。用户代理可能会给这些属性应用CSS属性,建议开发者们把这种支持当做实验性质的,更高版本的CSS可能会进一步规范这个。

BFC的特性:

1)块级格式化上下文会阻止外边距叠加
当两个相邻的块框在同一个块级格式化上下文中时,它们之间垂直方向的外边距会发生叠加。换句话说,如果这两个相邻的块框不属于同一个块级格式化上下文,那么它们的外边距就不会叠加。

2)块级格式化上下文不会重叠浮动元素
根据规定,一个块级格式化上下文的边框不能和它里面的元素的外边距重叠。这就意味着浏览器将会给块级格式化上下文创建隐式的外边距来阻止它和浮动元 素的外边距叠加。由于这个原因,当给一个挨着浮动的块级格式化上下文添加负的外边距时将会不起作用(Webkit和IE6在这点上有一个问题——可以看这 个测试用例)。

3)块级格式化上下文通常可以包含浮动
详见: W3C CSS2.1 - 10.6.7 'Auto' heights for block formatting context roots

通俗地来说:创建了 BFC的元素就是一个独立的盒子,里面的子元素不会在布局上影响外面的元素,反之亦然,同时BFC任然属于文档中的普通流。

至此,您或许明白了为什么 overflow:hidden或者auto可以闭合浮动了,真是因为父元素创建了新的BFC。对于张鑫旭在对《overflow与zoom”清除浮动”的一些认识 》一文中对于用包裹来解释闭合浮动的原理,我觉得是不够严谨的,而且没有依据。并且说道“Firefox等浏览器并没有haslayout的概念”,那么现代浏览器是有BFC的,从表现上来说,hasLayout 可以等同于 BFC。

IE6-7的显示引擎使用的是一个称为布局(layout)的内部概念,由于这个显示引擎自身存在很多的缺陷,直接导致了IE6-7的很多显示 bug。当我们说一个元素“得到 layout”,或者说一个元素“拥有 layout” 的时候,我们的意思是指它的微软专有属性 hasLayout http://msdn.microsoft.com/worksh ... rties/haslayout.asp 为此被设为了 true 。IE6-7使用布局的概念来控制元素的尺寸和定位,那些拥有布局(have layout)的元素负责本身及其子元素的尺寸设置和定位。如果一个元素的 hasLayout 为false,那么它的尺寸和位置由最近拥有布局的祖先元素控制。

触发hasLayout的条件:

position: absolute

float: left|right

display: inline-block

width: 除 “auto” 外的任意值

height: 除 “auto” 外的任意值 (例如很多人清除浮动会用到 height: 1% )

zoom: 除 “normal” 外的任意值 (MSDN) http://msdn.microsoft.com/worksh ... properties/zoom.asp

writing-mode: tb-rl (MSDN) http://msdn.microsoft.com/worksh ... ies/writingmode.asp
在 IE7 中,overflow 也变成了一个 layout 触发器:

overflow: hidden|scroll|auto ( 这个属性在IE之前版本中没有触发 layout 的功能。 )

overflow-x|-y: hidden|scroll|auto (CSS3 盒模型中的属性,尚未得到浏览器的广泛支持。他们在之前IE版本中同样没有触发 layout 的功能)
hasLayout更详细的解释请参见 old9翻译的 大名鼎鼎的 《On having layout》一文(英文原文:http://www.satzansatz.de/cssd/onhavinglayout.htm),由于old9博客被墙,中文版地址:

IE8使用了全新的显示引擎,据称不使用 hasLayout属性了,因此解决了很多深恶痛绝的bug。

综上所述:
在支持BFC的浏览器(IE8+,firefox,chrome,safari)通过创建新的BFC闭合浮动;
在不支持 BFC的浏览器 (IE6-7),通过触发 hasLayout 闭合浮动。

四、闭合浮动方法——精益求精
上面已经列举了7种闭合浮动的方法,通过第三节分析的原理,我们发现其实更多的:display:table- cell,display:inline-block等只要触发了BFC的属性值都可以闭合浮动。从各个方面比较,after伪元素闭合浮动无疑是相对比 较好的解决方案了,下面详细说说该方法。

.clearfix:after {content:"."; display:block; height:0; visibility:hidden; clear:both; }

.clearfix { *zoom:1; }

  1. display:block 使生成的元素以块级元素显示,占满剩余空间;

  2. height:0 避免生成内容破坏原有布局的高度。

  3. visibility:hidden 使生成的内容不可见,并允许可能被生成内容盖住的内容可以进行点击和交互;

4)通过 content:"."生成内容作为最后一个元素,至于content里面是点还是其他都是可以的,例如oocss里面就有经典的 content:"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",有些版本可能content 里面内容为空,一丝冰凉是不推荐这样做的,firefox直到7.0 content:”" 仍然会产生额外的空隙;

5)zoom:1 触发IE hasLayout。

通过分析发现,除了clear:both用来清除浮动的,其他代码无非都是为了隐藏掉content生成的内容,这也就是其他版本的闭合浮动为什么会有font-size:0,line-height:0。

精益求精方案一:

相对于空标签闭合浮动的方法代码似乎还是有些冗余,通过查询发现Unicode字符里有一个“零宽度空格”,也就是U+200B ,这个字符本身是不可见的,所以我们完全可以省略掉 visibility:hidden了

.clearfix:after {content:"\200B"; display:block; height:0; clear:both; }

.clearfix { *zoom:1; }.

精益求精方案二:

由Nicolas Gallagher 大湿提出来的,原文:A new micro clearfix hack,该方法也不存在firefox中空隙的问题。

/* For modern browsers */

.cf:before,.cf:after {

content:"";

display:table;

}

.cf:after { clear:both; }/* For IE 6/7 (trigger hasLayout) */

.cf { zoom:1; }

需要注意的是:

上面的方法用到了 :before伪元素,很多人对这个有些迷惑,到底我什么时候需要用before呢?为什么方案一没有呢?其实它是用来处理margin边距重叠的,由于 内部元素 float 创建了BFC,导致内部元素的margin-top和 上一个盒子的margin-bottom 发生叠加。如果这不是你所希望的,那么就可以加上before,如果只是单纯的闭合浮动,after就够了!并不是如同大漠《Clear Float》一文所说的:但只使用clearfix:after时在跨浏览器兼容问题会存在一个垂直边距叠加的bug,这不是bug,是BFC应该有的特性。

请看优雅的Demo

进一步了解请看: 《clearfix改良及overflow:hidden详解【译】》

在实际开发中,改进方案一由于存在Unicode字符不适合内嵌CSS的GB2312编码的页面,使用方案7完全可以解决我们的需求了,改进方案二 等待大家的进一步实践。方案3、4通过overflow闭合浮动,实际上已经创建了新的 块级格式化上下文,这将导致其布局和相对于浮动的行为等发生一系列的变化,清除浮动只不过是一系列变化中的一个作用而已。所以为了闭合浮动去改变全局特 性,这是不明智的,带来的风险就是一系列的bug,比如firefox 早期版本产生 focus,截断绝对定位的层等等。始终要明白,如果单单只是需要闭合浮动,overflow就不要使用,而不是某些文章所说的“慎用”。

前前后后花了三天写完了这篇文章。如果觉得本文对您有帮助,您的留言就是对我最大的支持,同时由于精力有限,欢迎指出文中错误与不足,共勉之!

参考资料:

Page breaks and block-formatting contexts: Allowed page breaks (13.3.3)
Clearfix and block formatting contexts: Everything you Know about Clearfix is Wrong
Block formating contexts, “hasLayout” – IE Window vs CSS2.1 browsers: simulations.
New block formatting contexts next to floats
Control Block Formatting Context
On having layout, [译文]On having layout http://old9.blogsome.com/2006/04/11/onhavinglayout
“HasLayout” Overview
hasLayout Property
IE hasLayout
https://developer.mozilla.org/en/CSS/block_formatting_context

前端兼容性不完全指南

常见兼容性问题

兼容性问题简分类

  • 按照所属?:CSS兼容性、JS兼容性、HTML兼容性,还可以继续细分。

兼容性文章很多很散,quirksmode,w3help文章较集中、较严谨,其他主要参考的站点还有前端观察

下面只列出部分工程中常见的兼容性问题,可忽略w3help中在quirk mode下的测试。

Quirk mode

某些特殊的doctype触发quirk mode(混杂模式、怪异模式),ie6未加doctype亦触发quirk mode。

表现之一:box model中width的计算(Demo

  • 混杂模式:border + padding + innerwidth
  • 标准模式:只有innerwidth

box

更多表现请参见Quirks mode and strict mode

quirk mode毕竟是“那个时代”的产物,渐渐离我们远去,工程上应该避免触发quirk mode。

结论:doctype推荐使用<!DOCTYPE html>

常见doctype请参考KB001: 兼容性问题与浏览器的内核及渲染模式

引发的问题

hasLayout

“The hasLayout property is a Document Object Model (DOM) property that indicates when an element has a layout. It is used internally only in quirks mode and IE7 mode to implement CSS positioning. It is not used at all in IE8 mode or IE9 Mode.”

犄角旮旯处找到上面描述,IE8和IE9标准模式下已经弃用hasLayout,下面是目录,这些信息很重要:

其他资源:

引发的问题

Block Formatting Context

Block Formatting Context,通常简称BFC

Floats, absolutely positioned elements, block containers (such as inline-blocks, table-cells, and table-captions) that are not block boxes, and block boxes with 'overflow' other than 'visible' (except when that value has been propagated to the viewport) establish new block formatting contexts for their contents.

Float

浮动有着十分严格的约束,参见W3C Float Position

Postion

了解z-index和层叠上下文stacking context

CSS Selector

完整列表参见quirksmodew3help"渲染-CSS相关",下面列举部分重要的问题:

  • LoVe HAte,了解下针对性(Specificity)这个概念,其实就是样式优先级。下面的写法是正解:

    a {font:bold 50px Verdana;}
    a:link {color:red;}    /* [0,0,1,1] */
    a:visited {color:green;}  /* [0,0,1,1] */
    a:hover {color:blue;}    /* [0,0,1,1] */
    a:active {color:yellow;}  /* [0,0,1,1] */
    a.test:link, a.test:visited, a.test:hover, a.test:active {color:black;}    /* [0,0,2,1] */
    
  • Multiple classesp.class1.class2IE6错误理解为p.class2

  • 子选择器div>p,IE6不支持

  • 相邻兄弟选择器div+p,IE6不支持

  • 属性选择器div[attr],IE6不支持

  • 伪元素

    • :first-child IE6不支持
    • :hover IE6不支持(A除外)
    • :active IE6、7不支持(A除外)
    • :focus、:before、:after IE6、7不支持

CSS Cascade

优先级升序(0为最低),请参考 CSS2.1规范Cascade Order

  1. user agent declarations
  2. user normal declarations
  3. author normal declarations
  4. author important declarations
  5. user important declarations

几处bug需要关注

其他问题

overflow

font-family,正确写法请不要随意使用引号(字体族除外)。

其他

一些心得

了解兼容性是为了写出最高质量的代码,降低后续维护难度。

太多的文章只是对官方标准的翻译(包括W3Help),你甘心永远读着别人的文章?为何不一劳永逸地搞懂问题?

所有不明白的最终都可以从官方文档中找到,请耐心尝试数次,以后就不需要求人了。

我们到底要耗多少时间才能彻底弄明白兼容问题?

  • 具体时间不知
  • 一定是积累的过程,很难一劳永逸
  • 适当的工具在手,可以减少工程上的耗时
  • 了解兼容性产生的原因,心里会更有底

兼容性分类

下面的分类同时也是调试前端bug的推荐流程:

  1. 特性支持 请使用caniuse确认核心特性的浏览器支持范围,典型如某些CSS选择器、某些CSS属性
  2. hasLayout 参见本文hasLayout章节,大部分涉及IE6/7的bug均源于此
  3. float
  4. margin
  5. table
  6. 自己不熟悉的特性往往也是bug的楦头

标准&工具

通用工具

  • 推荐quirksmode兼容表,内容庞大

  • caniuse 主要是HTML5, CSS3兼容性检测

    Compatibility tables for support of HTML5, CSS3, SVG and more in desktop and mobile browsers.
    
  • webdevout 很久前人家推荐的,留在这里作纪念

CSS

JS

  • ES5
  • ES6

HTML

  • HTML 4.01
  • HTML 5

{重构}页面优化总结

前端是庞大的,包括HTML、CSS、Javascript、Image、Flash等等各种各样的资源。前端优化是复杂的,针对方方面面的资源都有不同的方式。那么,前端优化的目的是什么
  1. 从用户角度而言,优化能够让页面加载得更快、对用户的操作响应得更及时,能够给用户提供更为友好的体验。
  2. 从服务商角度而言,优化能够减少页面请求数、或者减小请求所占带宽,能够节省可观的资源。
  总之,恰当的优化不仅能够改善站点的用户体验并且能够节省相当的资源利用。
  前端优化的途径有很多,按粒度大致可以分为两类,第一类是页面级别的优化,例如HTTP请求数、脚本的无阻塞加载、内联脚本的位置优化等;第二类则是代码级别的优化,例如Javascript中的DOM操作优化、CSS选择符优化、图片优化以及HTML结构优化等等。另外,本着提高投入产出比的目的,后文提到的各种优化策略大致按照投入产出比从大到小的顺序排列。
  一、页面级优化
  1. 减少HTTP请求数
  这条策略基本上所有前端人都知道,而且也是最重要最有效的。都说要减少HTTP请求,那请求多了到底会怎么样呢?首先,每个请求都是有成本的,既包含时间成本也包含资源成本。一个完整的请求都需要经过DNS寻址、与服务器建立连接、发送数据、等待服务器响应、接收数据这样一个“漫长”而复杂的过程。时间成本就是用户需要看到或者“感受”到这个资源是必须要等待这个过程结束的,资源上由于每个请求都需要携带数据,因此每个请求都需要占用带宽。另外,由于浏览器进行并发请求的请求数是有上限的(具体参见此处),因此请求数多了以后,浏览器需要分批进行请求,因此会增加用户的等待时间,会给用户造成站点速度慢这样一个印象,即使可能用户能看到的第一屏的资源都已经请求完了,但是浏览器的进度条会一直存在。
  减少HTTP请求数的主要途径包括:
  (1). 从设计实现层面简化页面
  如果你的页面像百度首页一样简单,那么接下来的规则基本上都用不着了。保持页面简洁、减少资源的使用时最直接的。如果不是这样,你的页面需要华丽的皮肤,则继续阅读下面的内容。
  (2). 合理设置HTTP缓存
  缓存的力量是强大的,恰当的缓存设置可以大大的减少HTTP请求。以有啊首页为例,当浏览器没有缓存的时候访问一共会发出78个请求,共600多K数据(如图1.1),而当第二次访问即浏览器已缓存之后访问则仅有10个请求,共20多K数据(如图1.2)。(这里需要说明的是,如果直接F5刷新页面的话效果是不一样的,这种情况下请求数还是一样,不过被缓存资源的请求服务器是304响应,只有Header没有Body,可以节省带宽)
  怎样才算合理设置?原则很简单,能缓存越多越好,能缓存越久越好。例如,很少变化的图片资源可以直接通过HTTP Header中的Expires设置一个很长的过期头;变化不频繁而又可能会变的资源可以使用Last-Modifed来做请求验证。尽可能的让资源能够在缓存中待得更久。关于HTTP缓存的具体设置和原理此处就不再详述了,有兴趣的可以参考下列文章:
  HTTP1.1协议中关于缓存策略的描述
  Fiddler HTTP Performance中关于缓存的介绍
  (3). 资源合并与压缩
  如果可以的话,尽可能的将外部的脚本、样式进行合并,多个合为一个。另外,CSS、Javascript、Image都可以用相应的工具进行压缩,压缩后往往能省下不少空间。
  (4). CSS Sprites
  合并CSS图片,减少请求数的又一个好办法。
  (5). Inline Images
  使用data: URL scheme的方式将图片嵌入到页面或CSS中,如果不考虑资源管理上的问题的话,不失为一个好办法。如果是嵌入页面的话换来的是增大了页面的体积,而且无法利用浏览器缓存。使用在CSS中的图片则更为理想一些
  (6). Lazy Load Image
  这条策略实际上并不一定能减少HTTP请求数,但是却能在某些条件下或者页面刚加载时减少HTTP请求数。对于图片而言,在页面刚加载的时候可以只加载第一屏,当用户继续往后滚屏的时候才加载后续的图片。这样一来,假如用户只对第一屏的内容感兴趣时,那剩余的图片请求就都节省了。有啊首页曾经的做法是在加载的时候把第一屏之后的图片地址缓存在Textarea标签中,待用户往下滚屏的时候才“惰性”加载。
  2. 将外部脚本置底
  前文有谈到,浏览器是可以并发请求的,这一特点使得其能够更快的加载资源,然而外链脚本在加载时却会阻塞其他资源,例如在脚本加载完成之前,它后面的图片、样式以及其他脚本都处于阻塞状态,直到脚本加载完成后才会开始加载。如果将脚本放在比较靠前的位置,则会影响整个页面的加载速度从而影响用户体验。解决这一问题的方法有很多,在这里有比较详细的介绍(这里是译文和更详细的例子),而最简单可依赖的方法就是将脚本尽可能的往后挪,减少对并发下载的影响。
  3. 异步执行inline脚本
  inline脚本对性能的影响与外部脚本相比,是有过之而无不及。首页,与外部脚本一样,inline脚本在执行的时候一样会阻塞并发请求,除此之外,由于浏览器在页面处理方面是单线程的,当inline脚本在页面渲染之前执行时,页面的渲染工作则会被推迟。简而言之,inline脚本在执行的时候,页面处于空白状态。鉴于以上两点原因,建议将执行时间较长的inline脚本异步执行,异步的方式有很多种,例如使用script元素的defer属性(存在兼容性问题和其他一些问题,例如不能使用document.write)、使用setTimeout,此外,在HTML5中引入了Web Workers的机制,恰恰可以解决此类问题
  4. Lazy Load Javascript
  随着Javascript框架的流行,越来越多的站点也使用起了框架。不过,一个框架往往包括了很多的功能实现,这些功能并不是每一个页面都需要的,如果下载了不需要的脚本则算得上是一种资源浪费-既浪费了带宽又浪费了执行花费的时间。目前的做法大概有两种,一种是为那些流量特别大的页面专门定制一个专用的mini版框架,另一种则是Lazy Load。YUI则使用了第二种方式,在YUI的实现中,最初只加载核心模块,其他模块可以等到需要使用的时候才加载
  5. 将CSS放在HEAD中
  如果将CSS放在其他地方比如BODY中,则浏览器有可能还未下载和解析到CSS就已经开始渲染页面了,这就导致页面由无CSS状态跳转到CSS状态,用户体验比较糟糕。除此之外,有些浏览器会在CSS下载完成后才开始渲染页面,如果CSS放在靠下的位置则会导致浏览器将渲染时间推迟。
  6. 异步请求Callback
  在某些页面中可能存在这样一种需求,需要使用script标签来异步的请求数据。类似:
  Javascript:
/Callback函数/
function myCallback(info){
//do something here
}
  HTML:

<script type="text/javascript" src="http://abc.com/cb"></script>
  cb返回的内容: 
myCallback('Hello world!');
      像以上这种方式直接在页面上写<script>

对页面的性能也是有影响的,即增加了页面首次加载的负担,推迟了DOMLoaded和window.onload事件的触发时机。如果时效性允许的话,可以考虑在DOMLoaded事件触发的时候加载,或者使用setTimeout方式来灵活的控制加载的时机。
  7. 减少不必要的HTTP跳转
  对于以目录形式访问的HTTP链接,很多人都会忽略链接最后是否带’/',假如你的服务器对此是区别对待的话,那么你也需要注意,这其中很可能隐藏了301跳转,增加了多余请求。具体参见下图,其中第一个链接是以无’/'结尾的方式访问的,于是服务器有了一次跳转。
  8. 避免重复的资源请求
  这种情况主要是由于疏忽或页面由多个模块拼接而成,然后每个模块中请求了同样的资源时,会导致资源的重复请求
  二、代码级优化
  1. Javascript
  (1). DOM
  DOM操作应该是脚本中最耗性能的一类操作,例如增加、修改、删除DOM元素或者对DOM集合进行操作。如果脚本中包含了大量的DOM操作则需要注意以下几点:
  a. HTML Collection
  在脚本中document.images、document.forms、getElementsByTagName()返回的都是HTMLCollection类型的集合,在平时使用的时候大多将它作为数组来使用,因为它有length属性,也可以使用索引访问每一个元素。不过在访问性能上则比数组要差很多,原因是这个集合并不是一个静态的结果,它表示的仅仅是一个特定的查询,每次访问该集合时都会重新执行这个查询从而更新查询结果。所谓的“访问集合”包括读取集合的length属性、访问集合中的元素。
  因此,当你需要遍历HTML Collection的时候,尽量将它转为数组后再访问,以提高性能。即使不转换为数组,也请尽可能少的访问它,例如在遍历的时候可以将length属性、成员保存到局部变量后再使用局部变量。
  b. Reflow & Repaint
  除了上面一点之外,DOM操作还需要考虑浏览器的Reflow和Repaint,因为这些都是需要消耗资源的,具体的可以参加以下文章:
  如何减少浏览器的repaint和reflow?
  Understanding Internet Explorer Rendering Behaviour
  Notes on HTML Reflow
  (2). 慎用with
with(obj){ p = 1}; 代码块的行为实际上是修改了代码块中的执行环境,将obj放在了其作用域链的最前端,在with代码块中访问非局部变量是都是先从obj上开始查找,如果没有再依次按作用域链向上查找,因此使用with相当于增加了作用域链长度。而每次查找作用域链都是要消耗时间的,过长的作用域链会导致查找性能下降。
  因此,除非你能肯定在with代码中只访问obj中的属性,否则慎用with,替代的可以使用局部变量缓存需要访问的属性。
  (3). 避免使用eval和Function
  每次 eval 或 Function 构造函数作用于字符串表示的源代码时,脚本引擎都需要将源代码转换成可执行代码。这是很消耗资源的操作 —— 通常比简单的函数调用慢100倍以上。
  eval 函数效率特别低,由于事先无法知晓传给 eval 的字符串中的内容,eval在其上下文中解释要处理的代码,也就是说编译器无法优化上下文,因此只能有浏览器在运行时解释代码。这对性能影响很大。
  Function 构造函数比eval略好,因为使用此代码不会影响周围代码;但其速度仍很慢。
  此外,使用eval和Function也不利于Javascript压缩工具执行压缩。
  (4). 减少作用域链查找
  前文谈到了作用域链查找问题,这一点在循环中是尤其需要注意的问题。如果在循环中需要访问非本作用域下的变量时请在遍历之前用局部变量缓存该变量,并在遍历结束后再重写那个变量,这一点对全局变量尤其重要,因为全局变量处于作用域链的最顶端,访问时的查找次数是最多的。
  低效率的写法:
//全局变量
var globalVar = 1;
function myCallback(info){
for( var i = 100000; i--;){
//每次访问globalVar都需要查找到作用域链最顶端,本例中需要访问100000次
globalVar += i;
}
}
  更高效的写法:
//全局变量
var globalVar = 1;
function myCallback(info){
//局部变量缓存全局变量
var localVar = globalVar;
for( var i = 100000; i--;){
//访问局部变量是最快的
localVar += i;
}
//本例中只需要访问2次全局变量
globalVar = localVar;
}
  此外,要减少作用域链查找还应该减少闭包的使用。
  (5). 数据访问
  Javascript中的数据访问包括直接量(字符串、正则表达式)、变量、对象属性以及数组,其中对直接量和局部变量的访问是最快的,对对象属性以及数组的访问需要更大的开销。当出现以下情况时,建议将数据放入局部变量:
  a. 对任何对象属性的访问超过1次
  b. 对任何数组成员的访问次数超过1次
  另外,还应当尽可能的减少对对象以及数组深度查找。
  (6). 字符串拼接
  在Javascript中使用"+"号来拼接字符串效率是比较低的,因为每次运行都会开辟新的内存并生成新的字符串变量,然后将拼接结果赋值给新变量。与之相比更为高效的做法是使用数组的join方法,即将需要拼接的字符串放在数组中最后调用其join方法得到结果。不过由于使用数组也有一定的开销,因此当需要拼接的字符串较多的时候可以考虑用此方法。
  关于Javascript优化的更详细介绍请参考:
  Write Efficient Javascript(PPT)
  Efficient JavaScript
  2. CSS选择符
  在大多数人的观念中,都觉得浏览器对CSS选择符的解析式从左往右进行的,例如

toc A { color: #444; }

  这样一个选择符,如果是从右往左解析则效率会很高,因为第一个ID选择基本上就把查找的范围限定了,但实际上浏览器对选择符的解析是从右往左进行的。如上面的选择符,浏览器必须遍历查找每一个A标签的祖先节点,效率并不像之前想象的那样高。根据浏览器的这一行为特点,在写选择符的时候需要注意很多事项,有人已经一一列举了,详情参考此处。
  3. HTML
  对HTML本身的优化现如今也越来越多的受人关注了,详情可以参见这篇总结性文章。
  4. Image压缩
  图片压缩是个技术活,不过现如今这方面的工具也非常多,压缩之后往往能带来不错的效果,具体的压缩原理以及方法在《Even Faster Web Sites》第10章有很详细的介绍,有兴趣的可以去看看。
  总结
  本文从页面级以及代码级两个粒度对前端优化的各种方式做了一个总结,这些方法基本上都是前端开发人员在开发的过程中可以借鉴和实践的,除此之外,完整的前端优化还应该包括很多其他的途径,例如CDN、Gzip、多域名、无Cookie服务器等等,由于对于开发人员的可操作性并不强大,在此也就不多叙述了,详细的可以参考Yahoo和Google的这些“金科玉律”。

承受压力和心智成熟

在过去的7月自己成长了很多,经历很了很多。
自己也很庆幸,自己算是解决了一些问题,接下来的生活对自己来说是一个完全全新的开始。
自己希望可以在以后的岁月里面做的更好。
自己在7月的时候有更多的想法,但是现在自己的内心已经趋于平静。

{CSS}盒子模型新解

这几天在写fires,感觉对css有了新的理解。

盒子模型

分类

有两种, IE 盒子模型和标准 W3C 盒子模型 这边的区分是对width的计算。

标准盒子模型
例:一个盒子的 margin 为 20px,border 为 1px,padding 为 10px,content 的宽为 200px、高为 50px,
用标准 w3c 盒子模型解释,那么这个盒子需要占据的位置为:
宽 20_2+1_2+10_2+200=262px、
高 20_2+1_2_10_2+50=112px,
盒子的实际大小为:
宽 1_2+10_2+200=222px、
高 1_2+10*2+50=72px;
标准盒子模型content是不包含border和padding的值

IE盒子模型
一个盒子的 margin 为 20px,border 为 1px,padding 为 10px,content 的宽为 200px、高为 50px,
用ie 盒子模型,那么这个盒子需要占据的位置为:
宽 20_2+200=240px、
高 20_2+50=70px,
盒子的实际大小为:
宽 200px、
高 50px。
IE盒子模型content是包含border和padding的值

猜想:这边应该是和浏览器的解析机制相关,这边的原理应该同事件的捕获和冒泡机制,具体是对css属性值执行先后。
一下子我还想不明白,但时候再好好分析一下。
应该还涉及到BFC和hasLayout的内容(另外在做相关的分析)

定义

使用doctype作用是告知浏览器的,HTML是用那种文档规范书写,浏览器会更具对应的规范解析HTML代码。
doctype的标准模型和兼容模式

   alert(window.top.document.compatMode) ;

         如果输出的结果是
         //BackCompat  表示怪异模式
        //CSS1Compat  表示标准模式

传统Box模型:width包含border的字,在计算width的时候要把border的内容也计算在里面。
IE6及以下的浏览器都是传统Box模型的解析方式。
W3C标准推出以后,浏览器都开始采纳新标准,但存在一个问题就是如何保证旧的网页还能继续浏览,在标准出来以前,很多页面都是根据旧的渲染方法编写的,如果用的标准来渲染,将导致页面显示异常。为保持浏览器渲染的兼容性,使以前的页面能够正常浏览,浏览器都保留了旧的渲染方法(如:微软的IE)。
这样浏览器渲染上就产生了Quircksmode和Standars mode,两种渲染方法共存在一个浏览器上。

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">

严格模式表示文档会用标准盒子模型来展示

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

兼容模式表示在新的浏览器中使用标准盒子模型,老版本IE6 使用IE盒子模型。

理解

标准盒子模型为准。
盒模型: 内容(content)、填充(padding)、边界(margin)、 边框(border).
内容是width和height。
简单就是可以把盒子模型平面化为相框。
margin:是外边距,决定挂在墙上的空间和其他的相框之间的距离。
margin的作用是用来定义元素和兄弟元素父亲元素之间的间距。
border:是相框中边框的部分。
padding:是相框里面和画的间距,
padding是用来区分定义元素和子元素之间的距离。
content:是画的内容大小

再把画框立体化,因为其实页面是是一个三维图,还有一个css属性是z-index,表示在立体上面的纬度。
页面的三维图是:
x轴:width
y轴:height
y轴:z-index
xy是从css属性background-repeat:repeat-x和repeat-y看出xy的分法,单位是自定义的,可以是px,em
z轴是限定单元的,自己需要定义数字。
xy都是正向的,最小值是0,最大值可以无限,
z轴可以正负数。

我以前一直把盒子模型理解为PS中的图层,这个在html5的canvas中更加生动。

margin和padding的争议

margin和padding都是间距,一个是外间距,一个是内间距。其实一看就明白,在页面中一个间距的效果可以用margin和padding实现。

<div style="padding:20px"> 
    <p >段落</p>
</div>

<div > 
    <p style="margin:20px">段落</p>
</div>

上面两种效果是一样的,也就是在父元素中使用padding,在子元素中使用margin。
margin是对内的,是对子元素的间距。
padding是对外的,是对父亲元素和兄弟元素间距。
这边有一点是重合的,就是对子元素的间距(padding)同时可以用对父亲元素的间距(margin)来实现。
但是一点是不重合就是margin对兄弟元素的实现,用padding可以实现对应的效果,但是根据盒子模型来看
就不是一个层面的东西了的。所以在对和兄弟元素的间距的时候不应该使用padding,要使用margin。

那在父亲元素和子元素的间距使用padding还是margin?
这边我的建议是一致使用padding,在父亲元素中使用padding。
理由是:
1.padding控制父子间距,margin控制兄弟间距
2.content的拉伸机制。在子元素中使用margin,间距会占去在拉伸机制下的block的width和height。
inline的height。而在父亲元素中使用padding,width,height会做大100%拉伸,且大小和夫妻元素相同。
3.从外向内写。

所以在fires我的一个规范就是父子关系用padding,不使用margin,只用兄弟间距使用margin。

padding和text-indent的争议

其实可以实现间距的属性还有text-indent。在单行文本的情况下。padding-left实现的效果和text-indent
效果相同,但是在盒子角度上来说有不一样的。padding会改变width的大小,但是text-indent不会。
我们用word来理解就是padding是整体缩进,text-indent是首行缩进。
且padding不可以为负数,text-indent可以为负数。
我在fires中使用text-indent来实现左边icon的效果实现,这样就不会出现对盒子模型的改造。
icon也作为内容被content包含。具体实现是文字text-indent,icon浮动或者绝对定位,这边绝对定位更好,因为浮动会产生新的盒子模型。

下图是我对两者的比较试验:

padding
代码是

<style>
.container{ width:200px; margin:10px auto; border-bottom:1px solid #999}
</style>
    <div class="container">
        <p style="padding-left:20px;">
商店的展示厅其实是一个船运集装箱,有一面大型单片玻璃落地窗,并且没有明显
        </p>
    </div>
    <div class="container">
            <p style="text-indent:20px;">
商店的展示厅其实是一个船运集装箱,有一面大型单片玻璃落地窗,并且没有明显
        </p>
    </div>
    <div class="container">
            <p style="text-indent:-20px;">
商店的展示厅其实是一个船运集装箱,有一面大型单片玻璃落地窗,并且没有明显
        </p>
    </div>

    <div class="container">
    <p  style=" text-align:right;text-indent:20px;">    
商店的展示厅其实是一个船运集装箱,有一面大型单片玻璃落地窗,并且没有明显
        </p>
    </div>

{css}页面重构--css模块化

页面重构

前言

上午想试试自己的重构水平,开始做@sofish的题目,做了一半就推到重来。然后又是有做了一半感觉还是不行,
开始推到重来。
自己去搜索了一下重构相关知识,做一下总结。

重构要做什么

自己对页面重构简单的定义就是写好的页面。便宜有便宜的做法,贵有贵的做法。技术只是一种手段,解决问题才是产品的核心。没有用的知识也就是高雅的玩具。这边ele现在就是便宜的做法,但是他解决了问题,拿到了钱,接下来他要做的就是贵的做。所以我感觉在做技术的时候要关注的是解决问题,而不是技术本身。
页面可以展现和合理的展现和完美的展现的差别不是一点。
下面是百度百科中对重构页面的流程说明,我感觉说的很好,这边实现是有先后顺序,先解决问题,然后在想怎么更好的解决问题。
简单来说页面重构需要的做到就是三点点:内容样式行为分离,HTML语义化,CSS模块化。
页面重构师
中定义了重构的工作流程和相关要求。

重构的目标

其实页面重构也是MVC实现的体现,目的是为了方便快速开发和以后的需求改动。
内容样式行为的分离。

我们一直追求这样的代码:
简洁:
HTML:最少的、语义化的标签,实现所需要的结构。
CSS:高复用、低冗余的定义
灵活:
HTML、CSS:最少改动,最多效果
可维护:
HTML、CSS:最快的速度定位到问题,最少的改动解决问题

重构的方法--CSS模块化

页面重构中的模块化核心**:将HTML和CSS通过一定的规则进行分类、组合,以达到特定
HTML、CSS在特定范围内最大程度的复用。
CSS模块化的目的是为了方便开发,更好的解决样式的继承和修改。
模块化就能解决掉上面提出的大部分的问题:
● 提高代码重用率
● 提高开发效率
● 减少沟通成本
● 降低耦合
● 降低发布风险
● 减少Bug定位时间和Fix成本
● 提高页面容错
● 更好的实现快速迭代
● 更好的支持灰度发布
还有就是模块化可以提高开发效率的问题,这是谁不喜欢的那?电脑和生活都不是技术的全部。

CSS模块化是在原来的内容样式行为的分离的基础再对CSS页面进行细分。
以前做外包网站的为了便于开发,我们提出了一种LMC的**。CSS的模块的想法和这个想法大体一致。
几乎所有页面都是相似的,都有header,footer甚至是页面内容都是相似,所以我可以把相似的内容提取出来,
在页面开发中做到重用,网站的开发和其他网站的开发中。
将页面模块氛围三部分。
layout:布局层(典型:header,控制页面大的布局)
model:模型层(典型:nav,model是小的模块,控制各个模块的展现和各个页面的的距离。 )
content:内容层(典型:list,控制样式的重现和布局)

这边根据alice规则来对css模块化做一个分析。
alece

在上面的代码中ui-name就是一个css模块,在ui-name里面一般只定义了实现这个样式的基本css属性。
在定义css的时候要保证这个css是有一定的扩展性的,而且是可以伸缩的,最好不要过多的定义css的自身属性内容。
ui-name-status是对这个模块在页面中使用的特殊样式的定义。
Alice 规范和最佳实践
在链接中还规定了其他的一些命名方法和规定。自己在后面的内容也做了一定的参考
其实在看完Alice后对css模块化还是缺少理解。

类OOP

其实用OOP**来理解css模块化要简单的多。下面介绍一下用OOP的**来理解css模块化。
css模块化的基础是css的优先级和继承机制。
下面对这些css基础做一些简单的回顾:

css优先级:

  1. 不同的样式定义有不同的权值,具体的值不得而知,但优先顺序大体如下:important

    内联 > ID > 类 > 标签 | 伪类 | 属性选择 > 伪对象 > 通配符 > 继承

  2. 只有同类的定义才需要比较大小,否则遵循权值的优先级
  3. 同类定义的比较中,如ID与ID比较,权值相同时,遵循“就近原则”,即最接近标签的定
    义优先,因此,样式定义所在的位置也是控制作用域所必需掌握的,优先级为:内联 >
    内嵌 > 外部;同个文件内的优先级:后定义的高于先定义的。
    PS:这边的css模板扩展的书写方式是class="mod new-mod"这样的熟悉方式才是有效果的,后面的是些方式是无效的class="mod" class="new-mod"

css选择器效率

浏览器是从右向左来遍历DOM接线,选取相关的DOM节点内容的。
ID最快,Universal最慢 有四种类型的key selector,解析速度由快到慢依次是:ID、class、tag和univers
后代选择器会减慢浏览器的解析过程。

css继承

css的文本属性会给子元素继承。
在下面介绍方法中我们将一个标签拥有两个class的时候,把后面的一个class当做是前面一个class的子元素,
会对父亲元素的属性进行继承,可以在原来属性的基础上进行扩展,当子元素有自己的值的时候会对属性进行宠幸赋值。

我们把一个css模块氛围一下三种类型:

基类

基础模块定义,一般我们会把经常用的模块定义为基类,以减少代码量。就是最简单的样式实现的效果。

扩展类

当一个基类在不同的位置使用时,有可能会因具体环境而需要有大部分展现上的或小部分结构
上的调整,如果通过复制新建模块的方式,会出现大部分的代码冗余,这时可以通过定义一个
扩展类来解决。

实例类

用于模块在具体页面中的细节修正,如位置、颜色等只在当前页面的展现。我们可以把实体类当做是基础类和扩展类的之类,实体类继承了父类的css属性,对应相同的属性,实体类给予了重新赋值。

基础类和扩展类都不应该写死,而是应该有一定的可扩展性,在积累和基础类中尽量只书写css的展现样式和少量的css文本样式。而css的自身样式应该是在实体类的书写。一般情况下,用基础类和实体类就可以完成。

一般情况下,模块的定义使用后代选择器来完成,尽量控制在三层或以下,可以使用以下的规
则:

<!--mod-box是基础类 new-mod-box-1是实体类-->
<div class="mod-box new-box-1">
    <div class="mod-box-head">
        <h3 class="mod-box-head-title">区块标题</h3>
        <span class="mod-box-head-text">其他文字</span>
        <a href="#" class="mod-box-head-more">更多</a>
    </div>
    <div class="mod-box-container">
        <div class="mod-box-content">ui-box-content 有默认内边距</div>
    </div>
</div>

/* 基类 */
.mod-box{}
.mod-box-head{}
.mod-box-head-title{}
.mod-box-head-text{}
.mod-box-head-more{}
.mod-box-container{}
.mod-box-content{}

/* 实例类 考虑到权重,
后面的属性会覆盖基础类中的属性,
而在实体中没有的属性会继承 */
.new-box-1{}
.new-box-1 .mod-box-head{}
.new-box-1 .mod-box-head-title{}
.new-box-1 .mod-box-head-text{}
.new-box-1 .mod-box-head-more{}
.new-box-1 .mod-box-container{}
.new-box-1 .mod-box-content{}

除了模块名和作用对象之外,中间的用于控制作用范围的选择器可以尽可能的少,只要能与其
它的定义区分开即可,并不一定非得把所有的层级都写进去。这样可以更好的减少权值的大小
,有利于后继的重定义。同时也提高了css的解析熟读

TIPS:
并不是所有的模块都必需很健壮。
虽然我们都希望我们写出来的模块十分的健壮,可以在从任何的地方使用,但事实上并
非如此,健壮的代码意味着更多的冗余,这对于网站整体来说并不是最有利的。
也并不是所有的html元素都应该有基础类和实体类,有时候只要一个实体类也可以解决问题。
我们的目的是更好的更有效率解决问题,

上面自己演示了css模块化例子,这边参考了OOP的一些设计上的原则,这样就会对css模块化更加便于理解,像“开闭原则”、“替换原则”、“依赖
原则”、“接口分离原则”等。当然也需要重新的解读:
基本原则

  1. 开闭原则
    扩展性是开放的;更改性是封闭的
    “开放的扩展性”,就是在基类的基础上,可以做的扩展是灵活的。封闭性的原则是指对模块内
    的修改,应该是封闭在模块内的,不影响到模块之外的内容。通常我们使用包含选择符的方式
    来实现。在基础类的选择器前面加上一个实体类就会比原来的基础类的权重高,会对继承的css属性重新赋值。
    .mod-name .class-1{...}
    .mod-name .class-2{...}
  2. 替换原则
    父类可出现的地方,子类可出现;反之不一定
    一个能够反映这个原则的例子是圆和椭圆,圆是椭圆的一个特殊子类。因此任何出现椭圆的地
    方,圆均可以出现。但反过来就可能行不通。这里的父类与子类,主要是指基类与扩展类之间
    的关系。
  3. 依赖原则
    接口:扩展类只负责模块效果的补充;实例类不影响扩展类与基类间的依赖关系
    结构化设计:高层抽象模块依赖底层抽象模块
    这里主要是指基类、扩展类与实例类间的关系,它们是共同作用于一个HTML结构的。扩展类
    依赖于基类,基类或基类加护展类组成一个完整的效果,实例类是做为模块在当前页面的补充
    定义,帮助模块实现最终的效果。
  4. 接口分离原则
    各接口负责不同的效果
    一个样式定义比如.css{},与HTML结构

    之间要产生关联,是通过标签的class属性
    进行的,结果就是

    ,这个class属性就是HTML与CSS之间的接口。因
    此,使用内联的样式定义,就与这个原则相违背了。同样的,一个HTML文件使用外链的方式
    引用CSS文件,也是适合接口分离的原则。

样式命名规则

内容模块的命名

基类命名

mod-[模块名]-[编号]
前缀:基类的模块标识。如“mod”。
模块名:模块名称。
编号:模块的编号,用于区分同类模块。当只有一个版本时不需要写模块编号,即基类命名中
模块编号一定是大于“1”的。
例:
.mod-tab{}
.mod-tab-2{}

子模块命名

子模块 = 模块名 + 子模块名
常用模块名有:cnt(content),hd(header),text(txt),img(images/pic),title,item,cell 等, 只要词义表达了组件要实现的功能或者要表现出来的的外观就可以了。
子模块状态 = 模块名 + 子模块名 + 状态

扩展类命名

exp-[模块名]-[模块编号]-扩展类编号
属于栏目级的公共模块定义。
前缀:扩展类模块标识,如“exp”。
例:
.exp-tab-1{}/扩展类1,基于基类tab/
.exp-tab-2{}/扩展类2,基于基类tab/
.exp-tab-2-2{}/扩展类2,基于基类tab-2/

实例类命名

new-[模块名称]-[位置]-[名称]

页面级模块定义,与ID类似,有在一个页面中唯一的特点。
前缀:实例类标识。如“new”。
作用:定义类的作用,用于对类型的补充。
状态:定义类的状态,用于对类型的补充。
位置:定义类所使用的位置,如首页、导航等等,不排除使用左、右这样的词,但应尽量避
免。
例:
.new-news-page-form{}//
.new-index-login{}/
/
用于模块内部的命名

布局模块命名

lay-[位置]-[名称]
例:
.lay-header{}
.lay-footer{}

内容模块命名

con-[模块名称]-[位置]

状态类

状态类一般以表示状态的单词来表示,只用于模块内部,即定义时必须限制在模块内部。一般
与实例类放在一起。

常用状态有:hover, current, selected, disabled, focus, blur, checked, success, error 等。通常你的命名应该看起来像 .ui-name-hover, .ui-name-error 这样。

例:
.new-index-login .nonce{}
.new-index-login.hover{}

元素类
前缀:元素类型名称。如“icon”。
例:
.icon-ok{}
.icon-error{}
尽可能的使用不带状态的名词
TIPS:
同一个单词可以被多处使用,但当可能出现嵌套时,应该为它加上前缀。
当一个定义可能被继承或影响到其它同类标签的时候,应该选择使用“class”

<div class=”lay-local-name”>
<div class=”box-name-a”>
<div class=”mod-modname-1 exp-modname-1-1 new-modname-1-1-newname”>
<div class=”g-modname-1”></div>
</div>
</div>
<div class=”box-name-b”>
<div class=”mod-modname-1 new-modname-1-newname”>
<div class=”g-modname-1”></div>
</div>
</div>

</div>

模块管理的问题

当你的模块越来越多之后,模块的管理问题就会随之而来。公共文件越来越大,一些使用不上
的模块也因为放在公共文件中而被不断的重复加载,造成带宽的浪费。聪明的你一定想到了,
把模块拆出来,按需加载:

如上图,每一个模块分别拆成独立的文件,然后通过引用外部文件的方式链接到当前页面的样
式文件里,从而实现按需加载。然而,这样会引发另一个问题,链接数的增加。一个页面有多
少个模块,就会增加多少个链接,显然不是我们所希望的。
我们都知道,解决链接数过多的方法很简单,就是把它们合并就行了。那么,我们同时需要解
决合并后所可能带来的问题——怎么更新的问题。

{fires} fires--前端解决方案介绍

Fires

前言

Fires 的名字来自多火,我以前在在的团队,中文名字叫做艾斯,来自海贼王的火拳艾斯。
Fires 星星之火,可以燎原。
Fires 是一种解决方案,并不是一个框架。
Fires 是火柴,并不是火把。
Fires是基于原型,面向设计开发的前端解决方案。

logo

设计**

设计**参考:MVC**,面向对象和基于原型
理论基础:标准盒子模型,css分类、书写顺序和继承 css层叠机制 (优先级和权重) css拉伸和包裹 浏览器对css的解析机制 。

从面向效果的开发向面向设计开发的转变

前端一般将页面开发分为内容(HTML),样式(CSS),行为(javascript)。
在页面开发的时候做到相互分离,其实我感觉这边有一个MVC**的延伸,
我们把HTML看做是View,是内容,是数据,
把CSS看做是model看做是容器,是模型,
把javascript看做是Controller是控制,是行为。

在以往的开发中,我们一般是做出一个页面,做出一个网站,给每个页面效果都写html和css实现,
后来我们有了html语义化的要求,有了css模块化的要求。

fires在这个基础上在对内容(HTML)和样式(CSS)借鉴MVC的**来进行细分。
HTML分为layout(布局层)、model(模型层)、content(内容层)
把CSS属性分为展现属性(Controller),自身属性(model)和文本属性(view)。

把一个页面设计图通过分析,提取出可以复用的模块,做到模块间的解藕。
每个模块可以看做是一个独立的整体,相互嵌套,组装成页面效果。
再利用原型的**来实现原有css模块的页面设计图的不同效果实现。

layout 层 :主要控制页面大区块的布局,典型模块是header.footer
model层:主要页面的可嵌套容器,典型模块是box,tab,nav
content层:主要控制页面的内容展现样式,典型模块是list

对model和content的分类依据是模块内部是不是可以嵌套其他的model和content。可以那么是model,不可以是content。
这边有点像是结构化块状元素,多目标块状元素和终端块状元素的分法。

css模块化向css模块原型化的转变

其实这边有点OOP的**,但是我感觉用js中原型的**更加容易理解,
考虑到浏览器的解析机制,和html、css和javascript一样是解析执行,
原型的理解可能也更加符合实际底层的机制。

这边的一个基础是:css优先级+css权重+css书写顺序来计算页面html到底会显示那些css属性,也就是css的层叠机制,
Cascading Style Sheets的Cascading。

下面我利用alice中的box来进行改造和讲解。
alice-box
alice-box github
修改前的效果
alcie show

上图是alice中box在500px宽度下面的实现效果。
代码如下:
HTML:

<div class="lay-container">
        <div class="ui-box">
            <div class="ui-box-head">
                 <h3 class="ui-box-head-title">区块标题</h3>
                 <span class="ui-box-head-text">其他文字</span>
                 <a href="#" class="ui-box-head-more">更多</a>
             </div>
            <div class="ui-box-container">
                <div class="ui-box-content">ui-box-content 有默认内边距</div>
            </div>
        </div>
        <div style="margin:15px 0 0 0"></div>
        <div class="ui-box">
            <div class="ui-box-head">
                <h3 class="ui-box-head-title">没有内容</h3>
                <span class="ui-box-head-text">其他文字</span>
                <a href="#" class="ui-box-head-more">更多</a>
            </div>
            <div class="ui-box-container" style="display: none;">
                <div class="ui-box-content">ui-box-content 有默认内边距</div>
            </div>
        </div>
        <div style="margin:30px 0 0 0"></div>
        <div class="ui-box">
            <div class="ui-box-head">
                <h3 class="ui-box-head-title">区块标题</h3>
                <span class="ui-box-head-text">其他文字</span>
                <a href="#" class="ui-box-head-more">更多</a>
            </div>
            <div class="ui-box-container">
                <div class="ui-box-content">ui-box-content 有默认内边距</div>
            </div>
        </div>
        <div class="ui-box ui-box-follow">
            <div class="ui-box-head">
                <h3 class="ui-box-head-title">连着上面的box</h3>
                <span class="ui-box-head-text">其他文字</span>
                <a href="#" class="ui-box-head-more">更多</a>
            </div>
            <div class="ui-box-container">
                <div class="ui-box-content">ui-box-content 有默认内边距</div>
            </div>
        </div>
    </div>

CSS:

.lay-container{width:500px;margin:20px auto ;}

.ui-box{border:1px solid #ccc;zoom:1;font-size:12px;margin:0;padding:0;border-bottom:0}
.ui-box:after{clear:both;content:" ";display:block;font-size:0;height:0;visibility:hidden}
.ui-box-follow{border-top:0}
.ui-box-head{border-bottom:1px solid #ccc;position:relative;padding:10px;height:16px;line-height:16px;
    background:-webkit-gradient(linear,left top,left bottom,from(#fcfcfc),to(#f9f9f9));
    background:-moz-linear-gradient(top,#fcfcfc,#f9f9f9);
    filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#fcfcfc', endColorstr='#f9f9f9');
    background:-o-linear-gradient(top,#fcfcfc,#f9f9f9);
    background:linear-gradient(top,#fcfcfc,#f9f9f9);zoom:1}
.ui-box-head .ui-box-head-title{color:#656565;font-size:14px;font-weight:700;float:left;
    display:inline;margin:0;padding:0}
.ui-box-head .ui-box-head-more{float:right}
.ui-box-head .ui-box-head-text{margin-left:10px;color:gray;float:left}
.ui-box-container{background:#fff;border-bottom:1px solid #ccc}
.ui-box-content{padding:10px}

我们可以看到源代码已经把浮动清除的方法:
.clearfix:after {content:"."; display:block; height:0; visibility:hidden; clear:both; }
.clearfix { *zoom:1; }
内置在在css中,这边的浮动清除还应该是清除错误的。

上面效果可以看做是一个box模型在四种场景中的使用(这边是设置不同的margin)。
我利用fires的规范来对alice box模型进行改造。

box是一个可以嵌套的内容的元素,所以应该属于model层。
用mod-box来代替原来的ui-box命名规范。我们把mod-box叫做box原型,
把new-mod-box-hidden、new-mod-box-margin、new-mod-box-follow叫做是box实例。
修改后的效果
fires show
改造后代码如下:
HTML:

    <div class="lay-container">
        <!-- 下面是mod-box的原型 -->
        <div class="mod-box">
            <div class="mod-box-head">
                 <h3 class="mod-box-head-title">区块标题</h3>
                 <span class="mod-box-head-text">其他文字</span>
                 <a href="#" class="mod-box-head-more">更多</a>
             </div>
            <div class="mod-box-container">
                <div class="mod-box-content">mod-box-content 有默认内边距</div>
            </div>
        </div>
       <!--  下面是mod-box的实例 -->

        <div class="mod-box new-mod-box-hidden">
            <div class="mod-box-head">
                <h3 class="mod-box-head-title">没有内容</h3>
                <span class="mod-box-head-text">其他文字</span>
                <a href="#" class="mod-box-head-more">更多</a>
            </div>
            <div class="mod-box-container" >
                <div class="mod-box-content">mod-box-content 有默认内边距</div>
            </div>
        </div>

        <!--  下面是mod-box的实例 -->
        <div class="mod-box new-mod-box-margin">
            <div class="mod-box-head">
                <h3 class="mod-box-head-title">区块标题</h3>
                <span class="mod-box-head-text">其他文字</span>
                <a href="#" class="mod-box-head-more">更多</a>
            </div>
            <div class="mod-box-container">
                <div class="mod-box-content">mod-box-content 有默认内边距</div>
            </div>
        </div>
        <!--  下面是mod-box的实例 -->
        <div class="mod-box new-mod-box-follow">
            <div class="mod-box-head">
                <h3 class="mod-box-head-title">连着上面的box</h3>
                <span class="mod-box-head-text">其他文字</span>
                <a href="#" class="mod-box-head-more">更多</a>
            </div>
            <div class="mod-box-container">
                <div class="mod-box-content">mod-box-content 有默认内边距</div>
            </div>
        </div>
    </div>

在HTML中和alice的不同是去重新设置class name,去掉了原来的两个有margin的div和原来内嵌在html中的
display:none。

CSS:

.lay-container{width:500px;margin:20px auto ;}
/*下面是box原型的css*/
.mod-box{border:1px solid #ccc;zoom:1;font-size:12px;margin:0;padding:0;border-bottom:0;}
.mod-box-head{border-bottom:1px solid #ccc;position:relative;
padding:10px;line-height:16px;
background:-webkit-gradient(linear,left top,left bottom,from(#fcfcfc),to(#f9f9f9));
background:-moz-linear-gradient(top,#fcfcfc,#f9f9f9);
filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#fcfcfc', endColorstr='#f9f9f9');
background:-o-linear-gradient(top,#fcfcfc,#f9f9f9);
background:linear-gradient(top,#fcfcfc,#f9f9f9);
zoom:1;}
.mod-box-head:after{content:"."; display:block; height:0; visibility:hidden; clear:both; }
.mod-box-head-title{color:#656565;font-size:14px;font-weight:700;float:left;display:inline;margin:0;padding:0}
.mod-box-head-more{float:right}
.mod-box-head-text{margin-left:10px;color:gray;float:left}
.mod-box-container{background:#fff;border-bottom:1px solid #ccc}
.mod-box-content{padding:10px}
/*下面是box实例的css*/
.new-mod-box-hidden{margin: 15px 0 0 0;}
.new-mod-box-hidden .mod-box-container{display: none;}
.new-mod-box-margin{margin: 30px 0 0 0;}
.new-mod-box-follow{border-top:0}

改动是把css选择器都改成是class选择器,没有使用子类选择器。
把clearfix的方法从原来的ui-box移动到mod-box-head中,去掉了mod-box-head的height
还有就是对实例的属性书写。
在上面的例子中,我们把mod-box叫做box原型,
把new-mod-box-hidden、new-mod-box-margin、new-mod-box-follow叫做是box实例。
mod-box作为原型,应该做到对外的是拉伸,对内是包裹,浮动清除方法内置。

利用css层叠机制实例继承了原型中的属性,
利用css层叠机制实例可以对属性重新赋值和增加属性。

...

我们通过这种方式来写,new-mod-box-hidden实例写在原型的后面,用new来标记是实例。
在css代码中
.new-mod-box-hidden{margin: 15px 0 0 0;}//利用css的熟悉书序
.new-mod-box-hidden .mod-box-container{display: none;}//利用css的权重计算

mod实例是写在mod原型后面,这边要特别注意,因为只有写在后面实例属性才会对原型中已有的属性进行重新赋值。
.new-mod-box-hidde用css属性书写顺序来实现层叠,
.new-mod-box-hidden .mod-box-container使用权重来实现层叠。
通过这种方式来分离原来在alice中的模型,把特殊的三个应用提取到实例中来。
把第一个mod-box当做是原型的实例。

这种css模块原型花对layout、model、content都是适用的,css模块分为css模块原型和css模块实例。
原型是通用类库,实例是实际应用。

大体就是如此。
其实如果我讲明白了的话就是:
页面分层,模块实例。

至于css属性的分类,书写书序、标准盒子模型的理解以及对外的拉伸和对内的、模块的浮动清除等内容应该是内置
在模块的css中的。

{life}next!

今天自己从电信离职。自己从实习开始在电信工作一年半时间,但是在这一年半的时间里面自己还是没有感到过很快乐,以及技术本身给自己带来的快感,自己也始终没有办法说服自己。让自己相信做的事情是为人民服务。自己对自身的价值不怎么认同。

在电信的这一年半是平静和安逸的一年半,自己看了很多书,也有时间去做自己想做的事情,自己做了几个自己的项目,但是都不怎么成功。

在电信的一年半时间里面自己并没有像自己希望的那样快速成长,但是在这一年半的时间自己还是看到了一个更大的世界,自己知道了很多学校以外的事情,自己也做好自己的本职工作。但是我一直不喜欢这种生活方式,虽然这一度是自己以前认为的梦想的生活。但是我感觉这也就是自己给毕业的后自己的生理和心理的调整期,而大企业进去看看,呆个一两年,看看到底是怎么回事,然后学学为人处事,学学怎么写文档和邮件就已经差不多了的。

接下来的公司是意见金融的软件行业,算是金融互联网和互联网金融行业吧,去那边做移动端的前端内容,算是回到自己喜欢的领域和内容上面来,但是以后的生活应该是没有自己现在这么轻松的。总之加油吧。

simple javascript

simple javascript

《JavaScript高级教程》的学习笔记。
尝试把书读薄,再看这本书,构建完整的只是体系。
目录:

  1. 浏览器工作原理
  2. 简介
  3. 使用
  4. 基础
  5. 引用
  6. 面向对象
  7. 函数
  8. BOM
  9. 客户端
  10. DOM
  11. DOM扩展
  12. DOM2和DOM3
  13. 事件
  14. 脚本表单
  15. canvas
  16. HTML5
  17. 调试
  18. js和XML
  19. E4X
  20. JSON
  21. Ajax
  22. 高级技巧
  23. 离线应用
  24. 最佳实践

简介

JavaScript

  • JavaScript: JavaScript的实现由下面三部分组分
    • ECMAScript:核心与语言,语法规定
    • DOM:访问和操作页面的方法和机构
    • BOM:与浏览器交互的方法和结构

使用

  • 执行方式: 解析执行,同html,css至上而下
  • 使用:内置和引用
  • defer:延迟,defer="defer"
  • defer:异步,async src="example1.css" 执行,不妨碍加载但无先后顺序
  • doctype:严格模式、兼容模式
alert(window.top.document.compatMode) ;
如果输出的结果是
 //BackCompat  表示怪异模式
 //CSS1Compat  表示标准模式 

基本概念

  • 语法

    • 区分大小写
    • 标示符
    • 注释
    //单行
    /*
     *   多行注释
     *   对航
     */
  • 变量:

    • var
    • 弱类型
    • 局部:*{var message=100;}
    • 全局:*{ message=100;}
  • 数据类型:

    • 原始值: 相当于传值
    • string
    • number
    • boolean
    • null
    • undefined
    var foo = 1,
        bar = foo;
    
    bar = 9;
    
    console.log(foo, bar); // => 1, 9
    • 复杂类型: 相当于传引用
    • object
    • array
    • function
    var foo = [1, 2],
        bar = foo;
    
    bar[0] = 9;
    
    console.log(foo[0], bar[0]); // => 9, 9

{life}对技术的反思

这几天我一直在想,技术的价值,意义,作用。还有就是我们的生活是不是真的需要那么多的智能化和数字化。需要那么多的社交网站和移动APP应用。

这几天我换了一个大妈牌三星手机,安卓的系统,一来是我发现,时代的确是在变化,我的黑莓已经跟不上时代的步伐,无论我如何坚守我还必须承认现实,二来是我后面的工作多对应的熟悉,毕竟移动互联网在我看来的确是这个时代的主流。我认为自己是一个坚实的科技推动者,但是我在一定程度上保持一种在这个行业的从业者少有的钝感。

我坚信“Computer can make life better!”但是我也一直认为手机和电脑不过是一种电器,我们才是生活的主导。我一直不认为电脑可以是生活的全部,虽然在这一点自己在很多时候做的都不好的,但是我一直认为如果你的生活中电脑已经成为你的隐形依赖的话,那么轻离开你的电脑一段时间,手机,同样是这样的。我很讨厌,一群人在玩电脑,手机,但是没有沟通,我看到吃饭的时候还在玩手机我就感觉真的很好笑。难道我们连好好坐下来吃一顿饭和朋友好好交心的时间都没有了吗》如果是这样我们要那么多科技做什么。

我始终认为知识也好,技术也好,都是用来解决问题的,在生活中有一个问题,我们通过知识的积累,科技的时间去解决这些问题,或者说是去比较好的,比较优秀的解决这些问题,这边的优秀可以是更快,更方便,更直接。其实我认为是有的互联网和移动互联网的产品都应该是用来解决问题的,而不是制造问题。事实上也是这样,产品用来解决一些问题,但是并不是所有人都有这样的问题,也不是所有人需要更优秀的解决这些问题。对于那些电子产品,我的观点是没有什么是最新,也没有什么一定是最好,但是你要去尝试,去探索,去发现那种方式,那种组合是最适合自己的。是的呀,是适合,而不是昂贵,也不是最优。适合自己的的才是最好的。

我从小就被教育什么时间做什么事情,卧室里面不能吃放,床上不能看书。我现在也这么认为什么东西都是单一的利用,这样会变的比较高翔和使用,但是现在有太多的组合出现,我并不是说这种组合不好,这是一种时代的进步,自己无比赞成这一点,也为时代的进步而感到高兴,但是我有时候不免想一下这种组合的带来的问题。

我一直认为手机就是用来电话,短信,邮件,而不是游戏和娱乐,平板是用来放松和娱乐,kindle是用来学习,电脑是用来工作,当然在我的使用这几样东西会交叉使用,但是当我切换工具的时候我会告诉自己现在的状态是不一样了的,自己要不同的心态去接受这个状态,是一种有意或者是无意的心里提示。

我至今还不太使用微信,其实我不实用的原因很简单,我不怎么习惯在微信上面语音,我跟喜欢有事情直接电话,淡然打情骂俏不在这个行列,我也嫌微信打字速度太慢,赶不上自己的电脑。

我知道KK至今还不用手机,但依然是这个时代科技的导师。

这几天对自己技术上的追求也想了很多,我们以前的那一帮人很早就知道技术的重要性和局限性,我们认为技术只占百分子二十,其他的东西是百分之八十,一个产品的技术好坏自然是成功与否的基础,但是并不是关键因素和决定因素,除非技术本身是有突破的,是绕过现在的所有的技术的。除了这种情况,运营呀,管理呀,财务呀,营销呀,各种因素才是决定产品的胜负,成败的关键。其实这边我感觉是一个综合的因素。

前端时间老马和我喝酒,也和我说什么时候我不怎么关注与技术了,或者说什么时候不怎么关注技术了,我可能就胜利了,因为其实我自己也很明白可能自己的爱好和性格更加适合当一个产品经理,但是我自己知道技术是基础,是那开始的百分子二十,我想先做好这一块,先做好着百分之二十。

这几天突然感觉这个行业里面牛人太多,自我认知,自己的智商和努力程度可能到不了这个行业的巅峰水平。我一开始选择这个行业的原因有两个,我也说给自己的母亲听,一个是这个行业是站在时代的前列的,我看到的东西比别人快,我可以看到这个时代的变化和发展,想想十年前的互联网和五年以前的移动互联网吧,那个东西不会在改变人类的历史。第二个是这个行业总是有新鲜感,我可以不断的学习新知识,新技术,并且去实践,这样我就不会那么无聊,我不用吧实践放在无聊的游戏和电视剧上面。今天我依然坚持第一个,但是我对第二个的想法有了不一样的认识。可能那只是年轻的时候年少轻狂的认知吧,人老酒希望学习一个东西就不断的应用,这个东西不会因为是时代的变化而改变,但是这种东西很少,我不是说没有,但是不学习就想永远保持成功是不怎么可能的。

我这几天突然感觉对技术的害怕,这种害怕是来自对自我和对技术的认知,承认以自己的水平可能无法在这个行业里面达到时间顶尖的水平,而自己又是一个极端的人,做不了最好的,基本上很难说服自己的内心,我也承认了这一点,所以我感觉现在的自己对技术并不是那么追求了的。我还是认为技术是应该用来解决问题的,而更好的,跟优秀的解决问题是在解决的问题的基础上我们在做对应讨论。技术的更新的速度太快了,更新的东西太多了,想要都去深入的了解我感觉是不可能的,也没有必要,我早就说过,电脑不是生活的全部,除了技术,生活还有很多没有的东西。技术本身应该只是我们自身追求美好生活的手段和工具,而不是目的和目标。所以解决问题要找到合适的方式,要找到合适技术,但是你不去了解全面的即使怎么有知道什么才是合适的那,这边就是一个无解的悖论,我想我没只能量力而行,全力以赴了吧。

“吾生也有涯,而知也无涯。以有涯随无涯,殆己!”在我现在看来一味的追求技术是没有什么好结果的,至少对个人来说,当然这种好结果是相对的,技术可以让生活温饱自然是没有什么问题的。但是相比那些更加轻松获得利益和成果的人来说,做技术的人辛苦了一点,自然有人喜欢这样的生活,那是个人选择,建议和意见都不是我们人生的决定的关键,选择我们人生的只有是我们自己。

我还是认为技术是用来解决问题,而是不是要完美的解决这个问题的,或者说完美的解决这个问题的代价就有待商榷了的。

我一直比较反对加班,特别对通宵写代码深恶痛绝,我认为这会违背人性的,我也因为这种想法被人认为不怎么适合创业型公司。我为这种机会的市区会心痛一下,但是并不会长久。帮别人实现梦想和创造价值的时候我永远都只会用8分力气,剩下的两分我用来生活,这可能有点自私,但是很不幸,你给我的价值我可能已经用了4分都已经帮你匹配了的,余下的力气是我自己的,只有在做自己的事业的时候我才会用12分力。这就是脑力劳动者的工作时间和效率问题。时间并不会代表产出。

我想我没都是平凡的人,平凡也是我们唯一的出路。

科技是这个时代的主题,是你生活的重要组成部分,但是我希望自己记住,这并不是主要的东西,花时间和朋友和家人在一起,而不是电脑。

最后我希望可以为科技做点什么东西,不负父母的期望,对得起我的名字。

{life}黑桃3和黑桃A

上个月从电信离职。来到了同花顺。

离职后自己给了自己一周的调整时间,我知道我需要时间来做调整,过去的一段时间里面发生了太多的事情,对自己和对我的家庭都是这样,我们需要时间来接收这边变化,认清现实,重新开始。在困难的时候需要相互鼓励。

离职后我到龙虾开的户外店里面里面住了几天,和他们一起去感受我故乡的魅力。那的确是一个美丽和让人向往的地方。

我面对悬崖选择了停留,在原地等待,坐在河边的岩石上找被水湿透的烟草,听水声四溅,内心胆怯。

我想我还是不喜欢探险,我喜欢所有的东西都在自己的控制中,我不希望我走的下一步是没有信心的。

同花顺是一家还算你可以的公司的,但是我知道在技术上这边可以给我的东西并不多,但是我这段时间突然感觉自己对技术其实并没有那么执着,或者我认为和其他东西相比,技术可以做的东西并不是那么意义重大。而同花顺相对来说是一个可以让自己了解资本市场的公司,而专门了解就是靠自己的能力的。

改变世界的是程序员,但是推动世界改变的是资本家。我一直不希望也不认为自己试一个埋头写代码的人,我希望自己可以了解这个世界资本的运作,再加上自己的一点点技术,我希望可以做出属于自己的产品,而这个产品本身就应该是盈利的。

商业逻辑远比逻辑代码有趣而高深。但是从一个蹩脚程序员到蹩脚资本家的道路漫长而艰难。

现在我抬头就可以看到“探究证券市场的规律和方法”。这就是我来到这里的原因和目的。

道路漫长而艰难,但是我自己都没有想到,一开始我就摔了一跤。

来同花顺上班后第三天,我就发现自己右侧胸口肋骨处有斑点,检查的结果是带状疱疹。一种病毒性的神经感染皮肤病。在周四的时候病情开始不断的加重,周五的晚上我甚至都很难自己坐车回家,这是我有记忆以来最严重的疼痛。

周五晚上因为疼痛而醒来,周六实在是痛的不行,见吃药也完全不见效果,就立马去了浙一挂了专家门诊。然后是连续挂了5天的点滴,每天四个小时,每天都要强烈的神经疼痛。而在这之前我还没有因为生病挂过点滴。我到前天才把这个消息和我妈妈说,我不希望他们太担心我,因为家里面的事情已经足够让他们烦心了的。

周四我没有去打最后一天的点滴,来上班,因为自己毕竟才入职一周,而我现在很需要这份工作。

这两天状态一直都不好,写不出什么代码来。一些最简单的需求都写不好,不过还好,这几天不是很忙,我中秋休息后来还有时间。

我来同花顺的一个原因是我是来这边接触和学习资本市场的,第二个原因是我想知道我fires这种思路是不是可以在一个团队中应用。

其实很多东西都是先关的,一年半以前我写fires就叫做是fires.d.ace.后来是叫做fires,现在我把他叫做是黑桃Ace。我希望可以给这边的后端同事发一张好牌。

希望自己可以在半年里面写出前端类库黑桃Ace和跨终端的类库红心Ace吧。

当在玩扑克牌的时候第一张抓到的是黑桃3的时候不要灰心,要相信下一张会是黑桃A。后面的牌还会越来越好。

不赌,怎么知道运气不好。

这个月是对自己意义重大的一个月,愿否极泰来。

生命频率和世界杯

这段时间有事周期性的失眠,昨天晚上又是基本没有睡。很多东西都在脑子里面晃来晃去,找不到出口,

昨天晚上睡着的时候我感觉我被雷电电了一下,脑子到身体都是整整的一麻,脑子更是闪的厉害。

我当是就想:这大概就是生命的波率吧,因为太疲劳而出现的灵魂的震动。

我以前一直认为人是有频率的,不同的人有不同的频率,管这个叫做气场,我一直认为海贼王里面的霸气也是这样的存在。

人的频率是有高低的,如果两个人之间的频率重合的越多,那么他们的关系自然是越好,自然和万物都是有频率的,环境也是。

我对燕青不值一次说过这个东西,而且我相信这是真理,因为我在西方的,**古代文学和印度瑜伽中都看到了这个东西,频率和共振。大体这应该是这样,至少我是这样认为的。

频率这东西和成长环境有关,而人的一生都在致力于扩大自己的频率,以便和更多的人,更多的事物有重合的区域。

这段时间我的频率不太稳定,来回波动,开始平凡的上下。感觉像是感受到了什么东西一样,是的呀,如果我现在的频率没有波动大概是已经失去了感受的能力吧,在现在的处境下这种波动应该是正常的吧。

灵魂感觉要破体而出,**不断的劝住,身体使劲的挽留。

我一直认为平静的生活可以让自己好受一下,但是昨天感觉电波像是在蓄力后的爆发。

其实我一直都很享受那种自然和非科学的体验,很想再感受一回,但是又怕的要死。

昨天陶说很喜欢90后的不安分,会去尝试,愿意承受。我不敢看他,惭愧的很。

这几天好几次都突然感觉有我似曾相识的感觉,我知道每个人都会有,但是这几天频发,我想我是在我我的路口吧。

我一直认为人生是一场有剧本的电影,剧本已经写好,表演就看自己的了。

今晚是世界杯决赛,定然是看的,不过这应该是一个人的世界杯。

四年前,我回家,一棒子朋友来车站接我,我们一起在酒店看球,那年西班牙拿了冠军,龙虾睡着了。

八年前,我去天天家,看的是黑白电视机,那年意大利拿了冠军,天天睡着了。

本来想今天是回家的,和朋友们一起去看球,再赶回杭州。后来没有这么做。我只是希望我到时候不会睡着。

德国打阿根廷,我希望是德国胜利,虽然梅西是我喜欢的球员。

三十岁已经老了,跑不动了,二十几岁才是世界之巅。

我想我应该努力奔跑了。

{css}css分类和书写书序

CSS分类和书写顺序

css分类

CSS样式的属性义有很多,像手册上就分为“字体”、“文本”、“背景”、“定位”等等17种,
自己把css归纳为3类:

展现属性

控制元素的用什么样的方式来展现。

float
display
postion
top
right
bottom
left
list-style

自身属性

控制元素的一些自身属性,自身属性是元素特有的属性。盒子元素的相关属性都在这个范围内。
从外向内是

margin
border
padding
width(min-width,max-width)
height(min-height , max-height)
background

文本属性(内容属性)

就是文本会以什么样的方式展现。

text-*
font-*
color

展现属性,自身属性是不可悲继承的,在页面展现中这两部分内容是一个元素特有的,而文本属性是可以被继承,因为在一个文档中的子元素和父亲元素的样式展现应该是统一的。

css书写书序

我自己的css书写书序是从外向里写。
先展现属性,然后是自身属性,最后才是展现属性。

display  
list-style  
position  
float  
clear  


/*自身属性*/  
width  
height  
margin  
padding  
border  
background  

/*文本属性*/  
color  
font  
text-decoration  
vertical-align  
white-space  
ohter text  
content

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.