渐进增强 ：针对低版本浏览器进行构建页面，保证最基本的功能，然后再针对高级浏览器进行效果、

          交互等改进和追加功能达到更好的用户体验。

优雅降级 ：一开始就构建完整的功能，然后再针对低版本浏览器进行兼容。

  -webkit  chrome和safari

     -moz  firefox

      -ms  IE

       -o  opera

  容器属性

    flex-direction
   
    flex-wrap
   
    flex-flow (flex-direction 和 flex-wrap的简写)
   
    justify-content
   
    align-items
   
    align-content


   项目属性

    order

    flex-grow

    flex-shrink

    flex-basis

    flex (flex-grow, flex-shrink 和 flex-basis的简写)

    align-self

    1.去掉或者丢失样式的时候能够让页面呈现出清晰的结构

    2.有利于SEO：和搜索引擎建立良好沟通，有助于爬虫抓取更多的有效信息：爬虫依赖于标签来确定上下文和各个关键字的权重；

    3.方便其他设备解析（如屏幕阅读器、盲人阅读器、移动设备）以意义的方式来渲染网页；

    4.便于团队开发和维护，语义化更具可读性，是下一步吧网页的重要动向，遵循W3C标准的团队都遵循这个标准，可以减少差异化。

   该标签可声明三种 DTD 类型，分别表示严格版本、过渡版本以及基于框架的 HTML 文档。

   HTML 4.01 规定了三种文档类型：Strict、Transitional 以及 Frameset。

   XHTML 1.0 规定了三种 XML 文档类型：Strict、Transitional 以及 Frameset。

   Standards （标准）模式（也就是严格呈现模式）用于呈现遵循最新标准的网页，而 Quirks

   （包容）模式（也就是松散呈现模式或者兼容模式）用于呈现为传统浏览器而设计的网页。

    区别：

    1.所有的标记都必须要有一个相应的结束标记

    2.所有标签的元素和属性的名字都必须使用小写

    3.所有的XML标记都必须合理嵌套

    4.所有的属性必须用引号""括起来

    5.把所有<和&特殊符号用编码表示

    6.给所有属性赋一个值

    7.不要在注释内容中使“--”

    8.图片必须有说明文字

浮动元素脱离文档流，不占据空间。浮动元素碰到包含它的边框或者浮动元素的边框停留。


1.使用空标签清除浮动。

   这种方法是在所有浮动标签后面添加一个空标签 定义css clear:both. 弊端就是增加了无意义标签。

2.使用overflow。

   给包含浮动元素的父标签添加css属性 overflow:auto; zoom:1; zoom:1用于兼容IE6。

3.使用after伪对象清除浮动。

   该方法只适用于非IE浏览器。具体写法可参照以下示例。使用中需注意以下几点。一、该方法中必须为需要清除浮动元素的伪对象中设置 height:0，否则该元素会比实际高出若干像素；

1.父元素的高度无法被撑开，影响与父元素同级的元素

2.与浮动元素同级的非浮动元素（内联元素）会跟随其后

3.若非第一个元素浮动，则该元素之前的元素也需要浮动，否则会影响页面显示的结构

      createDocumentFragment()    //创建一个DOM片段

      createElement()   //创建一个具体的元素

      createTextNode()   //创建一个文本节点

      appendChild()

      removeChild()

      replaceChild()

      insertBefore() //并没有insertAfter()

      document.querySelector()，document.querySelectorAll() //返回匹配该选择器的元素节点 空则返回null 但是，它们不支持CSS伪元素的选择器

      document.getElementsByTagName()    //通过标签名称 返回值是一个类似数组的HTMLCollection对象

      document.getElementsByClassName()   //返回值是一个类似数组的HTMLCollection对象

      document.getElementsByName()   //返回一个类似数组的的对象（NodeList对象的实例）

      getElementById()    //返回匹配指定id属性的元素节点，空则返回null 

      document.elementFromPoint()    //方法返回位于页面指定位置最上层的Element子节点

      Document节点（document节点是文档的根节点，每张网页都有自己的document节点）

      Element节点（Element对象对应网页的HTML标签元素）

      Text节点（Text节点代表Element节点和Attribute节点的文本内容）

      DocumentFragment节点（代表一个文档的片段，本身就是一个完整的DOM树形结构）

  HTML5 现在已经不是 SGML 的子集，主要是关于图像，位置，存储，多任务等功能的增加。

  拖拽释放(Drag and drop) API

  语义化更好的内容标签（header,nav,footer,aside,article,section）

  音频、视频API(audio,video)

  画布(Canvas) API

  地理(Geolocation) API

  本地离线存储 localStorage 长期存储数据，浏览器关闭后数据不丢失；

  sessionStorage 的数据在浏览器关闭后自动删除


  表单控件，calendar、date、time、email、url、search

  新的技术webworker, websocket, Geolocation

纯表现的元素：basefont，big，center，font, s，strike，tt，u；

对可用性产生负面影响的元素：frame，frameset，noframes；

  Web Socket 是 Web 应用程序的传输协议，它提供了双向的，按序到达的数据流。

  他是一个 HTML5 协议， WebSocket 的连接是持久的，他通过在客户端和服务器之间保持双工连接，

  服务器的更新可以被及时推送给客户端，而不需要客户端以一定时间间隔去轮询。

  Web Storage 是HTML5引入的一个非常重要的功能，可以在客户端本地存储数据。

  类似HTML4的cookie，但可实现功能要比cookie强大的多，cookie大小被限制在4KB，Web Storage官方建议为每个网站5MB。

  Web Storage又分为两种：sessionStorage、localStorage

  1、Web Storage 的概念和 cookie 相似，区别是它是为了更大容量存储设计的。 

  2、Cookie 的大小是受限的，并且每次你请求一个新的页面的时候 Cookie 都会被发送过去，
    
    这样无形中浪费了带宽，另外`cookie`还需要指定作用域，不可以跨域调用。

  3、除此之外，Web Storage 拥有 setItem,getItem,removeItem,clear 等方法，
    
    不像 cookie 需要前端开发者自己封装 setCookie，getCookie 。

  4、但是 cookie 也是不可以或缺的： cookie 的作用是与服务器进行交互，作为 
    
    HTTP 规范的一部分而存在 ，而 Web Storage 仅仅是为了在本地“存储”数据而生
    
    浏览器的支持除了`IE７`及以下不支持外，其他标准浏览器都完全支持(ie及FF需在

    web服务器里运行)，值得一提的是IE总是办好事，

  例如IE7、IE6中的 userData 其实就是 javascript 本地存储的解决方案。通过简单的代码封装可以统一到所有的浏览器都支持 web storage 。

  localStorage 和 sessionStorage 都具有相同的操作方法，例 setItem、getItem 和 removeItem 等

     1、cookie数据存放在客户的浏览器上，session数据放在服务器上。

     2、cookie不是很安全，别人可以分析存放在本地的COOKIE并进行COOKIE欺骗

        考虑到安全应当使用session。

     3、session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能

         考虑到减轻服务器性能方面，应当使用COOKIE。

     4、单个cookie保存的数据不能超过4K，很多浏览器都限制一个站点最多保存20个cookie。

     5、所以个人建议：

        将登陆信息等重要信息存放为SESSION

        其他信息如果需要保留，可以放在COOKIE中

    1.IE6或更低版本最多20个cookie

    2.IE7和之后的版本最后可以有50个cookie。

    3.Firefox最多50个cookie

    4.chrome和Safari没有做硬性限制

