├── img
├── tip-box.jpg
├── element-mask.jpg
├── element-size.png
├── sort-compare.png
└── display-adjust.png
├── javascript思维导图.md
└── README.md
/img/tip-box.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/awesome-interview/FE-interview/HEAD/img/tip-box.jpg
--------------------------------------------------------------------------------
/img/element-mask.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/awesome-interview/FE-interview/HEAD/img/element-mask.jpg
--------------------------------------------------------------------------------
/img/element-size.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/awesome-interview/FE-interview/HEAD/img/element-size.png
--------------------------------------------------------------------------------
/img/sort-compare.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/awesome-interview/FE-interview/HEAD/img/sort-compare.png
--------------------------------------------------------------------------------
/img/display-adjust.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/awesome-interview/FE-interview/HEAD/img/display-adjust.png
--------------------------------------------------------------------------------
/javascript思维导图.md:
--------------------------------------------------------------------------------
1 | # JS思维导图汇总
2 | -----------------------------
3 |
4 | ## 1.JavaScript变量
5 |
6 | 
7 |
8 | ## 2.JavaScript运算符
9 |
10 | 
11 |
12 | ## 3.JavaScript数组
13 |
14 | 
15 |
16 | ## 4.JavaScript流程语句
17 |
18 | 
19 |
20 | ## 5.JavaScript字符串函数
21 |
22 | 
23 |
24 | ## 6.JavaScript函数基础
25 |
26 | 
27 |
28 | ## 7.JavaScript基础DOM操作
29 |
30 | 
31 | 
32 |
33 | ## 8.JavaScript基础BOM操作
34 |
35 | 
36 | ## 9.JavaScript正则表达式
37 |
38 | 
39 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | 转载请注明出处: [https://github.com/qiu-deqing/FE-interview](https://github.com/qiu-deqing/FE-interview)
2 |
3 |
4 |
5 | **Table of Contents** *generated with [DocToc](http://doctoc.herokuapp.com/)*
6 |
7 | - [FE-interview](#fe-interview)
8 | - [$HTML， HTTP，web综合问题](#$html，-http，web综合问题)
9 | - [常见排序算法的时间复杂度,空间复杂度](#常见排序算法的时间复杂度空间复杂度)
10 | - [前端需要注意哪些SEO](#前端需要注意哪些seo)
11 | - [web开发中会话跟踪的方法有哪些](#web开发中会话跟踪的方法有哪些)
12 | - [`![]()
`的`title`和`alt`有什么区别](#img的title和alt有什么区别)
13 | - [doctype是什么,举例常见doctype及特点](#doctype是什么举例常见doctype及特点)
14 | - [HTML全局属性(global attribute)有哪些](#html全局属性global-attribute有哪些)
15 | - [什么是web语义化,有什么好处](#什么是web语义化有什么好处)
16 | - [HTTP method](#http-method)
17 | - [从浏览器地址栏输入url到显示页面的步骤(以HTTP为例)](#从浏览器地址栏输入url到显示页面的步骤以http为例)
18 | - [HTTP request报文结构是怎样的](#http-request报文结构是怎样的)
19 | - [HTTP response报文结构是怎样的](#http-response报文结构是怎样的)
20 | - [如何进行网站性能优化](#如何进行网站性能优化)
21 | - [什么是渐进增强](#什么是渐进增强)
22 | - [HTTP状态码及其含义](#http状态码及其含义)
23 | - [$CSS部分](#$css部分)
24 | - [CSS选择器有哪些](#css选择器有哪些)
25 | - [css sprite是什么,有什么优缺点](#css-sprite是什么有什么优缺点)
26 | - [`display: none;`与`visibility: hidden;`的区别](#display-none与visibility-hidden的区别)
27 | - [css hack原理及常用hack](#css-hack原理及常用hack)
28 | - [specified value,computed value,used value计算方法](#specified-valuecomputed-valueused-value计算方法)
29 | - [`link`与`@import`的区别](#link与@import的区别)
30 | - [``display: block;``和``display: inline;``的区别](#display-block和display-inline的区别)
31 | - [PNG,GIF,JPG的区别及如何选](#pnggifjpg的区别及如何选)
32 | - [CSS有哪些继承属性](#css有哪些继承属性)
33 | - [IE6浏览器有哪些常见的bug,缺陷或者与标准不一致的地方,如何解决](#ie6浏览器有哪些常见的bug缺陷或者与标准不一致的地方如何解决)
34 | - [容器包含若干浮动元素时如何清理(包含)浮动](#容器包含若干浮动元素时如何清理包含浮动)
35 | - [什么是FOUC?如何避免](#什么是fouc如何避免)
36 | - [如何创建块级格式化上下文(block formatting context),BFC有什么用](#如何创建块级格式化上下文block-formatting-contextbfc有什么用)
37 | - [display,float,position的关系](#displayfloatposition的关系)
38 | - [外边距折叠(collapsing margins)](#外边距折叠collapsing-margins)
39 | - [如何确定一个元素的包含块(containing block)](#如何确定一个元素的包含块containing-block)
40 | - [stacking context,布局规则](#stacking-context布局规则)
41 | - [如何水平居中一个元素](#如何水平居中一个元素)
42 | - [如何竖直居中一个元素](#如何竖直居中一个元素)
43 | - [$javascript概念部分](#$javascript概念部分)
44 | - [DOM元素e的e.getAttribute(propName)和e.propName有什么区别和联系](#dom元素e的egetattributepropname和epropname有什么区别和联系)
45 | - [offsetWidth/offsetHeight,clientWidth/clientHeight与scrollWidth/scrollHeight的区别](#offsetwidthoffsetheightclientwidthclientheight与scrollwidthscrollheight的区别)
46 | - [XMLHttpRequest通用属性和方法](#xmlhttprequest通用属性和方法)
47 | - [focus/blur与focusin/focusout的区别与联系](#focusblur与focusinfocusout的区别与联系)
48 | - [mouseover/mouseout与mouseenter/mouseleave的区别与联系](#mouseovermouseout与mouseentermouseleave的区别与联系)
49 | - [sessionStorage,localStorage,cookie区别](#sessionstoragelocalstoragecookie区别)
50 | - [javascript跨域通信](#javascript跨域通信)
51 | - [javascript有哪几种数据类型](#javascript有哪几种数据类型)
52 | - [什么闭包,闭包有什么用](#什么闭包闭包有什么用)
53 | - [javascript有哪几种方法定义函数](#javascript有哪几种方法定义函数)
54 | - [应用程序存储和离线web应用](#应用程序存储和离线web应用)
55 | - [客户端存储localStorage和sessionStorage](#客户端存储localstorage和sessionstorage)
56 | - [cookie及其操作](#cookie及其操作)
57 | - [javascript有哪些方法定义对象](#javascript有哪些方法定义对象)
58 | - [===运算符判断相等的流程是怎样的](#===运算符判断相等的流程是怎样的)
59 | - [==运算符判断相等的流程是怎样的](#==运算符判断相等的流程是怎样的)
60 | - [对象到字符串的转换步骤](#对象到字符串的转换步骤)
61 | - [对象到数字的转换步骤](#对象到数字的转换步骤)
62 | - [<,>,<=,>=的比较规则](#==的比较规则)
63 | - [+运算符工作流程](#运算符工作流程)
64 | - [函数内部arguments变量有哪些特性,有哪些属性,如何将它转换为数组](#函数内部arguments变量有哪些特性有哪些属性如何将它转换为数组)
65 | - [DOM事件模型是如何的,编写一个EventUtil工具类实现事件管理兼容](#dom事件模型是如何的编写一个eventutil工具类实现事件管理兼容)
66 | - [评价一下三种方法实现继承的优缺点,并改进](#评价一下三种方法实现继承的优缺点并改进)
67 | - [$javascript编程部分](#$javascript编程部分)
68 | - [请用原生js实现一个函数,给页面制定的任意一个元素添加一个透明遮罩(透明度可变,默认0.2),使这个区域点击无效,要求兼容IE8+及各主流浏览器,遮罩层效果如下图所示:](#请用原生js实现一个函数给页面制定的任意一个元素添加一个透明遮罩透明度可变默认02使这个区域点击无效要求兼容ie8及各主流浏览器遮罩层效果如下图所示)
69 | - [请用代码写出(今天是星期x)其中x表示当天是星期几,如果当天是星期一,输出应该是"今天是星期一"](#请用代码写出今天是星期x其中x表示当天是星期几如果当天是星期一输出应该是今天是星期一)
70 | - [下面这段代码想要循环延时输出结果0 1 2 3 4,请问输出结果是否正确,如果不正确,请说明为什么,并修改循环内的代码使其输出正确结果](#下面这段代码想要循环延时输出结果0-1-2-3-4请问输出结果是否正确如果不正确请说明为什么并修改循环内的代码使其输出正确结果)
71 | - [现有一个Page类,其原型对象上有许多以post开头的方法(如postMsg);另有一拦截函数chekc,只返回ture或false.请设计一个函数,该函数应批量改造原Page的postXXX方法,在保留其原有功能的同时,为每个postXXX方法增加拦截验证功能,当chekc返回true时继续执行原postXXX方法,返回false时不再执行原postXXX方法](#现有一个page类其原型对象上有许多以post开头的方法如postmsg另有一拦截函数chekc只返回ture或false请设计一个函数该函数应批量改造原page的postxxx方法在保留其原有功能的同时为每个postxxx方法增加拦截验证功能当chekc返回true时继续执行原postxxx方法返回false时不再执行原postxxx方法)
72 | - [完成下面的tool-tip](#完成下面的tool-tip)
73 | - [编写javascript深度克隆函数deepClone](#编写javascript深度克隆函数deepclone)
74 | - [补充代码,鼠标单击Button1后将Button1移动到Button2的后面](#补充代码鼠标单击button1后将button1移动到button2的后面)
75 | - [网页中实现一个计算当年还剩多少时间的倒数计时程序,要求网页上实时动态显示"××年还剩××天××时××分××秒"](#网页中实现一个计算当年还剩多少时间的倒数计时程序要求网页上实时动态显示××年还剩××天××时××分××秒)
76 | - [完成一个函数,接受数组作为参数,数组元素为整数或者数组,数组元素包含整数或数组,函数返回扁平化后的数组](#完成一个函数接受数组作为参数数组元素为整数或者数组数组元素包含整数或数组函数返回扁平化后的数组)
77 | - [如何判断一个对象是否为数组](#如何判断一个对象是否为数组)
78 | - [请评价以下事件监听器代码并给出改进意见](#请评价以下事件监听器代码并给出改进意见)
79 | - [如何判断一个对象是否为函数](#如何判断一个对象是否为函数)
80 | - [编写一个函数接受url中query string为参数,返回解析后的Object,query string使用application/x-www-form-urlencoded编码](#编写一个函数接受url中query-string为参数返回解析后的objectquery-string使用applicationx-www-form-urlencoded编码)
81 | - [解析一个完整的url,返回Object包含域与window.location相同](#解析一个完整的url返回object包含域与windowlocation相同)
82 | - [完成函数getViewportSize返回指定窗口的视口尺寸](#完成函数getviewportsize返回指定窗口的视口尺寸)
83 | - [完成函数getScrollOffset返回窗口滚动条偏移量](#完成函数getscrolloffset返回窗口滚动条偏移量)
84 | - [现有一个字符串richText,是一段富文本,需要显示在页面上.有个要求,需要给其中只包含一个img元素的p标签增加一个叫pic的class.请编写代码实现.可以使用jQuery或KISSY.](#现有一个字符串richtext是一段富文本需要显示在页面上有个要求需要给其中只包含一个img元素的p标签增加一个叫pic的class请编写代码实现可以使用jquery或kissy)
85 | - [请实现一个Event类,继承自此类的对象都会拥有两个方法on,off,once和trigger](#请实现一个event类继承自此类的对象都会拥有两个方法onoffonce和trigger)
86 | - [编写一个函数将列表子元素顺序反转](#编写一个函数将列表子元素顺序反转)
87 | - [以下函数的作用是?空白区域应该填写什么](#以下函数的作用是空白区域应该填写什么)
88 | - [编写一个函数实现form的序列化(即将一个表单中的键值序列化为可提交的字符串)](#编写一个函数实现form的序列化即将一个表单中的键值序列化为可提交的字符串)
89 | - [使用原生javascript给下面列表中的li节点绑定点击事件,点击时创建一个Object对象,兼容IE和标准浏览器](#使用原生javascript给下面列表中的li节点绑定点击事件点击时创建一个object对象兼容ie和标准浏览器)
90 | - [有一个大数组,var a = ['1', '2', '3', ...];a的长度是100,内容填充随机整数的字符串.请先构造此数组a,然后设计一个算法将其内容去重](#有一个大数组var-a-=-1-2-3-a的长度是100内容填充随机整数的字符串请先构造此数组a然后设计一个算法将其内容去重)
91 |
92 |
93 |
94 | # FE-interview
95 |
96 | 个人收集的前端知识点、面试题和答案，参考答案仅代表个人观点，方便复习，目录如下，通过文档内搜索目录可快速定位章节
97 |
98 | ## $HTML， HTTP，web综合问题
99 |
100 | ### 常见排序算法的时间复杂度,空间复杂度
101 |
102 | 
103 |
104 | ### 前端需要注意哪些SEO
105 |
106 | 1. 合理的title、description、keywords：搜索对着三项的权重逐个减小，title值强调重点即可，重要关键词出现不要超过2次，而且要靠前，不同页面title要有所不同；description把页面内容高度概括，长度合适，不可过分堆砌关键词，不同页面description有所不同；keywords列举出重要关键词即可
107 | 2. 语义化的HTML代码，符合W3C规范：语义化代码让搜索引擎容易理解网页
108 | 3. 重要内容HTML代码放在最前：搜索引擎抓取HTML顺序是从上到下，有的搜索引擎对抓取长度有限制，保证重要内容一定会被抓取
109 | 4. 重要内容不要用js输出：爬虫不会执行js获取内容
110 | 5. 少用iframe：搜索引擎不会抓取iframe中的内容
111 | 6. 非装饰性图片必须加alt
112 | 7. 提高网站速度：网站速度是搜索引擎排序的一个重要指标
113 |
114 | ### web开发中会话跟踪的方法有哪些
115 |
116 | 1. cookie
117 | 2. session
118 | 3. url重写
119 | 4. 隐藏input
120 | 5. ip地址
121 |
122 | ### `![]()
`的`title`和`alt`有什么区别
123 |
124 | 1. `title`是[global attributes](http://www.w3.org/TR/html-markup/global-attributes.html#common.attrs.core)之一，用于为元素提供附加的advisory information。通常当鼠标滑动到元素上的时候显示。
125 | 2. `alt`是`![]()
`的特有属性，是图片内容的等价描述，用于图片无法加载时显示、读屏器阅读图片。可提图片高可访问性，除了纯装饰图片外都必须设置有意义的值，搜索引擎会重点分析。
126 |
127 | ### doctype是什么,举例常见doctype及特点
128 |
129 | 1. ``声明必须处于HTML文档的头部，在``标签之前，HTML5中不区分大小写
130 | 2. ``声明不是一个HTML标签，是一个用于告诉浏览器当前HTMl版本的指令
131 | 3. 现代浏览器的html布局引擎通过检查doctype决定使用兼容模式还是标准模式对文档进行渲染，一些浏览器有一个接近标准模型。
132 | 3. 在HTML4.01中``声明指向一个DTD，由于HTML4.01基于SGML，所以DTD指定了标记规则以保证浏览器正确渲染内容
133 | 4. HTML5不基于SGML，所以不用指定DTD
134 |
135 | 常见dotype：
136 |
137 | 1. **HTML4.01 strict**：不允许使用表现性、废弃元素（如font）以及frameset。声明：``
138 | 2. **HTML4.01 Transitional**:允许使用表现性、废弃元素（如font），不允许使用frameset。声明：``
139 | 3. **HTML4.01 Frameset**:允许表现性元素，废气元素以及frameset。声明：``
140 | 4. **XHTML1.0 Strict**:不使用允许表现性、废弃元素以及frameset。文档必须是结构良好的XML文档。声明：````
141 | 5. **XHTML1.0 Transitional**:允许使用表现性、废弃元素，不允许frameset，文档必须是结构良好的XMl文档。声明： ````
142 | 6. **XHTML 1.0 Frameset**:允许使用表现性、废弃元素以及frameset，文档必须是结构良好的XML文档。声明：````
143 | 7. **HTML 5**: ``
144 |
145 | ### HTML全局属性(global attribute)有哪些
146 |
147 | 参考资料：[MDN: html global attribute](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes)或者[W3C HTML global-attributes](http://www.w3.org/TR/html-markup/global-attributes.html#common.attrs.core)
148 |
149 | - `accesskey`:设置快捷键，提供快速访问元素如aaa在windows下的firefox中按``alt + shift + a``可激活元素
150 | - `class`:为元素设置类标识，多个类名用空格分开，CSS和javascript可通过class属性获取元素
151 | - `contenteditable`: 指定元素内容是否可编辑
152 | - `contextmenu`: 自定义鼠标右键弹出菜单内容
153 | - `data-*`: 为元素增加自定义属性
154 | - `dir`: 设置元素文本方向
155 | - `draggable`: 设置元素是否可拖拽
156 | - `dropzone`: 设置元素拖放类型： copy, move, link
157 | - `hidden`: 表示一个元素是否与文档。样式上会导致元素不显示，但是不能用这个属性实现样式效果
158 | - `id`: 元素id，文档内唯一
159 | - `lang`: 元素内容的的语言
160 | - `spellcheck`: 是否启动拼写和语法检查
161 | - `style`: 行内css样式
162 | - `tabindex`: 设置元素可以获得焦点，通过tab可以导航
163 | - `title`: 元素相关的建议信息
164 | - `translate`: 元素和子孙节点内容是否需要本地化
165 |
166 | ### 什么是web语义化,有什么好处
167 |
168 | web语义化是指通过HTML标记表示页面包含的信息，包含了HTML标签的语义化和css命名的语义化。
169 | HTML标签的语义化是指：通过使用包含语义的标签（如h1-h6）恰当地表示文档结构
170 | css命名的语义化是指：为html标签添加有意义的class，id补充未表达的语义，如[Microformat](http://en.wikipedia.org/wiki/Microformats)通过添加符合规则的class描述信息
171 | 为什么需要语义化：
172 |
173 | - 去掉样式后页面呈现清晰的结构
174 | - 盲人使用读屏器更好地阅读
175 | - 搜索引擎更好地理解页面，有利于收录
176 | - 便团队项目的可持续运作及维护
177 |
178 | ### HTTP method
179 |
180 | 1. 一台服务器要与HTTP1.1兼容，只要为资源实现**GET**和**HEAD**方法即可
181 | 2. **GET**是最常用的方法，通常用于**请求服务器发送某个资源**。
182 | 3. **HEAD**与GET类似，但**服务器在响应中值返回首部，不返回实体的主体部分**
183 | 4. **PUT**让服务器**用请求的主体部分来创建一个由所请求的URL命名的新文档，或者，如果那个URL已经存在的话，就用干这个主体替代它**
184 | 5. **POST**起初是用来向服务器输入数据的。实际上，通常会用它来支持HTML的表单。表单中填好的数据通常会被送给服务器，然后由服务器将其发送到要去的地方。
185 | 6. **TRACE**会在目的服务器端发起一个环回诊断，最后一站的服务器会弹回一个TRACE响应并在响应主体中携带它收到的原始请求报文。TRACE方法主要用于诊断，用于验证请求是否如愿穿过了请求/响应链。
186 | 7. **OPTIONS**方法请求web服务器告知其支持的各种功能。可以查询服务器支持哪些方法或者对某些特殊资源支持哪些方法。
187 | 8. **DELETE**请求服务器删除请求URL指定的资源
188 |
189 | ### 从浏览器地址栏输入url到显示页面的步骤(以HTTP为例)
190 |
191 | 1. 在浏览器地址栏输入URL
192 | 2. 浏览器查看**缓存**，如果请求资源在缓存中并且新鲜，跳转到转码步骤
193 | 1. 如果资源未缓存，发起新请求
194 | 2. 如果已缓存，检验是否足够新鲜，足够新鲜直接提供给客户端，否则与服务器进行验证。
195 | 3. 检验新鲜通常有两个HTTP头进行控制`Expires`和`Cache-Control`：
196 | - HTTP1.0提供Expires，值为一个绝对时间表示缓存新鲜日期
197 | - HTTP1.1增加了Cache-Control: max-age=,值为以秒为单位的最大新鲜时间
198 | 3. 浏览器**解析URL**获取协议，主机，端口，path
199 | 4. 浏览器**组装一个HTTP（GET）请求报文**
200 | 5. 浏览器**获取主机ip地址**，过程如下：
201 | 1. 浏览器缓存
202 | 2. 本机缓存
203 | 3. hosts文件
204 | 4. 路由器缓存
205 | 5. ISP DNS缓存
206 | 6. DNS递归查询（可能存在负载均衡导致每次IP不一样）
207 | 6. **打开一个socket与目标IP地址，端口建立TCP链接**，三次握手如下：
208 | 1. 客户端发送一个TCP的**SYN=1，Seq=X**的包到服务器端口
209 | 2. 服务器发回**SYN=1， ACK=X+1， Seq=Y**的响应包
210 | 3. 客户端发送**ACK=Y+1， Seq=Z**
211 | 7. TCP链接建立后**发送HTTP请求**
212 | 8. 服务器接受请求并解析，将请求转发到服务程序，如虚拟主机使用HTTP Host头部判断请求的服务程序
213 | 9. 服务器检查**HTTP请求头是否包含缓存验证信息**如果验证缓存新鲜，返回**304**等对应状态码
214 | 10. 处理程序读取完整请求并准备HTTP响应，可能需要查询数据库等操作
215 | 11. 服务器将**响应报文通过TCP连接发送回浏览器**
216 | 12. 浏览器接收HTTP响应，然后根据情况选择**关闭TCP连接或者保留重用，关闭TCP连接的四次握手如下**：
217 | 1. 主动方发送**Fin=1， Ack=Z， Seq= X**报文
218 | 2. 被动方发送**ACK=X+1， Seq=Z**报文
219 | 3. 被动方发送**Fin=1， ACK=X， Seq=Y**报文
220 | 4. 主动方发送**ACK=Y， Seq=X**报文
221 | 13. 浏览器检查响应状态吗：是否为1XX，3XX， 4XX， 5XX，这些情况处理与2XX不同
222 | 14. 如果资源可缓存，**进行缓存**
223 | 15. 对响应进行**解码**（例如gzip压缩）
224 | 16. 根据资源类型决定如何处理（假设资源为HTML文档）
225 | 17. **解析HTML文档，构件DOM树，下载资源，构造CSSOM树，执行js脚本**，这些操作没有严格的先后顺序，以下分别解释
226 | 18. **构建DOM树**：
227 | 1. **Tokenizing**：根据HTML规范将字符流解析为标记
228 | 2. **Lexing**：词法分析将标记转换为对象并定义属性和规则
229 | 3. **DOM construction**：根据HTML标记关系将对象组成DOM树
230 | 19. 解析过程中遇到图片、样式表、js文件，**启动下载**
231 | 20. 构建**CSSOM树**：
232 | 1. **Tokenizing**：字符流转换为标记流
233 | 2. **Node**：根据标记创建节点
234 | 3. **CSSOM**：节点创建CSSOM树
235 | 21. **[根据DOM树和CSSOM树构建渲染树](https://developers.google.com/web/fundamentals/performance/critical-rendering-path/render-tree-construction)**:
236 | 1. 从DOM树的根节点遍历所有**可见节点**，不可见节点包括：1）`script`,`meta`这样本身不可见的标签。2)被css隐藏的节点，如`display: none`
237 | 2. 对每一个可见节点，找到恰当的CSSOM规则并应用
238 | 3. 发布可视节点的内容和计算样式
239 | 22. **js解析如下**：
240 | 1. 浏览器创建Document对象并解析HTML，将解析到的元素和文本节点添加到文档中，此时**document.readystate为loading**
241 | 2. HTML解析器遇到**没有async和defer的script时**，将他们添加到文档中，然后执行行内或外部脚本。这些脚本会同步执行，并且在脚本下载和执行时解析器会暂停。这样就可以用document.write()把文本插入到输入流中。**同步脚本经常简单定义函数和注册事件处理程序，他们可以遍历和操作script和他们之前的文档内容**
242 | 3. 当解析器遇到设置了**async**属性的script时，开始下载脚本并继续解析文档。脚本会在它**下载完成后尽快执行**，但是**解析器不会停下来等它下载**。异步脚本**禁止使用document.write()**，它们可以访问自己script和之前的文档元素
243 | 4. 当文档完成解析，document.readState变成interactive
244 | 5. 所有**defer**脚本会**按照在文档出现的顺序执行**，延迟脚本**能访问完整文档树**，禁止使用document.write()
245 | 6. 浏览器**在Document对象上触发DOMContentLoaded事件**
246 | 7. 此时文档完全解析完成，浏览器可能还在等待如图片等内容加载，等这些**内容完成载入并且所有异步脚本完成载入和执行**，document.readState变为complete,window触发load事件
247 | 23. **显示页面**（HTML解析过程中会逐步显示页面）
248 |
249 | ### HTTP request报文结构是怎样的
250 | [rfc2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html)中进行了定义：
251 |
252 | 1. 首行是**Request-Line**包括：**请求方法**，**请求URI**，**协议版本**，**CRLF**
253 | 2. 首行之后是若干行**请求头**，包括**general-header**，**request-header**或者**entity-header**，每个一行以CRLF结束
254 | 3. 请求头和消息实体之间有一个**CRLF分隔**
255 | 4. 根据实际请求需要可能包含一个**消息实体**
256 | 一个请求报文例子如下：
257 |
258 | ```
259 | GET /Protocols/rfc2616/rfc2616-sec5.html HTTP/1.1
260 | Host: www.w3.org
261 | Connection: keep-alive
262 | Cache-Control: max-age=0
263 | Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
264 | User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.153 Safari/537.36
265 | Referer: https://www.google.com.hk/
266 | Accept-Encoding: gzip,deflate,sdch
267 | Accept-Language: zh-CN,zh;q=0.8,en;q=0.6
268 | Cookie: authorstyle=yes
269 | If-None-Match: "2cc8-3e3073913b100"
270 | If-Modified-Since: Wed, 01 Sep 2004 13:24:52 GMT
271 |
272 | name=qiu&age=25
273 | ```
274 |
275 | ### HTTP response报文结构是怎样的
276 |
277 | [rfc2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec6.html)中进行了定义：
278 |
279 | 1. 首行是状态行包括：**HTTP版本，状态码，状态描述**，后面跟一个CRLF
280 | 2. 首行之后是**若干行响应头**，包括：**通用头部，响应头部，实体头部**
281 | 3. 响应头部和响应实体之间用**一个CRLF空行**分隔
282 | 4. 最后是一个可能的**消息实体**
283 | 响应报文例子如下：
284 |
285 | ```
286 | HTTP/1.1 200 OK
287 | Date: Tue, 08 Jul 2014 05:28:43 GMT
288 | Server: Apache/2
289 | Last-Modified: Wed, 01 Sep 2004 13:24:52 GMT
290 | ETag: "40d7-3e3073913b100"
291 | Accept-Ranges: bytes
292 | Content-Length: 16599
293 | Cache-Control: max-age=21600
294 | Expires: Tue, 08 Jul 2014 11:28:43 GMT
295 | P3P: policyref="http://www.w3.org/2001/05/P3P/p3p.xml"
296 | Content-Type: text/html; charset=iso-8859-1
297 |
298 | {"name": "qiu", "age": 25}
299 | ```
300 |
301 | ### 如何进行网站性能优化
302 |
303 | [雅虎Best Practices for Speeding Up Your Web Site](https://developer.yahoo.com/performance/rules.html)：
304 |
305 | - content方面
306 | 1. 减少HTTP请求：合并文件、CSS精灵、inline Image
307 | 2. 减少DNS查询：DNS查询完成之前浏览器不能从这个主机下载任何任何文件。方法：DNS缓存、将资源分布到恰当数量的主机名，平衡并行下载和DNS查询
308 | 3. 避免重定向：多余的中间访问
309 | 4. 使Ajax可缓存
310 | 5. 非必须组件延迟加载
311 | 6. 未来所需组件预加载
312 | 7. 减少DOM元素数量
313 | 8. 将资源放到不同的域下：浏览器同时从一个域下载资源的数目有限，增加域可以提高并行下载量
314 | 9. 减少iframe数量
315 | 10. 不要404
316 |
317 | - Server方面
318 | 1. 使用CDN
319 | 2. 添加Expires或者Cache-Control响应头
320 | 3. 对组件使用Gzip压缩
321 | 4. 配置ETag
322 | 5. Flush Buffer Early
323 | 6. Ajax使用GET进行请求
324 | 7. 避免空src的img标签
325 | - Cookie方面
326 | 1. 减小cookie大小
327 | 2. 引入资源的域名不要包含cookie
328 | - css方面
329 | 1. 将样式表放到页面顶部
330 | 2. 不使用CSS表达式
331 | 3. 使用不使用@import
332 | 4. 不使用IE的Filter
333 | - Javascript方面
334 | 1. 将脚本放到页面底部
335 | 2. 将javascript和css从外部引入
336 | 3. 压缩javascript和css
337 | 4. 删除不需要的脚本
338 | 5. 减少DOM访问
339 | 6. 合理设计事件监听器
340 | - 图片方面
341 | 1. 优化图片：根据实际颜色需要选择色深、压缩
342 | 2. 优化css精灵
343 | 3. 不要在HTML中拉伸图片
344 | 4. 保证favicon.ico小并且可缓存
345 | - 移动方面
346 | 1. 保证组件小于25k
347 | 2. Pack Components into a Multipart Document
348 |
349 |
350 | ### 什么是渐进增强
351 |
352 | 渐进增强是指在web设计时强调可访问性、语义化HTML标签、外部样式表和脚本。保证所有人都能访问页面的基本内容和功能同时为高级浏览器和高带宽用户提供更好的用户体验。核心原则如下:
353 |
354 | - 所有浏览器都必须能访问基本内容
355 | - 所有浏览器都必须能使用基本功能
356 | - 所有内容都包含在语义化标签中
357 | - 通过外部CSS提供增强的布局
358 | - 通过非侵入式、外部javascript提供增强功能
359 | - end-user web browser preferences are respected
360 |
361 | ### HTTP状态码及其含义
362 |
363 | 参考[RFC 2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html)
364 |
365 | - 1XX：信息状态码
366 | - **100 Continue**：客户端应当继续发送请求。这个临时相应是用来通知客户端它的部分请求已经被服务器接收，且仍未被拒绝。客户端应当继续发送请求的剩余部分，或者如果请求已经完成，忽略这个响应。服务器必须在请求万仇向客户端发送一个最终响应
367 | - **101 Switching Protocols**：服务器已经理解力客户端的请求，并将通过Upgrade消息头通知客户端采用不同的协议来完成这个请求。在发送完这个响应最后的空行后，服务器将会切换到Upgrade消息头中定义的那些协议。
368 | - 2XX：成功状态码
369 | - **200 OK**：请求成功，请求所希望的响应头或数据体将随此响应返回
370 | - **201 Created**：
371 | - **202 Accepted**：
372 | - **203 Non-Authoritative Information**：
373 | - **204 No Content**：
374 | - **205 Reset Content**：
375 | - **206 Partial Content**：
376 | - 3XX：重定向
377 | - **300 Multiple Choices**：
378 | - **301 Moved Permanently**：
379 | - **302 Found**：
380 | - **303 See Other**：
381 | - **304 Not Modified**：
382 | - **305 Use Proxy**：
383 | - **306 （unused）**：
384 | - **307 Temporary Redirect**：
385 | - 4XX：客户端错误
386 | - **400 Bad Request**:
387 | - **401 Unauthorized**:
388 | - **402 Payment Required**:
389 | - **403 Forbidden**:
390 | - **404 Not Found**:
391 | - **405 Method Not Allowed**:
392 | - **406 Not Acceptable**:
393 | - **407 Proxy Authentication Required**:
394 | - **408 Request Timeout**:
395 | - **409 Conflict**:
396 | - **410 Gone**:
397 | - **411 Length Required**:
398 | - **412 Precondition Failed**:
399 | - **413 Request Entity Too Large**:
400 | - **414 Request-URI Too Long**:
401 | - **415 Unsupported Media Type**:
402 | - **416 Requested Range Not Satisfiable**:
403 | - **417 Expectation Failed**:
404 | - 5XX: 服务器错误
405 | - **500 Internal Server Error**:
406 | - **501 Not Implemented**:
407 | - **502 Bad Gateway**:
408 | - **503 Service Unavailable**:
409 | - **504 Gateway Timeout**:
410 | - **505 HTTP Version Not Supported**:
411 |
412 | ## $CSS部分
413 |
414 | ### CSS选择器有哪些
415 |
416 | 1. ***通用选择器**：选择所有元素，**不参与计算优先级**，兼容性IE6+
417 | 2. **#X id选择器**：选择id值为X的元素，兼容性：IE6+
418 | 3. **.X 类选择器**： 选择class包含X的元素，兼容性：IE6+
419 | 4. **X Y后代选择器**： 选择满足X选择器的后代节点中满足Y选择器的元素，兼容性：IE6+
420 | 5. **X 元素选择器**： 选择标所有签为X的元素，兼容性：IE6+
421 | 6. **:link，：visited，：focus，：hover，：active链接状态**： 选择特定状态的链接元素，顺序LoVe HAte，兼容性: IE4+
422 | 7. **X + Y直接兄弟选择器**：在**X之后第一个兄弟节点**中选择满足Y选择器的元素，兼容性： IE7+
423 | 8. **X > Y子选择器**： 选择X的子元素中满足Y选择器的元素，兼容性： IE7+
424 | 9. **X ~ Y兄弟**： 选择**X之后所有兄弟节点**中满足Y选择器的元素，兼容性： IE7+
425 | 10. **[attr]**：选择所有设置了attr属性的元素，兼容性IE7+
426 | 11. **[attr=value]**：选择属性值刚好为value的元素
427 | 12. **[attr~=value]**：选择属性值为空白符分隔，其中一个的值刚好是value的元素
428 | 13. **[attr|=value]**：选择属性值刚好为value或者value-开头的元素
429 | 14. **[attr^=value]**：选择属性值以value开头的元素
430 | 15. **[attr$=value]**：选择属性值以value结尾的元素
431 | 16. **[attr*=value]**：选择属性值中包含value的元素
432 | 17. **[:checked]**：选择单选框，复选框，下拉框中选中状态下的元素，兼容性：IE9+
433 | 18. **X:after, X::after**：after伪元素，选择元素虚拟子元素（元素的最后一个子元素），CSS3中::表示伪元素。兼容性:after为IE8+，::after为IE9+
434 | 18. **:hover**：鼠标移入状态的元素，兼容性a标签IE4+， 所有元素IE7+
435 | 19. **:not(selector)**：选择不符合selector的元素。**不参与计算优先级**，兼容性：IE9+
436 | 20. **::first-letter**：伪元素，选择块元素第一行的第一个字母，兼容性IE5.5+
437 | 21. **::first-line**：伪元素，选择块元素的第一行，兼容性IE5.5+
438 | 22. **:nth-child(an + b)**：伪类，选择前面有an + b - 1个兄弟节点的元素，其中n
439 | >= 0， 兼容性IE9+
440 | 23. **:nth-last-child(an + b)**：伪类，选择后面有an + b - 1个兄弟节点的元素
441 | 其中n >= 0，兼容性IE9+
442 | 24. **X:nth-of-type(an+b)**：伪类，X为选择器，**解析得到元素标签**，选择**前面**有an + b - 1个**相同标签**兄弟节点的元素。兼容性IE9+
443 | 25. **X:nth-last-of-type(an+b)**：伪类，X为选择器，解析得到元素标签，选择**后面**有an+b-1个相同**标签**兄弟节点的元素。兼容性IE9+
444 | 26. **X:first-child**：伪类，选择满足X选择器的元素，且这个元素是其父节点的第一个子元素。兼容性IE7+
445 | 27. **X:last-child**：伪类，选择满足X选择器的元素，且这个元素是其父节点的最后一个子元素。兼容性IE9+
446 | 28. **X:only-child**：伪类，选择满足X选择器的元素，且这个元素是其父元素的唯一子元素。兼容性IE9+
447 | 29. **X:only-of-type**：伪类，选择X选择的元素，**解析得到元素标签**，如果该元素没有相同类型的兄弟节点时选中它。兼容性IE9+
448 | 30. **X:first-of-type**：伪类，选择X选择的元素，**解析得到元素标签**，如果该元素
449 | 是此此类型元素的第一个兄弟。选中它。兼容性IE9+
450 |
451 |
452 | ### css sprite是什么,有什么优缺点
453 |
454 | 概念：将多个小图片拼接到一个图片中。通过background-position和元素尺寸调节需要显示的背景图案。
455 |
456 | 优点：
457 |
458 | 1. 减少HTTP请求数，极大地提高页面加载速度
459 | 2. 增加图片信息重复度，提高压缩比，减少图片大小
460 | 3. 更换风格方便，只需在一张或几张图片上修改颜色或样式即可实现
461 |
462 | 缺点：
463 |
464 | 1. 图片合并麻烦
465 | 2. 维护麻烦，修改一个图片可能需要从新布局整个图片，样式
466 |
467 |
468 | ### `display: none;`与`visibility: hidden;`的区别
469 | 联系：它们都能让元素不可见
470 |
471 | 区别：
472 |
473 | 1. display:none;会让元素完全从渲染树中消失，渲染的时候不占据任何空间；visibility: hidden;不会让元素从渲染树消失，渲染师元素继续占据空间，只是内容不可见
474 | 2. display: none;是非继承属性，子孙节点消失由于元素从渲染树消失造成，通过修改子孙节点属性无法显示；visibility: hidden;是继承属性，子孙节点消失由于继承了hidden，通过设置visibility: visible;可以让子孙节点显式
475 | 3. 修改常规流中元素的display通常会造成文档重排。修改visibility属性只会造成本元素的重绘。
476 | 4. 读屏器不会读取display: none;元素内容；会读取visibility: hidden;元素内容
477 |
478 | ### css hack原理及常用hack
479 |
480 | 原理：利用**不同浏览器对CSS的支持和解析结果不一样**编写针对特定浏览器样式。常见的hack有1）属性hack。2）选择器hack。3）IE条件注释
481 |
482 | - IE条件注释：适用于[IE5, IE9]常见格式如下
483 |
484 | ```
485 |
488 | ```
489 |
490 | - 选择器hack：不同浏览器对选择器的支持不一样
491 |
492 | ```
493 | /***** Selector Hacks ******/
494 |
495 | /* IE6 and below */
496 | * html #uno { color: red }
497 |
498 | /* IE7 */
499 | *:first-child+html #dos { color: red }
500 |
501 | /* IE7, FF, Saf, Opera */
502 | html>body #tres { color: red }
503 |
504 | /* IE8, FF, Saf, Opera (Everything but IE 6,7) */
505 | html>/**/body #cuatro { color: red }
506 |
507 | /* Opera 9.27 and below, safari 2 */
508 | html:first-child #cinco { color: red }
509 |
510 | /* Safari 2-3 */
511 | html[xmlns*=""] body:last-child #seis { color: red }
512 |
513 | /* safari 3+, chrome 1+, opera9+, ff 3.5+ */
514 | body:nth-of-type(1) #siete { color: red }
515 |
516 | /* safari 3+, chrome 1+, opera9+, ff 3.5+ */
517 | body:first-of-type #ocho { color: red }
518 |
519 | /* saf3+, chrome1+ */
520 | @media screen and (-webkit-min-device-pixel-ratio:0) {
521 | #diez { color: red }
522 | }
523 |
524 | /* iPhone / mobile webkit */
525 | @media screen and (max-device-width: 480px) {
526 | #veintiseis { color: red }
527 | }
528 |
529 | /* Safari 2 - 3.1 */
530 | html[xmlns*=""]:root #trece { color: red }
531 |
532 | /* Safari 2 - 3.1, Opera 9.25 */
533 | *|html[xmlns*=""] #catorce { color: red }
534 |
535 | /* Everything but IE6-8 */
536 | :root *> #quince { color: red }
537 |
538 | /* IE7 */
539 | *+html #dieciocho { color: red }
540 |
541 | /* Firefox only. 1+ */
542 | #veinticuatro, x:-moz-any-link { color: red }
543 |
544 | /* Firefox 3.0+ */
545 | #veinticinco, x:-moz-any-link, x:default { color: red }
546 | ```
547 |
548 | - 属性hack：不同浏览器解析bug或方法
549 |
550 | ```
551 | /* IE6 */
552 | #once { _color: blue }
553 |
554 | /* IE6, IE7 */
555 | #doce { *color: blue; /* or #color: blue */ }
556 |
557 | /* Everything but IE6 */
558 | #diecisiete { color/**/: blue }
559 |
560 | /* IE6, IE7, IE8 */
561 | #diecinueve { color: blue\9; }
562 |
563 | /* IE7, IE8 */
564 | #veinte { color/*\**/: blue\9; }
565 |
566 | /* IE6, IE7 -- acts as an !important */
567 | #veintesiete { color: blue !ie; } /* string after ! can be anything */
568 | ```
569 |
570 | ### specified value,computed value,used value计算方法
571 |
572 | - specified value: 计算方法如下：
573 | 1. 如果样式表设置了一个值，使用这个值
574 | 2. 如果没有设置值，这个属性是继承属性，从父元素继承
575 | 3. 如果没设置，并且不是继承属性，使用css规范指定的初始值
576 |
577 | - computed value: 以specified value根据规范定义的行为进行计算，通常将相对值计算为绝对值，例如em根据font-size进行计算。一些使用百分数并且需要布局来决定最终值的属性，如width，margin。百分数就直接作为computed value。line-height的无单位值也直接作为computed value。这些值将在计算used value时得到绝对值。**computed value的主要作用是用于继承**
578 |
579 | - used value：属性计算后的最终值，对于大多数属性可以通过window.getComputedStyle获得，尺寸值单位为像素。以下属性依赖于布局，
580 | - background-position
581 | - bottom, left, right, top
582 | - height, width
583 | - margin-bottom, margin-left, margin-right, margin-top
584 | - min-height, min-width
585 | - padding-bottom, padding-left, padding-right, padding-top
586 | - text-indent
587 |
588 | ### `link`与`@import`的区别
589 |
590 | 1. ``link``是HTML方式， ``@import``是CSS方式
591 | 2. ``link``最大限度支持并行下载，``@import``过多嵌套导致串行下载，出现[FOUC](http://www.bluerobot.com/web/css/fouc.asp/)
592 | 4. ``link``可以通过``rel="alternate stylesheet"``指定候选样式
593 | 5. 浏览器对``link``支持早于``@import``，可以使用``@import``对老浏览器隐藏样式
594 | 6. ``@import``必须在样式规则之前，可以在css文件中引用其他文件
595 | 6. 总体来说：**[link优于@import](http://www.stevesouders.com/blog/2009/04/09/dont-use-import/)**
596 |
597 | ### ``display: block;``和``display: inline;``的区别
598 |
599 | ``block``元素特点：
600 |
601 | 1.处于常规流中时，如果``width``没有设置，会自动填充满父容器
602 | 2.可以应用``margin/padding``
603 | 3.在没有设置高度的情况下会扩展高度以包含常规流中的子元素
604 | 4.处于常规流中时布局时在前后元素位置之间（独占一个水平空间）
605 | 5.忽略``vertical-align``
606 |
607 | ``inline``元素特点
608 |
609 | 1.水平方向上根据``direction``依次布局
610 | 2.不会在元素前后进行换行
611 | 3.受``white-space``控制
612 | 4.``margin/padding``在竖直方向上无效，水平方向上有效
613 | 5.``width/height``属性对非替换行内元素无效，宽度由元素内容决定
614 | 6.非替换行内元素的行框高由``line-height``确定，替换行内元素的行框高由``height``,``margin``,``padding``,``border``决定
615 | 6.浮动或绝对定位时会转换为``block``
616 | 7.``vertical-align``属性生效
617 |
618 |
619 |
620 | ### PNG,GIF,JPG的区别及如何选
621 | 参考资料： [选择正确的图片格式](http://www.yuiblog.com/blog/2008/11/04/imageopt-2/)
622 | **GIF**:
623 |
624 | 1. 8位像素，256色
625 | 2. 无损压缩
626 | 3. 支持简单动画
627 | 4. 支持boolean透明
628 | 5. 适合简单动画
629 |
630 | **JPEG**：
631 |
632 | 1. 颜色限于256
633 | 2. 有损压缩
634 | 3. 可控制压缩质量
635 | 4. 不支持透明
636 | 5. 适合照片
637 |
638 | **PNG**：
639 |
640 | 1. 有PNG8和truecolor PNG
641 | 2. PNG8类似GIF颜色上限为256，文件小，支持alpha透明度，无动画
642 | 3. 适合图标、背景、按钮
643 |
644 | ### CSS有哪些继承属性
645 |
646 | - 关于文字排版的属性如：
647 | + [font](https://developer.mozilla.org/en-US/docs/Web/CSS/font)
648 | + [word-break](https://developer.mozilla.org/en-US/docs/Web/CSS/word-break)
649 | + [letter-spacing](https://developer.mozilla.org/en-US/docs/Web/CSS/letter-spacing)
650 | + [text-align](https://developer.mozilla.org/en-US/docs/Web/CSS/text-align)
651 | + [text-rendering](https://developer.mozilla.org/en-US/docs/Web/CSS/text-rendering)
652 | + [word-spacing](https://developer.mozilla.org/en-US/docs/Web/CSS/word-spacing)
653 | + [white-space](https://developer.mozilla.org/en-US/docs/Web/CSS/white-space)
654 | + [text-indent](https://developer.mozilla.org/en-US/docs/Web/CSS/text-indent)
655 | + [text-transform](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform)
656 | + [text-shadow](https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow)
657 | - [line-height](https://developer.mozilla.org/en-US/docs/Web/CSS/line-height)
658 | - [color](https://developer.mozilla.org/en-US/docs/Web/CSS/color)
659 | - [visibility](https://developer.mozilla.org/en-US/docs/Web/CSS/visibility)
660 | - [cursor](https://developer.mozilla.org/en-US/docs/Web/CSS/cursor)
661 |
662 |
663 |
664 | ### IE6浏览器有哪些常见的bug,缺陷或者与标准不一致的地方,如何解决
665 |
666 | - IE6不支持min-height，解决办法使用css hack：
667 |
668 | ```
669 | .target {
670 | min-height: 100px;
671 | height: auto !important;
672 | height: 100px; // IE6下内容高度超过会自动扩展高度
673 | }
674 | ```
675 |
676 | - ``ol``内``li``的序号全为1，不递增。解决方法：为li设置样式``display: list-item;``
677 |
678 | - 未定位父元素``overflow: auto;``，包含``position: relative;``子元素，子元素高于父元素时会溢出。解决办法：1）子元素去掉``position: relative;``; 2）不能为子元素去掉定位时，父元素``position: relative;``
679 |
680 | ```
681 |
696 |
697 |
700 | ```
701 |
702 | - IE6只支持``a``标签的``:hover``伪类，解决方法：使用js为元素监听mouseenter，mouseleave事件，添加类实现效果：
703 |
704 | ```
705 |
711 |
712 | aaaa bbbbbDDDDDDDDDDDd aaaa lkjlkjdf j
713 |
714 |
738 | ```
739 |
740 | - IE5-8不支持``opacity``，解决办法：
741 |
742 | ```
743 | .opacity {
744 | opacity: 0.4
745 | filter: alpha(opacity=60); /* for IE5-7 */
746 | -ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=60)"; /* for IE 8*/
747 | }
748 | ```
749 |
750 | - IE6在设置``height``小于``font-size``时高度值为``font-size``，解决办法：``font-size: 0;``
751 | - IE6不支持PNG透明背景，解决办法: **IE6下使用gif图片**
752 | - IE6-7不支持``display: inline-block``解决办法：设置inline并触发hasLayout
753 |
754 | ```
755 | display: inline-block;
756 | *display: inline;
757 | *zoom: 1;
758 | ```
759 |
760 | - IE6下浮动元素在浮动方向上与父元素边界接触元素的外边距会加倍。解决办法：
761 | 1）使用padding控制间距。
762 | 2）浮动元素``display: inline;``这样解决问题且无任何副作用：css标准规定浮动元素display:inline会自动调整为block
763 | - 通过为块级元素设置宽度和左右margin为auto时，IE6不能实现水平居中，解决方法：为父元素设置``text-align: center;``
764 |
765 | ### 容器包含若干浮动元素时如何清理(包含)浮动
766 |
767 | 1. 容器元素闭合标签前添加额外元素并设置``clear: both``
768 | 2. 父元素触发块级格式化上下文(见块级可视化上下文部分)
769 | 3. 设置容器元素伪元素进行清理[推荐的清理浮动方法](http://nicolasgallagher.com/micro-clearfix-hack/)
770 |
771 | ```
772 | /**
773 | * 在标准浏览器下使用
774 | * 1 content内容为空格用于修复opera下文档中出现
775 | * contenteditable属性时在清理浮动元素上下的空白
776 | * 2 使用display使用table而不是block：可以防止容器和
777 | * 子元素top-margin折叠,这样能使清理效果与BFC，IE6/7
778 | * zoom: 1;一致
779 | **/
780 |
781 | .clearfix:before,
782 | .clearfix:after {
783 | content: " "; /* 1 */
784 | display: table; /* 2 */
785 | }
786 |
787 | .clearfix:after {
788 | clear: both;
789 | }
790 |
791 | /**
792 | * IE 6/7下使用
793 | * 通过触发hasLayout实现包含浮动
794 | **/
795 | .clearfix {
796 | *zoom: 1;
797 | }
798 | ```
799 |
800 | ### 什么是FOUC?如何避免
801 | Flash Of Unstyled Content：用户定义样式表加载之前浏览器使用默认样式显示文档，用户样式加载渲染之后再从新显示文档，造成页面闪烁。**解决方法**：把样式表放到文档的`head`
802 |
803 | ### 如何创建块级格式化上下文(block formatting context),BFC有什么用
804 | 创建规则：
805 |
806 | 1. 根元素
807 | 2. 浮动元素（``float``不是``none``）
808 | 3. 绝对定位元素（``position``取值为``absolute``或``fixed``）
809 | 4. ``display``取值为``inline-block``,``table-cell``, ``table-caption``,``flex``, ``inline-flex``之一的元素
810 | 5. ``overflow``不是``visible``的元素
811 |
812 |
813 | 作用：
814 |
815 | 1. 可以包含浮动元素
816 | 2. 不被浮动元素覆盖
817 | 3. 阻止父子元素的margin折叠
818 |
819 | ### display,float,position的关系
820 |
821 | 1. 如果``display``为none，那么position和float都不起作用，这种情况下元素不产生框
822 | 2. 否则，如果position值为absolute或者fixed，框就是绝对定位的，float的计算值为none，display根据下面的表格进行调整。
823 | 3. 否则，如果float不是none，框是浮动的，display根据下表进行调整
824 | 4. 否则，如果元素是根元素，display根据下表进行调整
825 | 5. 其他情况下display的值为指定值
826 | 总结起来：**绝对定位、浮动、根元素都需要调整``display``**
827 | 
828 |
829 | ### 外边距折叠(collapsing margins)
830 | 毗邻的两个或多个``margin``会合并成一个margin，叫做外边距折叠。规则如下：
831 |
832 | 1. 两个或多个毗邻的普通流中的块元素垂直方向上的margin会折叠
833 | 2. 浮动元素/inline-block元素/绝对定位元素的margin不会和垂直方向上的其他元素的margin折叠
834 | 3. 创建了块级格式化上下文的元素，不会和它的子元素发生margin折叠
835 | 4. 元素自身的margin-bottom和margin-top相邻时也会折叠
836 |
837 | ### 如何确定一个元素的包含块(containing block)
838 |
839 | 1. 根元素的包含块叫做初始包含块，在连续媒体中他的尺寸与viewport相同并且anchored at the canvas origin；对于paged media，它的尺寸等于page area。初始包含块的direction属性与根元素相同。
840 | 2. ``position``为``relative``或者``static``的元素，它的包含块由最近的块级（``display``为``block``,``list-item``, ``table``）祖先元素的**内容框**组成
841 | 3. 如果元素``position``为``fixed``。对于连续媒体，它的包含块为viewport；对于paged media，包含块为page area
842 | 4. 如果元素``position``为``absolute``，它的包含块由祖先元素中最近一个``position``为``relative``,``absolute``或者``fixed``的元素产生，规则如下：
843 | - 如果祖先元素为行内元素，the containing block is the bounding box around the **padding boxes** of the first and the last inline boxes generated for that element.
844 | - 其他情况下包含块由祖先节点的**padding edge**组成
845 |
846 | 如果找不到定位的祖先元素，包含块为**初始包含块**
847 |
848 | ### stacking context,布局规则
849 | z轴上的默认层叠顺序如下（从下到上）：
850 |
851 | 1. 根元素的边界和背景
852 | 2. 常规流中的元素按照html中顺序
853 | 3. 浮动块
854 | 4. positioned元素按照html中出现顺序
855 |
856 | 如何创建stacking context：
857 |
858 | 1. 根元素
859 | 2. z-index不为auto的定位元素
860 | 3. a flex item with a z-index value other than 'auto'
861 | 4. opacity小于1的元素
862 | 5. 在移动端webkit和chrome22+，z-index为auto，position: fixed也将创建新的stacking context
863 |
864 | ### 如何水平居中一个元素
865 | - 如果需要居中的元素为**常规流中inline元素**，为父元素设置`text-align: center;`即可实现
866 | - 如果需要居中的元素为**常规流中block元素**，1）为元素设置宽度，2）设置左右margin为auto。3）IE6下需在父元素上设置`text-align: center;`,再给子元素恢复需要的值
867 |
868 | ```
869 |
870 |
871 | aaaaaa aaaaaa a a a a a a a a
872 |
873 |
874 |
875 |
888 | ```
889 |
890 | - 如果需要居中的元素为**浮动元素**，1）为元素设置宽度，2）`position: relative;`，3）浮动方向偏移量（left或者right）设置为50%，4）浮动方向上的margin设置为元素宽度一半乘以-1
891 |
892 | ```
893 |
894 |
895 | aaaaaa aaaaaa a a a a a a a a
896 |
897 |
898 |
899 |
914 | ```
915 |
916 | - 如果需要居中的元素为**绝对定位元素**，1）为元素设置宽度，2）偏移量设置为50%，3）偏移方向外边距设置为元素宽度一半乘以-1
917 |
918 | ```
919 |
920 |
921 | aaaaaa aaaaaa a a a a a a a a
922 |
923 |
924 |
925 |
940 | ```
941 |
942 | - 如果需要居中的元素为**绝对定位元素**，1）为元素设置宽度，2）设置左右偏移量都为0,3）设置左右外边距都为auto
943 |
944 | ```
945 |
946 |
947 | aaaaaa aaaaaa a a a a a a a a
948 |
949 |
950 |
951 |
967 | ```
968 |
969 | ### 如何竖直居中一个元素
970 | 参考资料：[6 Methods For Vertical Centering With CSS](http://www.vanseodesign.com/css/vertical-centering/)。 [盘点8种CSS实现垂直居中](http://blog.csdn.net/freshlover/article/details/11579669)
971 |
972 | - 需要居中元素为**单行文本**，为包含文本的元素设置大于`font-size`的`line-height`：
973 |
974 | ```
975 | center text
976 |
977 |
982 | ```
983 |
984 |
985 | ## $javascript概念部分
986 |
987 | ### DOM元素e的e.getAttribute(propName)和e.propName有什么区别和联系
988 |
989 | - e.getAttribute()，是标准DOM操作文档元素属性的方法，具有通用性可在任意文档上使用，返回元素在源文件中**设置的属性**
990 | - e.propName通常是在HTML文档中访问特定元素的**特性**，浏览器解析元素后生成对应对象（如a标签生成HTMLAnchorElement），这些对象的特性会根据特定规则结合属性设置得到，对于没有对应特性的属性，只能使用getAttribute进行访问
991 | - e.getAttribute()返回值是源文件中设置的值，类型是字符串或者null（有的实现返回""）
992 | - e.propName返回值可能是字符串、布尔值、对象、undefined等
993 | - 大部分attribute与property是一一对应关系，修改其中一个会影响另一个，如id，title等属性
994 | - 一些布尔属性``的检测设置需要hasAttribute和removeAttribute来完成，或者设置对应property
995 | - 像`link`中href属性，转换成property的时候需要通过转换得到完整URL
996 | - 一些attribute和property不是一一对应如：form控件中``对应的是defaultValue，修改或设置value property修改的是控件当前值，setAttribute修改value属性不会改变value property
997 |
998 | ### offsetWidth/offsetHeight,clientWidth/clientHeight与scrollWidth/scrollHeight的区别
999 |
1000 | - offsetWidth/offsetHeight返回值包含**content + padding + border**，效果与e.getBoundingClientRect()相同
1001 | - clientWidth/clientHeight返回值只包含**content + padding**，如果有滚动条，也**不包含滚动条**
1002 | - scrollWidth/scrollHeight返回值包含**content + padding + 溢出内容的尺寸**
1003 |
1004 | [Measuring Element Dimension and Location with CSSOM in Windows Internet Explorer 9](http://msdn.microsoft.com/en-us/library/ie/hh781509(v=vs.85).aspx)
1005 |
1006 | 
1007 |
1008 | ### XMLHttpRequest通用属性和方法
1009 |
1010 | 1. `readyState`:表示请求状态的整数，取值：
1011 | - UNSENT（0）：对象已创建
1012 | - OPENED（1）：open()成功调用，在这个状态下，可以为xhr设置请求头，或者使用send()发送请求
1013 | - HEADERS_RECEIVED(2)：所有重定向已经自动完成访问，并且最终响应的HTTP头已经收到
1014 | - LOADING(3)：响应体正在接收
1015 | - DONE(4)：数据传输完成或者传输产生错误
1016 | 3. `onreadystatechange`：readyState改变时调用的函数
1017 | 4. `status`：服务器返回的HTTP状态码（如，200， 404）
1018 | 5. `statusText`:服务器返回的HTTP状态信息（如，OK，No Content）
1019 | 6. `responseText`:作为字符串形式的来自服务器的完整响应
1020 | 6. `responseXML`: Document对象，表示服务器的响应解析成的XML文档
1021 | 7. `abort()`:取消异步HTTP请求
1022 | 8. `getAllResponseHeaders()`: 返回一个字符串，包含响应中服务器发送的全部HTTP报头。每个报头都是一个用冒号分隔开的名/值对，并且使用一个回车/换行来分隔报头行
1023 | 9. `getResponseHeader(headerName)`:返回headName对应的报头值
1024 | 10. `open(method, url, asynchronous [, user, password])`:初始化准备发送到服务器上的请求。method是HTTP方法，不区分大小写；url是请求发送的相对或绝对URL；asynchronous表示请求是否异步；user和password提供身份验证
1025 | 11. `setRequestHeader(name, value)`:设置HTTP报头
1026 | 12. `send(body)`:对服务器请求进行初始化。参数body包含请求的主体部分，对于POST请求为键值对字符串；对于GET请求，为null
1027 |
1028 | ### focus/blur与focusin/focusout的区别与联系
1029 |
1030 | 1. focus/blur不冒泡，focusin/focusout冒泡
1031 | 2. focus/blur兼容性好，focusin/focusout在除FireFox外的浏览器下都保持良好兼容性，如需使用事件托管，可考虑在FireFox下使用事件捕获elem.addEventListener('focus', handler, true)
1032 | 3. 可获得焦点的元素：
1033 | 1. window
1034 | 2. 链接被点击或键盘操作
1035 | 3. 表单空间被点击或键盘操作
1036 | 4. 设置`tabindex`属性的元素被点击或键盘操作
1037 |
1038 | ### mouseover/mouseout与mouseenter/mouseleave的区别与联系
1039 |
1040 | 1. mouseover/mouseout是标准事件，**所有浏览器都支持**；mouseenter/mouseleave是IE5.5引入的特有事件后来被DOM3标准采纳，现代标准浏览器也支持
1041 | 2. mouseover/mouseout是**冒泡**事件；mouseenter/mouseleave**不冒泡**。需要为**多个元素监听鼠标移入/出事件时，推荐mouseover/mouseout托管，提高性能**
1042 | 3. 标准事件模型中event.target表示发生移入/出的元素,**vent.relatedTarget**对应移出/如元素；在老IE中event.srcElement表示发生移入/出的元素，**event.toElement**表示移出的目标元素，**event.fromElement**表示移入时的来源元素
1043 |
1044 | 例子：鼠标从div#target元素移出时进行处理，判断逻辑如下：
1045 |
1046 | test
1047 |
1048 |
1082 |
1083 | ### sessionStorage,localStorage,cookie区别
1084 |
1085 | 1. 都会在浏览器端保存，有大小限制，同源限制
1086 | 2. cookie会在请求时发送到服务器，作为会话标识，服务器可修改cookie；web storage不会发送到服务器
1087 | 3. cookie有path概念，子路径可以访问父路径cookie，父路径不能访问子路径cookie
1088 | 4. 有效期：cookie在设置的有效期内有效，默认为浏览器关闭；sessionStorage在窗口关闭前有效，localStorage长期有效，直到用户删除
1089 | 5. 共享：sessionStorage不能共享，localStorage在同源文档之间共享，cookie在同源且符合path规则的文档之间共享
1090 | 6. localStorage的修改会促发其他文档窗口的update事件
1091 | 7. cookie有secure属性要求HTTPS传输
1092 | 8. 浏览器不能保存超过300个cookie，单个服务器不能超过20个，每个cookie不能超过4k。web storage大小支持能达到5M
1093 |
1094 | ### javascript跨域通信
1095 | 同源：两个文档同源需满足
1096 |
1097 | 1. 协议相同
1098 | 2. 域名相同
1099 | 3. 端口相同
1100 |
1101 | 跨域通信：js进行DOM操作、通信时如果目标与当前窗口不满足同源条件，浏览器为了安全会阻止跨域操作。跨域通信通常有以下方法
1102 |
1103 | - 如果是log之类的简单**单项通信**，新建``![]()
``,``
1458 | ```
1459 |
1460 | ### 请用代码写出(今天是星期x)其中x表示当天是星期几,如果当天是星期一,输出应该是"今天是星期一"
1461 |
1462 | ```
1463 | var days = ['日','一','二','三','四','五','六'];
1464 | var date = new Date();
1465 |
1466 | console.log('今天是星期' + days[date.getDay()]);
1467 | ```
1468 |
1469 | ### 下面这段代码想要循环延时输出结果0 1 2 3 4,请问输出结果是否正确,如果不正确,请说明为什么,并修改循环内的代码使其输出正确结果
1470 |
1471 | ```
1472 | for (var i = 0; i < 5; ++i) {
1473 | setTimeout(function () {
1474 | console.log(i + ' ');
1475 | }, 100);
1476 | }
1477 | ```
1478 |
1479 | 不能输出正确结果，因为循环中setTimeout接受的参数函数通过闭包访问变量i。javascript运行环境为单线程，setTimeout注册的函数需要等待线程空闲才能执行，此时for循环已经结束，i值为5.五个定时输出都是5
1480 | 修改方法：将setTimeout放在函数立即调用表达式中，将i值作为参数传递给包裹函数，创建新闭包
1481 |
1482 | ```
1483 | for (var i = 0; i < 5; ++i) {
1484 | (function (i) {
1485 | setTimeout(function () {
1486 | console.log(i + ' ');
1487 | }, 100);
1488 | }(i));
1489 | }
1490 | ```
1491 |
1492 |
1493 |
1494 | ### 现有一个Page类,其原型对象上有许多以post开头的方法(如postMsg);另有一拦截函数chekc,只返回ture或false.请设计一个函数,该函数应批量改造原Page的postXXX方法,在保留其原有功能的同时,为每个postXXX方法增加拦截验证功能,当chekc返回true时继续执行原postXXX方法,返回false时不再执行原postXXX方法
1495 |
1496 | ```
1497 | function Page() {}
1498 |
1499 | Page.prototype = {
1500 | constructor: Page,
1501 |
1502 | postA: function (a) {
1503 | console.log('a:' + a);
1504 | },
1505 | postB: function (b) {
1506 | console.log('b:' + b);
1507 | },
1508 | postC: function (c) {
1509 | console.log('c:' + c);
1510 | },
1511 | check: function () {
1512 | return Math.random() > 0.5;
1513 | }
1514 | }
1515 |
1516 | function checkfy(obj) {
1517 | for (var key in obj) {
1518 | if (key.indexOf('post') === 0 && typeof obj[key] === 'function') {
1519 | (function (key) {
1520 | var fn = obj[key];
1521 | obj[key] = function () {
1522 | if (obj.check()) {
1523 | fn.apply(obj, arguments);
1524 | }
1525 | };
1526 | }(key));
1527 | }
1528 | }
1529 | } // end checkfy()
1530 |
1531 | checkfy(Page.prototype);
1532 |
1533 | var obj = new Page();
1534 |
1535 | obj.postA('checkfy');
1536 | obj.postB('checkfy');
1537 | obj.postC('checkfy');
1538 | ```
1539 |
1540 | ### 完成下面的tool-tip
1541 | 
1542 |
1543 | ### 编写javascript深度克隆函数deepClone
1544 |
1545 | function deepClone(obj) {
1546 | var _toString = Object.prototype.toString;
1547 |
1548 | // null, undefined, non-object, function
1549 | if (!obj || typeof obj !== 'object') {
1550 | return obj;
1551 | }
1552 |
1553 | // DOM Node
1554 | if (obj.nodeType && 'cloneNode' in obj) {
1555 | return obj.cloneNode(true);
1556 | }
1557 |
1558 | // Date
1559 | if (_toString.call(obj) === '[object Date]') {
1560 | return new Date(obj.getTime());
1561 | }
1562 |
1563 | // RegExp
1564 | if (_toString.call(obj) === '[object RegExp]') {
1565 | var flags = [];
1566 | if (obj.global) { flags.push('g'); }
1567 | if (obj.multiline) { flags.push('m'); }
1568 | if (obj.ignoreCase) { flags.push('i'); }
1569 |
1570 | return new RegExp(obj.source, flags.join(''));
1571 | }
1572 |
1573 | var result = Array.isArray(obj) ? [] :
1574 | obj.constructor ? new obj.constructor() : {};
1575 |
1576 | for (var key in obj ) {
1577 | result[key] = deepClone(obj[key]);
1578 | }
1579 |
1580 | return result;
1581 | }
1582 |
1583 | function A() {
1584 | this.a = a;
1585 | }
1586 |
1587 | var a = {
1588 | name: 'qiu',
1589 | birth: new Date(),
1590 | pattern: /qiu/gim,
1591 | container: document.body,
1592 | hobbys: ['book', new Date(), /aaa/gim, 111]
1593 | };
1594 |
1595 | var c = new A();
1596 | var b = deepClone(c);
1597 | console.log(c.a === b.a);
1598 | console.log(c, b);
1599 |
1600 | ### 补充代码,鼠标单击Button1后将Button1移动到Button2的后面
1601 |
1602 |
1603 |
1604 |
1605 | TEst
1606 |
1607 |
1608 |
1609 |
1610 |
1611 |
1612 |
1613 |
1614 |
1638 |
1639 |
1640 |
1641 | ### 网页中实现一个计算当年还剩多少时间的倒数计时程序,要求网页上实时动态显示"××年还剩××天××时××分××秒"
1642 |
1643 |
1644 |
1645 |
1646 |
1647 | TEst
1648 |
1649 |
1650 |
1651 |
1652 |
1653 |
1654 |
1697 |
1698 |
1699 |
1700 |
1701 | ### 完成一个函数,接受数组作为参数,数组元素为整数或者数组,数组元素包含整数或数组,函数返回扁平化后的数组
1702 | 如：[1, [2, [ [3, 4], 5], 6]] => [1, 2, 3, 4, 5, 6]
1703 |
1704 | ```
1705 | var data = [1, [2, [ [3, 4], 5], 6]];
1706 |
1707 | function flat(data, result) {
1708 | var i, d, len;
1709 | for (i = 0, len = data.length; i < len; ++i) {
1710 | d = data[i];
1711 | if (typeof d === 'number') {
1712 | result.push(d);
1713 | } else {
1714 | flat(d, result);
1715 | }
1716 | }
1717 | }
1718 |
1719 | var result = [];
1720 | flat(data, result);
1721 |
1722 | console.log(result);
1723 | ```
1724 |
1725 | ### 如何判断一个对象是否为数组
1726 | 如果浏览器支持Array.isArray()可以直接判断否则需进行必要判断
1727 |
1728 | ```
1729 | /**
1730 | * 判断一个对象是否是数组，参数不是对象或者不是数组，返回false
1731 | *
1732 | * @param {Object} arg 需要测试是否为数组的对象
1733 | * @return {Boolean} 传入参数是数组返回true，否则返回false
1734 | */
1735 | function isArray(arg) {
1736 | if (typeof arg === 'object') {
1737 | return Object.prototype.toString.call(arg) === '[object Array]';
1738 | }
1739 | return false;
1740 | }
1741 | ```
1742 |
1743 | ### 请评价以下事件监听器代码并给出改进意见
1744 |
1745 | ```
1746 | if (window.addEventListener) {
1747 | var addListener = function (el, type, listener, useCapture) {
1748 | el.addEventListener(type, listener, useCapture);
1749 | };
1750 | }
1751 | else if (document.all) {
1752 | addListener = function (el, type, listener) {
1753 | el.attachEvent('on' + type, function () {
1754 | listener.apply(el);
1755 | });
1756 | };
1757 | }
1758 | ```
1759 |
1760 | 作用：浏览器功能检测实现跨浏览器DOM事件绑定
1761 |
1762 | 优点：
1763 |
1764 | 1. 测试代码只运行一次，根据浏览器确定绑定方法
1765 | 2. 通过``listener.apply(el)``解决IE下监听器this与标准不一致的地方
1766 | 3. 在浏览器不支持的情况下提供简单的功能，在标准浏览器中提供捕获功能
1767 |
1768 | 缺点：
1769 |
1770 | 1. document.all作为IE检测不可靠，应该使用if(el.attachEvent)
1771 | 2. addListener在不同浏览器下API不一样
1772 | 3. ``listener.apply``使this与标准一致但监听器无法移除
1773 | 4. 未解决IE下listener参数event。 target问题
1774 |
1775 | 改进:
1776 |
1777 | ```
1778 | var addListener;
1779 |
1780 | if (window.addEventListener) {
1781 | addListener = function (el, type, listener, useCapture) {
1782 | el.addEventListener(type, listener, useCapture);
1783 | return listener;
1784 | };
1785 | }
1786 | else if (window.attachEvent) {
1787 | addListener = function (el, type, listener) {
1788 | // 标准化this，event，target
1789 | var wrapper = function () {
1790 | var event = window.event;
1791 | event.target = event.srcElement;
1792 | listener.call(el, event);
1793 | };
1794 |
1795 | el.attachEvent('on' + type, wrapper);
1796 | return wrapper;
1797 | // 返回wrapper。调用者可以保存，以后remove
1798 | };
1799 | }
1800 | ```
1801 |
1802 | ### 如何判断一个对象是否为函数
1803 |
1804 | ```
1805 | /**
1806 | * 判断对象是否为函数，如果当前运行环境对可调用对象（如正则表达式）
1807 | * 的typeof返回'function'，采用通用方法，否则采用优化方法
1808 | *
1809 | * @param {Any} arg 需要检测是否为函数的对象
1810 | * @return {boolean} 如果参数是函数，返回true，否则false
1811 | */
1812 | function isFunction(arg) {
1813 | if (arg) {
1814 | if (typeof (/./) !== 'function') {
1815 | return typeof arg === 'function';
1816 | } else {
1817 | return Object.prototype.toString.call(arg) === '[object Function]';
1818 | }
1819 | } // end if
1820 | return false;
1821 | }
1822 | ```
1823 |
1824 | ### 编写一个函数接受url中query string为参数,返回解析后的Object,query string使用application/x-www-form-urlencoded编码
1825 |
1826 | ```
1827 | /**
1828 | * 解析query string转换为对象，一个key有多个值时生成数组
1829 | *
1830 | * @param {String} query 需要解析的query字符串，开头可以是?，
1831 | * 按照application/x-www-form-urlencoded编码
1832 | * @return {Object} 参数解析后的对象
1833 | */
1834 | function parseQuery(query) {
1835 | var result = {};
1836 |
1837 | // 如果不是字符串返回空对象
1838 | if (typeof query !== 'string') {
1839 | return result;
1840 | }
1841 |
1842 | // 去掉字符串开头可能带的?
1843 | if (query.charAt(0) === '?') {
1844 | query = query.substring(1);
1845 | }
1846 |
1847 | var pairs = query.split('&');
1848 | var pair;
1849 | var key, value;
1850 | var i, len;
1851 |
1852 | for (i = 0, len = pairs.length; i < len; ++i) {
1853 | pair = pairs[i].split('=');
1854 | // application/x-www-form-urlencoded编码会将' '转换为+
1855 | key = decodeURIComponent(pair[0]).replace(/\+/g, ' ');
1856 | value = decodeURIComponent(pair[1]).replace(/\+/g, ' ');
1857 |
1858 | // 如果是新key，直接添加
1859 | if (!(key in result)) {
1860 | result[key] = value;
1861 | }
1862 | // 如果key已经出现一次以上，直接向数组添加value
1863 | else if (isArray(result[key])) {
1864 | result[key].push(value);
1865 | }
1866 | // key第二次出现，将结果改为数组
1867 | else {
1868 | var arr = [result[key]];
1869 | arr.push(value);
1870 | result[key] = arr;
1871 | } // end if-else
1872 | } // end for
1873 |
1874 | return result;
1875 | }
1876 |
1877 | function isArray(arg) {
1878 | if (arg && typeof arg === 'object') {
1879 | return Object.prototype.toString.call(arg) === '[object Array]';
1880 | }
1881 | return false;
1882 | }
1883 | /**
1884 | console.log(parseQuery('sourceid=chrome-instant&ion=1&espv=2&ie=UTF-8'));
1885 | */
1886 | ```
1887 |
1888 | ### 解析一个完整的url,返回Object包含域与window.location相同
1889 |
1890 | ```
1891 | /**
1892 | * 解析一个url并生成window.location对象中包含的域
1893 | * location:
1894 | * {
1895 | * href: '包含完整的url',
1896 | * origin: '包含协议到pathname之前的内容',
1897 | * protocol: 'url使用的协议，包含末尾的:',
1898 | * username: '用户名', // 暂时不支持
1899 | * password: '密码', // 暂时不支持
1900 | * host: '完整主机名，包含:和端口',
1901 | * hostname: '主机名，不包含端口'
1902 | * port: '端口号',
1903 | * pathname: '服务器上访问资源的路径/开头',
1904 | * search: 'query string，?开头',
1905 | * hash: '#开头的fragment identifier'
1906 | * }
1907 | *
1908 | * @param {string} url 需要解析的url
1909 | * @return {Object} 包含url信息的对象
1910 | */
1911 | function parseUrl(url) {
1912 | var result = {};
1913 | var keys = ['href', 'origin', 'protocol', 'host',
1914 | 'hostname', 'port', 'pathname', 'search', 'hash'];
1915 | var i, len;
1916 | var regexp = /(([^:]+:)\/\/(([^:\/\?#]+)(:\d+)?))(\/[^?#]*)?(\?[^#]*)?(#.*)?/;
1917 |
1918 | var match = regexp.exec(url);
1919 |
1920 | if (match) {
1921 | for (i = keys.length - 1; i >= 0; --i) {
1922 | result[keys[i]] = match[i] ? match[i] : '';
1923 | }
1924 | }
1925 |
1926 | return result;
1927 | }
1928 | ```
1929 |
1930 | ### 完成函数getViewportSize返回指定窗口的视口尺寸
1931 |
1932 | ```
1933 | /**
1934 | * 查询指定窗口的视口尺寸，如果不指定窗口，查询当前窗口尺寸
1935 | **/
1936 | function getViewportSize(w) {
1937 | w = w || window;
1938 |
1939 | // IE9及标准浏览器中可使用此标准方法
1940 | if ('innerHeight' in w) {
1941 | return {
1942 | width: w.innerWidth,
1943 | height: w.innerHeight
1944 | };
1945 | }
1946 |
1947 | var d = w.document;
1948 | // IE 8及以下浏览器在标准模式下
1949 | if (document.compatMode === 'CSS1Compat') {
1950 | return {
1951 | width: d.documentElement.clientWidth,
1952 | height: d.documentElement.clientHeight
1953 | };
1954 | }
1955 |
1956 | // IE8及以下浏览器在怪癖模式下
1957 | return {
1958 | width: d.body.clientWidth,
1959 | height: d.body.clientHeight
1960 | };
1961 | }
1962 | ```
1963 |
1964 | ### 完成函数getScrollOffset返回窗口滚动条偏移量
1965 |
1966 | /**
1967 | * 获取指定window中滚动条的偏移量，如未指定则获取当前window
1968 | * 滚动条偏移量
1969 | *
1970 | * @param {window} w 需要获取滚动条偏移量的窗口
1971 | * @return {Object} obj.x为水平滚动条偏移量,obj.y为竖直滚动条偏移量
1972 | */
1973 | function getScrollOffset(w) {
1974 | w = w || window;
1975 | // 如果是标准浏览器
1976 | if (w.pageXOffset != null) {
1977 | return {
1978 | x: w.pageXOffset,
1979 | y: w.pageYOffset
1980 | };
1981 | }
1982 |
1983 | // 老版本IE，根据兼容性不同访问不同元素
1984 | var d = w.document;
1985 | if (d.compatMode === 'CSS1Compat') {
1986 | return {
1987 | x: d.documentElement.scrollLeft,
1988 | y: d.documentElement.scrollTop
1989 | }
1990 | }
1991 |
1992 | return {
1993 | x: d.body.scrollLeft,
1994 | y: d.body.scrollTop
1995 | };
1996 | }
1997 |
1998 |
1999 | ### 现有一个字符串richText,是一段富文本,需要显示在页面上.有个要求,需要给其中只包含一个img元素的p标签增加一个叫pic的class.请编写代码实现.可以使用jQuery或KISSY.
2000 |
2001 | function richText(text) {
2002 | var div = document.createElement('div');
2003 | div.innerHTML = text;
2004 | var p = div.getElementsByTagName('p');
2005 | var i, len;
2006 |
2007 | for (i = 0, len = p.length; i < len; ++i) {
2008 | if (p[i].getElementsByTagName('img').length === 1) {
2009 | p[i].classList.add('pic');
2010 | }
2011 | }
2012 |
2013 | return div.innerHTML;
2014 | }
2015 |
2016 | ### 请实现一个Event类,继承自此类的对象都会拥有两个方法on,off,once和trigger
2017 |
2018 |
2019 | function Event() {
2020 | if (!(this instanceof Event)) {
2021 | return new Event();
2022 | }
2023 | this._callbacks = {};
2024 | }
2025 | Event.prototype.on = function (type, handler) {
2026 | this_callbacks = this._callbacks || {};
2027 | this._callbacks[type] = this.callbacks[type] || [];
2028 | this._callbacks[type].push(handler);
2029 |
2030 | return this;
2031 | };
2032 |
2033 | Event.prototype.off = function (type, handler) {
2034 | var list = this._callbacks[type];
2035 |
2036 | if (list) {
2037 | for (var i = list.length; i >= 0; --i) {
2038 | if (list[i] === handler) {
2039 | list.splice(i, 1);
2040 | }
2041 | }
2042 | }
2043 |
2044 | return this;
2045 | };
2046 |
2047 | Event.prototype.trigger = function (type, data) {
2048 | var list = this._callbacks[type];
2049 |
2050 | if (list) {
2051 | for (var i = 0, len = list.length; i < len; ++i) {
2052 | list[i].call(this, data);
2053 | }
2054 | }
2055 | };
2056 |
2057 | Event.prototype.once = function (type, handler) {
2058 | var self = this;
2059 |
2060 | function wrapper() {
2061 | handler.apply(self, arguments);
2062 | self.off(type, wrapper);
2063 | }
2064 | this.on(type, wrapper);
2065 | return this;
2066 | };
2067 |
2068 | ### 编写一个函数将列表子元素顺序反转
2069 |
2070 | ```
2071 |
2072 | - 1
2073 | - 2
2074 | - 3
2075 | - 4
2076 |
2077 |
2078 |
2088 | ```
2089 |
2090 | ### 以下函数的作用是?空白区域应该填写什么
2091 |
2092 | ```
2093 | // define
2094 | (function (window) {
2095 | function fn(str) {
2096 | this.str = str;
2097 | }
2098 |
2099 | fn.prototype.format = function () {
2100 | var arg = __1__;
2101 | return this.str.replace(__2__, function (a, b) {
2102 | return arg[b] || '';
2103 | });
2104 | };
2105 |
2106 | window.fn = fn;
2107 | })(window);
2108 |
2109 | // use
2110 | (function () {
2111 | var t = new fn('{1}{2}
');
2112 | console.log(t.format('http://www.alibaba.com', 'Alibaba', 'Welcome'));
2113 | })();
2114 | ```
2115 |
2116 | define部分定义一个简单的模板类，使用{}作为转义标记，中间的数字表示替换目标，format实参用来替换模板内标记
2117 | 横线处填：
2118 |
2119 | 1. ``Array.prototype.slice.call(arguments, 0)``
2120 | 2. ``/\{\s*(\d+)\s*\}/g``
2121 |
2122 | ### 编写一个函数实现form的序列化(即将一个表单中的键值序列化为可提交的字符串)
2123 |
2124 |
2125 |
2144 |
2145 |
2146 |
2215 |
2216 | ### 使用原生javascript给下面列表中的li节点绑定点击事件,点击时创建一个Object对象,兼容IE和标准浏览器
2217 |
2218 | ```
2219 |
2225 |
2226 | Object:
2227 | {
2228 | "index": 1,
2229 | "name": "111",
2230 | "link": "http://1111"
2231 | }
2232 | ```
2233 |
2234 | script:
2235 |
2236 | ```
2237 | var EventUtil = {
2238 | getEvent: function (event) {
2239 | return event || window.event;
2240 | },
2241 | getTarget: function (event) {
2242 | return event.target || event.srcElement;
2243 | },
2244 | // 返回注册成功的监听器，IE中需要使用返回值来移除监听器
2245 | on: function (elem, type, handler) {
2246 | if (elem.addEventListener) {
2247 | elem.addEventListener(type, handler, false);
2248 | return handler;
2249 | } else if (elem.attachEvent) {
2250 | function wrapper(event) {
2251 | return handler.call(elem, event);
2252 | };
2253 | elem.attachEvent('on' + type, wrapper);
2254 | return wrapper;
2255 | }
2256 | },
2257 | off: function (elem, type, handler) {
2258 | if (elem.removeEventListener) {
2259 | elem.removeEventListener(type, handler, false);
2260 | } else if (elem.detachEvent) {
2261 | elem.detachEvent('on' + type, handler);
2262 | }
2263 | },
2264 | preventDefault: function (event) {
2265 | if (event.preventDefault) {
2266 | event.preventDefault();
2267 | } else if ('returnValue' in event) {
2268 | event.returnValue = false;
2269 | }
2270 | },
2271 | stopPropagation: function (event) {
2272 | if (event.stopPropagation) {
2273 | event.stopPropagation();
2274 | } else if ('cancelBubble' in event) {
2275 | event.cancelBubble = true;
2276 | }
2277 | }
2278 | };
2279 | var DOMUtil = {
2280 | text: function (elem) {
2281 | if ('textContent' in elem) {
2282 | return elem.textContent;
2283 | } else if ('innerText' in elem) {
2284 | return elem.innerText;
2285 | }
2286 | },
2287 | prop: function (elem, propName) {
2288 | return elem.getAttribute(propName);
2289 | }
2290 | };
2291 |
2292 | var nav = document.getElementById('nav');
2293 |
2294 | EventUtil.on(nav, 'click', function (event) {
2295 | var event = EventUtil.getEvent(event);
2296 | var target = EventUtil.getTarget(event);
2297 |
2298 | var children = this.children;
2299 | var i, len;
2300 | var anchor;
2301 | var obj = {};
2302 |
2303 | for (i = 0, len = children.length; i < len; ++i) {
2304 | if (children[i] === target) {
2305 | obj.index = i + 1;
2306 | anchor = target.getElementsByTagName('a')[0];
2307 | obj.name = DOMUtil.text(anchor);
2308 | obj.link = DOMUtil.prop(anchor, 'href');
2309 | }
2310 | }
2311 |
2312 | alert('index: ' + obj.index + ' name: ' + obj.name +
2313 | ' link: ' + obj.link);
2314 | });
2315 | ```
2316 |
2317 | ### 有一个大数组,var a = ['1', '2', '3', ...];a的长度是100,内容填充随机整数的字符串.请先构造此数组a,然后设计一个算法将其内容去重
2318 |
2319 | ```
2320 | /**
2321 | * 数组去重
2322 | **/
2323 | function normalize(arr) {
2324 | if (arr && Array.isArray(arr)) {
2325 | var i, len, map = {};
2326 | for (i = arr.length; i >= 0; --i) {
2327 | if (arr[i] in map) {
2328 | arr.splice(i, 1);
2329 | } else {
2330 | map[arr[i]] = true;
2331 | }
2332 | }
2333 | }
2334 | return arr;
2335 | }
2336 |
2337 | /**
2338 | * 用100个随机整数对应的字符串填充数组。
2339 | **/
2340 | function fillArray(arr, start, end) {
2341 | start = start == undefined ? 1 : start;
2342 | end = end == undefined ? 100 : end;
2343 |
2344 | if (end <= start) {
2345 | end = start + 100;
2346 | }
2347 |
2348 | var width = end - start;
2349 | var i;
2350 | for (i = 100; i >= 1; --i) {
2351 | arr.push('' + (Math.floor(Math.random() * width) + start));
2352 | }
2353 | return arr;
2354 | }
2355 |
2356 | var input = [];
2357 | fillArray(input, 1, 100);
2358 | input.sort(function (a, b) {
2359 | return a - b;
2360 | });
2361 | console.log(input);
2362 |
2363 | normalize(input);
2364 | console.log(input);
2365 | ```
2366 |
--------------------------------------------------------------------------------