1.通过良好的编程，控制保存在cookie中的session对象的大小。

2.通过加密和安全传输技术（SSL），减少cookie被破解的可能性。

3.只在cookie中存放不敏感数据，即使被盗也不会有重大损失。

4.控制cookie的生命期，使之不会永远有效。偷盗者很可能拿到一个过期的cookie。

1.Cookie 数量和长度的限制。每个domain最多只能有20条cookie，每个cookie长度不能超过4KB，否则会被截掉.

2.安全性问题。如果cookie被人拦截了，那人就可以取得所有的session信息。即使加密也与事无补，因为拦截者并不需要知道cookie的意义，他只要原样转发cookie就可以达到目的了。

3.有些状态不可能保存在客户端。例如，为了防止重复提交表单，我们需要在服务器端保存一个计数器。如果我们把这个计数器保存在客户端，那么它起不到任何作用。

  验证用户的使用环境[浏览器和 IP 地址]。 
      
      分配给用户 Session ID 时，同时探明用户使用的浏览器和 IP 地址，作为验证依据，使非法用户不能进行 Session ID 欺骗。 
  

  正确处理 Session 变量。 
      
      当用户注销时，立即删除 Session ID 。并设置好 Session 的生存周期，过期就自动删除。 

  数值（number）

  字符串（string）

  布尔值（boolean）

  undefined

  null

  对象（object）

  Symbol (ES6新增)

  值类型：number、string、boolean、undefined、null

    typeof：number、string、boolean、undefined、function、object( {}、[]、null )

  引用类型：Array 、Object 、Function 、Date 、 RegExp 、 基本包装类型 (Boolean、Number、String)

  强制转换

    主要指使用Number、String和Boolean三个构造函数，手动将各种类型的值，转换成数字、字符串或者布尔值

  自动转换

    不同类型的数据互相运算  如：字符串拼接

    对非布尔值类型的数据求布尔值  如：if语句

    对非数值类型的数据使用一元运算符  如：逻辑运算

null 是一个表示"无"的对象，转为数值时为0； undefined 是一个表示"无"的原始值，转为数值时为 NaN 。

当声明的变量还未被初始化时，变量的默认值为 undefined 。

null 用来表示尚未存在的对象，常用来表示函数企图返回一个不存在的对象。



undefined 表示"缺少值"，就是此处应该有一个值，但是还没有定义。典型用法是：

  1.变量被声明了，但没有赋值时，就等于undefined。

  2.调用函数时，应该提供的参数没有提供，该参数等于undefined。

  3.对象没有赋值的属性，该属性的值为undefined。

  4.函数没有返回值时，默认返回undefined。



null 表示"没有对象"，即该处不应该有值。典型用法是：

  1.作为函数的参数，表示该函数的参数不是对象。

  2.作为对象原型链的终点。

    内存泄漏指任何对象在您不再拥有或需要它之后仍然存在。

    垃圾回收器定期扫描对象，并计算引用了每个对象的其他对象的数量。如果一个对象的引用数量为 

    0（没有其他对象引用过该对象），或对该对象的惟一引用是循环的，那么该对象的内存即可回收。

    setTimeout 的第一个参数使用字符串而非函数的话，会引发内存泄漏。

    闭包、控制台日志、循环（在两个对象彼此引用且彼此保留时，就会产生一个循环）

  这是JavaScript最常见的垃圾回收方式，当变量进入执行环境的时候，比如函数中声明一个变量，

  垃圾回收器将其标记为“进入环境”，当变量离开环境的时候（函数执行结束）将其标记为“离开环境”。

  垃圾回收器会在运行的时候给存储在内存中的所有变量加上标记，然后去掉环境中的变量以及被环境中变量

  所引用的变量（闭包），在这些完成之后仍存在标记的就是要删除的变量了

    在低版本IE中经常会出现内存泄露，很多时候就是因为其采用引用计数方式进行垃圾回收。

    引用计数的策略是跟踪记录每个值被使用的次数，当声明了一个 变量并将一个引用类型赋值

    给该变量的时候这个值的引用次数就加1，如果该变量的值变成了另外一个，则这个值得引用次数减1，

    当这个值的引用次数变为0的时 候，说明没有变量在使用，这个值没法被访问了，因此可以将其占用的空间回收，

    这样垃圾回收器会在运行的时候清理掉引用次数为0的值占用的空间。

在IE中虽然 JavaScript 对象通过标记清除的方式进行垃圾回收，

但BOM与DOM对象却是通过引用计数回收垃圾的，也就是说只要涉及`BOM`及DOM就会出现循环引用问题。

  在手持设备的浏览器上（此处主要指定IOS和Android系统上的Webkit内核的浏览器和嵌入在应用程序里面的Webview），

  由于两次连续的“轻触”是放大的操作（即使你两次轻触的是一个链接或一个有click的时间监听的元素），所以在第一次被

  “轻触”后，浏览器需要先等一段时间，看看有没有所谓的“连续第二次轻触”。如果有，则进行“放大”操作。否则，才敢放心

  地认为用户不是要放大，而是需要“click”，至此才敢触发click事件，导致“短按”（手指接触屏幕到离开屏幕的时间比较短）

  的click时间通常大约会延迟300ms。
  
  在移动平台浏览器中事件的触发顺序，是 touchstart-touchmove-touchend-click

    1.工厂模式

    2.构造函数模式

    3.原型模式

    4.混合构造函数和原型模式

    5.动态原型模式

    6.寄生构造函数模式

    7.稳妥构造函数模式

    1.原型链继承

    2.借用构造函数继承

    3.组合继承(原型+借用构造)

    4.原型式继承

    5.寄生式继承

    6.寄生组合式继承

主要好处就是可以消除对象间的耦合，通过使用工程方法而不是new关键字。将所有实例化的代码集中在一个位置防止代码重复。

    工厂模式解决了重复实例化的问题 ，但还有一个问题,那就是识别问题，因为根本无法 搞清楚他们到底是哪个对象的实例。

    使用构造函数的方法 ，即解决了重复实例化的问题 ，又解决了对象识别的问题，该模式与工厂模式的不同之处在于：

    1.构造函数方法没有显示的创建对象 (new Object());

    2.直接将属性和方法赋值给 this 对象;

    3.没有 renturn 语句。

    4.函数名是大写字母P开头，表示构造函数 //借鉴其他OO语言

    一是字面量重写原型会中断关系，使用引用类型的原型，并且子类型还无法给超类型传递参数。

    借用构造函数虽然解决了刚才两种问题，但没有原型，则复用无从谈起。所以我们需要原型链+借用构造函数的模式，这种模式称为组合继承

    组合式继承是比较常用的一种继承方法，其背后的思路是 使用原型链实现对原型属性和方法的继承，而通过借用构造函数来实现对实例属性的继承。这样，既通过在原型上定义方法实现了函数复用，又保证每个实例都有它自己的属性。

   使用闭包主要是为了设计私有的方法和变量。闭包的优点是可以避免全局变量的污染，缺点是闭包会常驻内存，

   会增大内存使用量，使用不当很容易造成内存泄露。在js中，函数即闭包，只有函数才会产生作用域的概念

    1.函数嵌套函数

    2.函数内部可以引用外部的参数和变量

    3.参数和变量不会被垃圾回收机制回收

异步操作“未完成”（pending）

异步操作“已完成”（resolved，又称fulfilled）

异步操作“失败”（rejected）

异步操作从“未完成”到“已完成”

异步操作从“未完成”到“失败”。

defer和async、动态创建DOM方式（创建script，插入到DOM中，加载完毕后callBack）、按需异步载入js

    变量必须声明后再使用

    函数的参数不能有同名属性，否则报错

    不能使用with语句

    不能对只读属性赋值，否则报错

    对一个只设置了赋值器（getter）的属性赋值，会报错

    不能使用前缀0表示八进制数，否则报错

    不能删除不可删除的属性，否则报错

    不能删除变量delete prop，会报错，只能删除属性delete global[prop]

    eval不会在它的外层作用域引入变量

    eval和arguments不能被重新赋值

    arguments不会自动反映函数参数的变化

    不能使用arguments.callee

    不能使用arguments.caller

    禁止this指向全局对象，会指向undefined

    不能使用fn.caller和fn.arguments获取函数调用的堆栈

    增加了保留字（比如protected、static和interface）

    1.消除 Javascript 语法的一些不合理、不严谨之处，减少一些怪异行为;

    2.消除代码运行的一些不安全之处，保证代码运行的安全；

    3.提高编译器效率，增加运行速度；

    4.为未来新版本的 Javascript 做好铺垫。

    1、ajax不支持浏览器back按钮。

    2、安全问题 AJAX暴露了与服务器交互的细节。

    3、对搜索引擎的支持比较弱。

    4、破坏了程序的异常机制。

    5、不容易调试。

    在IE浏览器下，如果请求的方法是 GET ，并且请求的 URL 不变，那么这个请求的结果就会被缓存。

    解决这个问题的办法可以通过实时改变请求的 URL ，只要 URL 改变，就不会被缓存，可以通过在 URL

    末尾添加上随机的时间戳参数('t'= + new Date().getTime())

open('GET','demo.php?rand=+Math.random()',true);//

    可以通过锚点来记录状态，`location.hash`。让浏览器记录Ajax请求时页面状态的变化。

    还可以通过`HTML5`的`history.pushState`，来实现浏览器地址栏的无刷新改变

    1.异步加载的方案： 动态插入script标签

    2.通过ajax去获取js代码，然后通过eval执行

    3.script标签上添加defer或者async属性

    4.创建并插入iframe，让它异步执行js

    5.延迟加载：有些 js 代码并不是页面初始化的时候就立刻需要的，而稍后的某些情况才需要的。

    Flash 适合处理多媒体、矢量图形、访问机器；对 CSS 、处理文本上不足，不容易被搜索。

    Ajax 对 CSS 、文本支持很好，支持搜索；多媒体、矢量图形、机器访问不足。

    共同点：与服务器的无刷新传递消息、用户离线和在线状态、操作DOM

    概念:同源策略是客户端脚本（尤其是 Javascript ）的重要的安全度量标准。它最早出自 Netscape Navigator2.0 ，其目的是防止某个文档或脚本从多个不同源装载 


    这里的同源策略指的是：协议，域名，端口相同，同源策略是一种安全协议。

    指一段脚本只能读取来自同一来源的窗口和文档的属性。

   我们举例说明：比如一个黑客程序，他利用 Iframe 把真正的银行登录页面嵌到他的页面上，

   当你使用真实的用户名，密码登录时，他的页面就可以通过 Javascript 

   读取到你的表单中 input 中的内容，这样用户名，密码就轻松到手了。

    现在网站的 JS  都会进行压缩，一些文件用了严格模式，而另一些没有。

    这时这些本来是严格模式的文件，被 merge 后，这个串就到了文件的中间，

    不仅没有指示严格模式，反而在压缩后浪费了字节。

    Commet：基于HTTP长连接的服务器推送技术
      
    基于 WebSocket 的推送方案
      
    SSE （Server-Send Event）：服务器推送数据新方式

    jquery 源码封装在一个匿名函数的自执行环境中，有助于防止变量的全局污染，

    然后通过传入window对象参数，可以使 window 对象作为局部变量使用，好处是当 jquery 

    中访问window对象的时候，就不用将作用域链退回到顶层作用域了，从而可以更快的访问 window 对象。

    同样，传入 undefined 参数，可以缩短查找undefined时的作用域链。

    物理层：通过媒介传输比特,确定机械及电气规范（比特Bit）
    
    数据链路层：将比特组装成帧和点到点的传递（帧Frame）
    
    网络层：负责数据包从源到宿的传递和网际互连（包PackeT）
    
    传输层：提供端到端的可靠报文传递和错误恢复（段Segment）
    
    会话层：建立、管理和终止会话（会话协议数据单元SPDU）
    
    表示层：对数据进行翻译、加密和压缩（表示协议数据单元PPDU）
    
    应用层：允许访问OSI环境的手段（应用协议数据单元APDU）

    ICMP协议： （Internet Control Message Protocol）因特网控制报文协议
              它是TCP/IP协议族的一个子协议，用于在IP主机、路由器之间传递控制消息。
    
    TFTP协议： （Trivial File Transfer Protocol）简单文件传输协议 
              是TCP/IP协议族中的一个用来在客户机与服务器之间进行简单文件传输的协议，提供不复杂、开销不大的文件传输服务。
    
    HTTP协议：  (HyperText Transfer Protocol) 超文本传输协议
              是一个属于应用层的面向对象的协议，由于其简捷、快速的方式，适用于分布式超媒体信息系统。
    
    DHCP协议： （Dynamic Host Configuration Protocol）动态主机配置协议
              是一种让系统得以连接到网络上，并获取所需要的配置参数手段。

    1.POST是向服务器传递数据；GET是从服务器上获取数据。

    2.POST是通过HTTP POST机制将表单内各个字段及其内容放置在html header内一起传送到action属性所指的url地址。

      用户看不到这个过程；GET是把参数数据队列加到提交表单action属性所指的url中，值和表单内各个字段一一对应，在url中可以看到。
    
    3.对于GET方式，服务器端用Request.QueryString获取变量的值；对于POST方式，服务器端用Request.Form获取提交数据。
    
    4.POST传送的数据量较大，一般默认为不受限制。但理论上，IIS4中最大量为80KB，IIS5中为100KB；GET传递的数据量较小，不能大于2KB。
    
    5.POST安全性较高；GET安全性非常低，但是执行效率却比POST方法好。
    
    6.在做数据添加、修改或删除时，建议用POST方式；而在做数据查询时，建议用GET方式。
    
    7.对于机密信息的数、发送包含未知字符的用户输入时，建议采用POST数据提交方式。

  Cache-control

  Expires

  Age

  Vary
  
  Etag

    HTTP 协议通常承载于TCP协议之上，在 HTTP 和 TCP 之间添加一个安全协议层（ SSL 或 TSL ），这个时候，就成了我们常说的HTTPS。

    默认HTTP的端口号为80， HTTPS 的端口号为443。

  因为网络请求需要中间有很多的服务器路由器的转发。中间的节点都可能篡改信息，而如果使用 HTTPS ，

  密钥在你和终点站才有。 https 之所以比 http 安全，是因为他利用 ssl/tls 协议传输。

  它包含证书，卸载，流量转发，负载均衡，页面适配，浏览器适配，refer传递等。保障了传输过程的安全性

    为了准确无误地把数据送达目标处， TCP 协议采用了三次握手策略。用TCP协议把数据包送出去后， TCP 不会对传送

    后的情况置之不理，它一定会向对方确认是否成功送达。握手过程中使用了TCP的标志： SYN 和 ACK 。

    发送端首先发送一个带 SYN 标志的数据包给对方。接收端收到后，回传一个带有 SYN/ACK 标志的数据包以示传达确认信息。
    
    最后，发送端再回传一个带 ACK 标志的数据包，代表“握手”结束。
    
    若在握手过程中某个阶段莫名中断， TCP 协议会再次以相同的顺序发送相同的数据包。

    第一次挥手：主动关闭方发送一个 FIN ，用来关闭主动方到被动关闭方的数据传送，也就是主动关闭方告诉被动关闭方：

              我已经不会再给你发数据了(当然，在fin包之前发送出去的数据，如果没有收到对应的ack确认报文，主动关闭方依然会重发这些数据)，

              但是，此时主动关闭方还可 以接受数据。

    第二次挥手：被动关闭方收到 FIN 包后，发送一个 ACK 给对方，确认序号为收到序号 +1 （与 SYN 相同，一个 FIN 占用一个序号）。

    第三次挥手：被动关闭方发送一个 FIN ，用来关闭被动关闭方到主动关闭方的数据传送，也就是告诉主动关闭方，我的数据也发送完了，不会再给你发数据了。

    第四次挥手：主动关闭方收到 FIN 后，发送一个 ACK 给被动关闭方，确认序号为收到序号+1，至此，完成四次挥手。

    在只有两次“握手”的情形下，假设Client想跟Server建立连接，但是却因为中途连接请求的数据报丢失了，

    故Client端不得不重新发送一遍；这个时候Server端仅收到一个连接请求，因此可以正常的建立连接。

    但是，有时候Client端重新发送请求不是因为数据报丢失了，而是有可能数据传输过程因为网络并发量很大在

    某结点被阻塞了，这种情形下Server端将先后收到2次请求，并持续等待两个Client请求向他发送数据...问题就在这里，

    Cient端实际上只有一次请求，而Server端却有2个响应，极端的情况可能由于Client端多次重新发送请求数据而导致

    Server端最后建立了N多个响应在等待，因而造成极大的资源浪费！所以，“三次握手”很有必要！

    试想一下，假如现在你是客户端你想断开跟Server的所有连接该怎么做？第一步，你自己先停止向Server端发送数据，

    并等待Server的回复。但事情还没有完，虽然你自身不往Server发送数据了，但是因为你们之前已经建立好平等的连接了，

    所以此时他也有主动权向你发送数据；故Server端还得终止主动向你发送数据，并等待你的确认。其实，说白了就是保证双方的一个合约的完整执行！

　　使用TCP的协议：FTP（文件传输协议）、Telnet（远程登录协议）、SMTP（简单邮件传输协议）、POP3（和SMTP相对，用于接收邮件）、HTTP协议等。

  TCP（Transmission Control Protocol，传输控制协议）是基于连接的协议，也就是说，在正式收发数据前，必须和对方建立可靠的连接。

  一个 TCP 连接必须要经过三次“对话”才能建立起来

  UDP（User Data Protocol，用户数据报协议）是与TCP相对应的协议。它是面向非连接的协议，它不与对方建立连接，而是直接就把数据包发送过去！

  UDP适用于一次只传送少量数据、对可靠性要求不高的应用环境。

    浏览器的并发请求数目限制是针对同一域名的，同一时间针对同一域名下的请求有一定数量限制，超过限制数目的请求会被阻塞。

  独立的域名方便我们在代理服务层做动静分离，以便提升静态请求的处理速度。

  原因如下：

      浏览器并发请求数的限制

      网络请求时cookie传输

      方便分流或缓存

  分为4个步骤：

  （1). 当发送一个URL请求时，不管这个URL是Web页面的URL还是Web页面上每个资源的URL，浏览器都会开启一个线程来

          处理这个请求，同时在远程DNS服务器上启动一个DNS查询。这能使浏览器获得请求对应的IP地址。


  （2). 浏览器与远程 Web 服务器通过 TCP 三次握手协商来建立一个 TCP/IP 连接。该握手包括一个同步报文，
          
          一个同步-应答报文和一个应答报文，这三个报文在 浏览器和服务器之间传递。该握手首先由客户端尝试建立起通信，而后服务器

          应答并接受客户端的请求，最后由客户端发出该请求已经被接受的报文。


  （3). 一旦 TCP/IP 连接建立，浏览器会通过该连接向远程服务器发送 HTTP 的 GET 请求。远程服务器找到资源并使用HTTP

          响应返回该资源，值为200的HTTP响应状态表示一个正确的响应。


  （4). 此时， Web 服务器提供资源服务，客户端开始下载资源。



  请求返回后，便进入了我们关注的前端模块

  简单来说，浏览器会解析 HTML 生成 DOM Tree ，其次会根据CSS生成CSS Rule Tree，而 javascript 又可以根据 DOM API 操作 DOM 

    当发送一个服务器请求时，浏览器首先会进行缓存过期判断。浏览器根据缓存过期时间判断缓存文件是否过期。

    情景一：若没有过期，则不向服务器发送请求，直接使用缓存中的结果，此时我们在浏览器控制台中可以看到  200 OK (from cache) ，

    此时的情况就是完全使用缓存，浏览器和服务器没有任何交互的。


    情景二：若已过期，则向服务器发送请求，此时请求中会带上①中设置的文件修改时间，和 Etag 


    然后，进行资源更新判断。服务器根据浏览器传过来的文件修改时间，判断自浏览器上一次请求之后，文件是不是没有被修改过；

    根据 Etag ，判断文件内容自上一次请求之后，有没有发生变化



    情形一：若两种判断的结论都是文件没有被修改过，则服务器就不给浏览器发 index.html 的内容了，直接告诉它，文件没有被修改过，你用你那边的缓存吧—— 304 Not Modified，此时浏览器就会从本地缓存中获取 index.html 的内容。此时的情况叫协议缓存，浏览器和服务器之间有一次请求交互。<br>

    情形二：若修改时间和文件内容判断有任意一个没有通过，则服务器会受理此次请求，之后的操作同①


    ① 只有get请求会被缓存，post请求不会

  Expires 要求客户端和服务端的时钟严格同步。 HTTP1.1 引入 Cache-Control 来克服Expires头的限制。

  如果max-age和Expires同时出现，则max-age有更高的优先级。

  Etag 由服务器端生成，客户端通过 If-Match 或者说 If-None-Match 这个条件判断请求来验证资源是否修改。

  常见的是使用 If-None-Match 。请求一个文件的流程可能如下：


  ====第一次请求===

    1.客户端发起 HTTP GET 请求一个文件；

    2.服务器处理请求，返回文件内容和一堆Header，当然包括Etag(例如"2e681a-6-5d044840")(假设服务器支持Etag生成和已经开启了Etag).状态码200



  ====第二次请求===

    客户端发起 HTTP GET 请求一个文件，注意这个时候客户端同时发送一个If-None-Match头，这个头的内容就是第一次请求时服务器返回的Etag：2e681a-6-5d0448402 （hash值）

    服务器判断发送过来的Etag和计算出来的Etag匹配，因此If-None-Match为False，不返回200，返回304，客户端继续使用本地缓存；

    流程很简单，问题是，如果服务器又设置了Cache-Control:max-age和Expires呢，怎么办


    答案是同时使用，也就是说在完全匹配 If-Modified-Since 和 If-None-Match 即检查完修改时间和 Etag 之后，

    服务器才能返回304.(不要陷入到底使用谁的问题怪圈)

  Etag 主要为了解决  Last-Modified  无法解决的一些问题。

  原理是：动态插入 script 标签，通过 script 标签引入一个 js 文件，这个js文件

  载入成功后会执行我们在url参数中指定的函数，并且会把我们需要的 json 数据作为参数传入。



  由于同源策略的限制， XmlHttpRequest 只允许请求当前源（域名、协议、端口）的资源，

  为了实现跨域请求，可以通过 script 标签实现跨域请求，然后在服务端输出JSON数据并执行回调函数，从而解决了跨域的数据请求。


  优点是兼容性好，简单易用，支持浏览器与服务器双向通信。缺点是只支持GET请求。

  JSONP：json+padding（内填充），顾名思义，就是把JSON填充到一个盒子里

  服务器端对于 CORS 的支持，主要就是通过设置 Access-Control-Allow-Origin 来进行的。

  如果浏览器检测到相应的设置，就可以允许 Ajax 进行跨域的访问。

  将子域和主域的 document.domain 设为同一个主域.前提条件：这两个域名必须属于同一个基础域名!

  而且所用的协议，端口都要一致，否则无法利用 document.domain 进行跨域

  主域相同的使用 document.domain 

  window 对象有个 name 属性，该属性有个特征：即在一个窗口(window)的生命周期内,窗口载入的

  所有的页面都是共享一个 window.name 的，每个页面对 window.name 都有读写的权限， window.name 是

  持久存在一个窗口载入过的所有页面中的

  还有flash、在服务器上设置代理页面等跨域方式。个人认为 window.name 的方法既不复杂，

  也能兼容到几乎所有浏览器，这真是极好的一种跨域方法。

    当浏览器向服务器发送URL请求，服务器会生成一个会话ID，并将浏览器端的一些信息保存在服务器端，

    然后将会话ID送到浏览器端保存到cookie里，当浏览器再次向服务器发送请求时会将cookie里的会话ID

    一并发送给服务器，服务器会将接收到的会话ID和服务器里的ID比较，如果相同服务器就认定是一次会话，

    就可以找到本次会话中保存的信息。

  数据结构和算法贯穿于编程的每个角落，前端开发也不例外。虽然我们的工作集中在界面交互上，数据结构和算法的使用场景看似不多，

      其实不知不觉我们在使用

  HTML文档本身就是一个棵树，DOM定义了操作这棵树的标准接口，jQuery在标准的DOM API的基础上提供了更好用的接口操作DOM

  JavaScript的Object本身就是一个hashmap

  JSON的数据的序列化和反序列化设计字符串处理的相关算法
  
  前端模版引擎宋昌会利用一些词法分析算法去完成模版的解析和渲染

  Facebook的React在渲染DOM过程中就采用了Diff算法

  数据图表类应用会涉及多种数据算法的应用

  浏览器底层综合利用了多种数据结构和算法才将我们产出的HTML，CSS绘制成用户可见的页面

  判断一个JSON结构是否非法时很简单的，捕捉JSON.parse的异常即可。但要知道index，需要有类似语法分析的流程

  时间开销

    排序的时间开销可用算法执行中的数据比较次数与数据移动次数来衡量。 
    
    算法运行时间代价的大略估算一般都按平均情况进行估算。对于那些受对象排序码序列初始排列及对象个数影响较大的，需要按最好情况和最坏情况进行估算

  空间开销

    算法执行时所需的附加存储。

  顺序表的特点是逻辑上相邻的数据元素，物理存储位置也相邻，并且，顺序表的存储空间需要预先分配。
  
  优点：
      
      方法简单，各种高级语言中都有数组，容易实现。

      不用为表示节点间的逻辑关系而增加额外的存储开销。

      顺序表具有按元素序号随机访问的特点。
  
  缺点：
      
      在顺序表中做插入、删除操作时，平均移动表中的一半元素，因此对n较大的顺序表效率低。

      需要预先分配足够大的存储空间，估计过大，可能会导致顺序表后部大量闲置；预先分配过小，又会造成溢出。



  在链表中逻辑上相邻的数据元素，物理存储位置不一定相邻，它使用指针实现元素之间的逻辑关系。并且，链表的存储空间是动态分配的。

  优点：

      比顺序存储结构的存储密度小(链式存储结构中每个结点都由数据域与指针域两部分组成，相比顺序存储结构增加了存储空间)。

      逻辑上相邻的节点物理上不必相邻。

      插入、删除灵活 (不必移动节点，只要改变节点中的指针)。

      每个结点是由数据域和指针域组成。

  缺点：

      要占用额外的存储空间存储元素之间的关系，存储密度降低。存储密度是指一个节点中数据元素所占的存储单元和整个节点所占的存储单元之比。

      链表不是一种随机存储结构，不能随机存取元素。

      查找结点时链式存储要比顺序存储慢。

    顺序表的存储空间是静态分配的，在程序执行之前必须明确规定它的存储规模，也就是说事先对“MaxSize”要有合适的设定，

    设定过大会造成存储空间的浪费，过小造成溢出。因此，当对线性表的长度或存储规模难以估计时，不宜采用顺序表。

    然而，链表的动态分配则可以克服这个缺点。链表不需要预留存储空间，也不需要知道表长如何变化，只要内存空间尚有空闲，

    就可以再程序运行时随时地动态分配空间，不需要时还可以动态回收。

    因此，当线性表的长度变化较大或者难以估计其存储规模时，宜采用动态链表作为存储结构。

    当线性表的长度变化不大而且事先容易确定其大小时，为节省存储空间，则采用顺序表作为存储结构比较适宜。


  
  基于运算的考虑（时间）

    顺序存储是一种随机存取的结构，而链表则是一种顺序存取结构，因此它们对各种操作有完全不同的算法和时间复杂度。

    例如，要查找线性表中的第i个元素，对于顺序表可以直接计算出a(i)的的地址，不用去查找，其时间复杂度为0(1).

    而链表必须从链表头开始，依次向后查找，平均需要0(n)的时间。所以，如果经常做的运算是按序号访问数据元素，显然顺表优于链表。

    反之，在顺序表中做插入，删除时平均移动表中一半的元素，当数据元素的信息量较大而且表比较长时，这一点是不应忽视的；

    在链表中作插入、删除，虽然要找插入位置，但操作是比较操作，从这个角度考虑显然后者优于前者。

  

  基于环境的考虑（语言）

    顺序表容易实现，任何高级语言中都有数组类型；链表的操作是基于指针的。相对来讲前者简单些，也用户考虑的一个因素。

    总之，两种存储结构各有长短，选择哪一种由实际问题中的主要因素决定。通常“较稳定”的线性表，即主要操作是查找操作的线性表，

    适于选择顺序存储；而频繁做插入删除运算的（即动态性比较强）的线性表适宜选择链式存储。

    栈的插入和删除操作都是在一端进行的，而队列的操作却是在两端进行的。

    队列先进先出，栈后进先出。

    栈只允许在表尾一端进行插入和删除，而队列只允许在表尾一端进行插入，在表头一端进行删除

    栈区（stack）：由编译器自动分配释放，存放函数的参数值，局部变量的值等。

    堆区（heap） ：一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。

    堆（数据结构）：堆可以被看成是一棵树，如：堆排序；

    栈（数据结构）：一种后进先出的数据结构。

  JavaScript提供了6个方法用于正则表达式，其中2个是正则对戏那个的方法，4个是字符串对象方法。

  JavaScript端到端：可以用JavaScript同时编写服务器端和客户端脚本。

  事件驱动的可扩展性：Node.js应用时间模型在同一个线程上来处理Web请求。

  可扩展性：Node.js追随者多、社区活跃、安装新模块简单

  快速执行：建立Node.js，并在其中开发时超级容易的。

  以下方式可以避免回调地狱:

    模块化: 将回调函数转换为独立的函数

    使用流程控制库，例如aync

    使用Promise

    使用aync/await

  Node.js中的require(id)执行分3种情况：引入内建模块、引入文件模块、引入一个包。

  通过id可以分析得到该模块是一个内建模块、文件模块还是包

  若是内建模块时，直接从内存中加载

  
  当id是相对路径或绝对路径时，模块被认为是一个文件模块，通过文件查找可以定位到文件的路径。


  当id既不是内建模块也不是文件模块时，则被认为是一个包。这个包可能通过npm安装的第三方模块。

  包的加载方式为，从当前路径下寻找node_modeules目录中是否存在该包。如果没有，想上一级目录进行查找，

  知道根目录下的node_modules。这个规则可以通过module.paths得到。


  寻找到包后，UI中啊到爆的描述文件pageage.json，该文件的main字段表明了这个包的入口文件，

  此时再按文件的方式找到对应文件即可。

  （目前自动加载扩展名可省略类型.js、.json、.node）

  .node文件在不同的平台下内容不同，在Windows下其实是.dll文件，其他平台下是.so文件

  Node.js中推崇非阻塞I/O,但是require一个模块时确实同步调用的，这会带来性能上的开销，但并不是每次require都很耗时

  因为在require成功之后会缓存起来，再次加载时直接从缓存读取，并没有额外开销。

  当通过.json的方式加载文件时固然方便，但大量使用时会导致这些数据被缓存，大量数据驻留在内存中，导致GC频繁和内存泄露。

  Node.js的异步I/O通过时间循环的方式实现。其中异步I/O又分磁盘I/O和网络I/O。

  在磁盘I/O的调用中，当发起异步调用后，会将异步操作送进libuv提供的队列中，然后返回。

  在磁盘I/O执行完成之后，会形成一个事件，事件循环的过程总发现该事件后，会将其消费。

  消费过程就是将得到的数据和传入的回调函数执行。

  
  网络I/O与磁盘I/O的差异在于他不需要线程池来进行处理，而是在每次事件循环的过程中通过

  IOCP/epoll/kqueue/event ports来获取网络的I/O的事件队列。

  Node的子进程模块为child_process，类似操作系统的API，但又有所不同。

  子进程模块有exec、execFile、fork、spawn4个异步方法和execSync、execFileSync、spawnSync3个同步调用方法。

  child_process模块与操作系统底层API的区别在于它并不是用来spawn和fork当前进程的，

  通过这些API创建出来的子进程与父进程之间没有任何必然的关系。

  当创建出来的子进程也是一个node进程时，可以在两个进程之间通信。Node内建了IPC机制，暴露的API为child.send()和process.on('message')。

  其内部机制在不同的平台下有不同的实现，UNIX下为Domain Socket，Windows为Named Pipe。
    

    PHP为例:
    function writeData($filepath, $data) 
    { 
        $fp = fopen($filepath,'a');  

        do{ 
            usleep(100); //微秒
        }while (!flock($fp, LOCK_EX)); //取得独占锁定 
        
        $res = fwrite($fp, $data."\n"); 

        flock($fp, LOCK_UN); //释放锁定
        
        fclose($fp);  
        
        return $res; 
    } 
  

  Node的 cluster 模块用于解决Node单进程无法充分利用操作系统多核CPU的问题。另外，通过master-cluster模式，

  也可以使得Node应用的健壮性能得到保障。

  Cluster的底层是child_process模块，Node进程间通信除了可以发送普通的消息外，还约定能够发送底层对象，包括TCP、UCP等。

  当一个TCP链接从主进程发送到子进程后，子进程能够根据消息重建出TCP连接，这样 Cluster 可以决定fork出适合硬件资源的

  子进程数。这些子进程能够通过IPC的机制分享对同一个端口的侦听，另外，通过对进程间通信管道的处理，可以自动完成进程退出重启等

  Buffer.concat(list[, totalLength]);

  list <Array> List of Buffer objects to concat

  totalLength <Number> Total length of the Buffers in the list when concatenated
  
  Return: <Buffer>
  

    新增模板字符串（为JavaScript提供了简单的字符串插值功能）

    箭头函数（操作符左边为输入的参数，而右边则是进行的操作以及返回的值 Inputs=>outputs ） 

    for-of （用来遍历数据—例如数组中的值。）

    arguments 对象可被不定参数和默认参数完美代替。 

    ES6 将 Promise 对象纳入规范，提供了原生的 Promise 对象。

    增加了 let 和 const 命令，用来声明变量。增加了块级作用域。let命令实际上就增加了块级作用域。

    ES6规定， var 命令和 function 命令声明的全局变量，属于全局对象的属性； 

    let 命令、 const 命令、 class 命令声明的全局变量，不属于全局对象的属性

    还有就是引入 module 模块的概念

  两个重大差异

  第一个差异
      CommonJS 模块输出的是一个值的拷贝，ES6 模块输出的是值的引用

      CommonJS 模块是运行时加载，ES6 模块是编译时输出接口


  第二个差异
      CommonJS 加载的是一个对象（即module.exports属性），该对象只有在脚本运行完才会生成

      ES6 模块不是对象，它的对外接口只是一种静态定义，在代码静态解析阶段就会生成

  前端框架解决Web应用开发中两个关键问题：

  如何写高可复用，易维护的前端组件

  如何管理前端应用中的数据

  框架： jQuery、Angular、React、VUE、

  jQuery组件开发需要通过封装类似原生DOM的API，而React可以关注于抽象的组件封装，组件包含了数据初始化、组件渲染、组件挂载等关键的钩子

  jQuery是通过手动定位来实现组件的改变的，代码是命令式的。React通过声明一个方法来表示如何根据数据渲染HTML。代码是声明式的。

  jQuery的组件无法很好的解决嵌套问题。React组件的全部DOM操作、生命周期都由框架一并控制，已由框架解决组件的嵌套问题。

  理论知识
    
    计算机图形图像：图形学、图像处理

    数学：高等数学、线性代数、数值计算

    统计分析：数据处理、统计学

    可视理论：数据可视化基本原理和方法

    交互理论：认知心理学

  工程实践
    计算机编程：JavaScript编程基础、Web技能Canvas、SVG、WebGL

对于传统的网站来说重构通常是：

表格(table)布局改为DIV+CSS

使网站前端兼容于现代浏览器(针对于不合规范的CSS、如对IE6有效的)

对于移动平台的优化

针对于SEO进行优化

深层次的网站重构应该考虑的方面


减少代码间的耦合

让代码保持弹性

严格按规范编写代码

设计可扩展的API

代替旧有的框架、语言(如VB)

增强用户体验

通常来说对于速度的优化也包含在重构中



压缩JS、CSS、image等前端资源(通常是由服务器来解决)

程序的性能优化(如数据读写)

采用CDN来加速资源加载

对于JS DOM的优化

HTTP服务器的文件缓存

    用 hash-table 来优化查找

    少用全局变量

    用 innerHTML 代替 DOM 操作，减少 DOM 操作次数，优化 javascript 性能

    用 setTimeout 来避免页面失去响应

    缓存DOM节点查找的结果

    避免使用CSS Expression

    避免全局查询

    避免使用with(with会创建自己的作用域，会增加作用域链长度)

    多个变量声明合并

    避免图片和iFrame等的空Src。空Src会重新加载当前页面，影响速度和效率

    尽量避免写在HTML标签中写Style属性

  广义的前端工程是一个系统工程，狭义的前端工程是前端开发流程的一部分。

  前端工程包含许多方面：有以下内容：

  1.代码规范：保证团队所有成员以同样的规范开发代码

  2.分支管理：不同工程师开发如那件的不同功能或组件，按照统一的流程合并进主干

  3.模块管理：一方面，团队引用的模块应该是规范的；另一方面，必须保证这些模块可以正确得加入最终的编译好的软件包

  4.自动化测试：为了保证合并进主干的代码达到质量标准，不会让软件挂掉，必须要有测试，而且测试应试自动化的，可以回归。

  5.构建：主干更新以后，自动将代码编译为最终的目标格式，并且准备好各种静态资源

  6.部署：将构建好的代码部署到生产环境

  静态检查指在不运行代码的前提下，仅仅根据代码的静态解析发现错误的做法。也就是说，静态检查时编译时的检查，而不是运行时的检查。

  常见的检查工具如下：

  测试金字塔反映了需要写的单元测试、集成测试以及端到端测试的比例:

  测试HTTP接口时应该是这样的:

  很多单元测试，分别测试各个模块(依赖需要stub)

  较少的集成测试，测试各个模块之间的交互(依赖不能stub)
  
  少量端到端测试，去调用真正地接口(依赖不能stub)

  WebPack 是一个模块打包工具，你可以使用 WebPack 管理你的模块依赖，并编绎输出模块们所需的静态文件。

  它能够很好地管理、打包Web开发中所用到的 HTML、Javascript、CSS 以及各种静态文件（图片、字体等），

  让开发过程更加高效。对于不同类型的资源， webpack 有对应的模块加载器。 webpack 模块打包器会分析模块间的依赖关系，

  最后 生成了优化且合并后的静态资源。

    1.code splitting（可以自动完成）

    2.loader 可以处理各种类型的静态文件，并且支持串联操作

    1. 对 CommonJS 、 AMD 、ES6的语法做了兼容

    2. 对js、css、图片等资源文件都支持打包

    3. 串联式模块加载器以及插件机制，让其具有更好的灵活性和扩展性，例如提供对CoffeeScript、ES6的支持

    4. 有独立的配置文件webpack.config.js

    5. 可以将代码切割成不同的chunk，实现按需加载，降低了初始化时间

    6. 支持 SourceUrls 和 SourceMaps，易于调试

    7. 具有强大的Plugin接口，大多是内部插件，使用起来比较灵活

    8.webpack 使用异步 IO 并具有多级缓存。这使得 webpack 很快且在增量编译上更加快

  Web安全主要分为客户端脚本安全和服务器端应用安全。

  客户端脚本安全主要包括浏览器安全、跨站脚本攻击(XSS)、跨站点请求伪造(CSRF)、点击劫持(ClickJacking)、HTML5安全；


  服务端安全主要包括

  注入攻击：SQL注入、XML注入、代码注入、CRLF注入等
  
  文件上传漏洞：如FCKEditor上传、绕过文件上传检查功能；
  
  PHP安全：一般会和文件含漏洞、变量覆盖漏洞、代码执行漏洞；

  认证与会话管理、访问控制、加密算法与随机数、Web框架安全、应用层拒绝服务攻击、Web Server配置安全等

  浏览器端主要涉及：同源策略、沙箱等

  就是通过把SQL命令插入到Web表单递交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令。

  总的来说有以下几点：

    1.永远不要信任用户的输入，要对用户的输入进行校验，可以通过正则表达式，或限制长度，对单引号和双"-"进行转换等。

    2.永远不要使用动态拼装SQL，可以使用参数化的SQL或者直接使用存储过程进行数据查询存取。

    3.永远不要使用管理员权限的数据库连接，为每个应用使用单独的权限有限的数据库连接。

    4.不要把机密信息明文存放，请加密或者hash掉密码和敏感的信息。

    Xss(cross-site scripting)攻击指的是攻击者往Web页面里插入恶意  html 标签或者 javascript 代码。比如：攻击者在论坛中放一个

    看似安全的链接，骗取用户点击后，窃取 cookie 中的用户私密信息；或者攻击者在论坛中加一个恶意表单，

    当用户提交表单的时候，却把信息传送到攻击者的服务器中，而不是用户原本以为的信任站点。

    首先代码里对用户输入的地方和变量都需要仔细检查长度和对`”<”,”>”,”;”,”’”`等字符做过滤；

    其次任何内容写到页面之前都必须加以 encode ，避免不小心把 html tag  弄出来。这一个层面做好，至少可以堵住超过一半的 XSS  攻击。

    首先，避免直接在 cookie  中泄露用户隐私，例如email、密码等等。

    其次，通过使 cookie  和系统 ip 绑定来降低 cookie  泄露后的危险。这样攻击者得到的 cookie  没有实际价值，不可能拿来重放。

    如果网站不需要再浏览器端对 cookie  进行操作，可以在 Set-Cookie  末尾加上 HttpOnly  来防止 javascript  代码直接获取 cookie  。


    尽量采用 POST 而非 GET 提交表单

    XSS是获取信息，不需要提前知道其他用户页面的代码和数据包。CSRF是代替用户完成指定的动作，需要知道其他用户页面的代码和数据包。

    要完成一次 CSRF 攻击，受害者必须依次完成两个步骤：

    登录受信任网站A，并在本地生成Cookie。

    在不登出A的情况下，访问危险网站B。

    服务端的 CSRF 方式方法很多样，但总的思想都是一致的，就是在客户端页面增加伪随机数。

    通过验证码的方法

为简化用户使用提供技术支持（交互部分）

为多个浏览器兼容性提供支持

为提高用户浏览速度（浏览器性能）提供支持

为跨平台或者其他基于webkit或其他渲染引擎的应用提供支持

为展示数据提供支持（数据接口）

    AMD (Asynchronous Module Definition) 即异步模块加载机制 
      是 RequireJS 在推广过程中对模块定义的规范化产出。

    CMD (Common Module Definition) 
      是 SeaJS 在推广过程中对模块定义的规范化产出。

    AMD  是提前执行，CMD 是延迟执行。

    AMD 推荐的风格通过返回一个对象做为模块对象， CommonJS 的风格通过对 module.exports 或 exports 的属性赋值来达到暴露模块对象的目的。

  HBase    列结构
  Redis    键/值结构
  Virtusos 图状结构
  MongoDB  文档模型